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"
33 #include "m68k-tdep.h"
36 #define P_LINKL_FP 0x480e
37 #define P_LINKW_FP 0x4e56
38 #define P_PEA_FP 0x4856
39 #define P_MOVL_SP_FP 0x2c4f
44 #define P_MOVML 0x48ef
45 #define P_FMOVM 0xf237
49 #define REGISTER_BYTES_FP (16*4 + 8 + 8*12 + 3*4)
50 #define REGISTER_BYTES_NOFP (16*4 + 8)
52 #define NUM_FREGS (NUM_REGS-24)
54 /* Offset from SP to first arg on stack at first instruction of a function */
56 #define SP_ARG0 (1 * 4)
58 /* This was determined by experimentation on hp300 BSD 4.3. Perhaps
59 it corresponds to some offset in /usr/include/sys/user.h or
60 something like that. Using some system include file would
61 have the advantage of probably being more robust in the face
62 of OS upgrades, but the disadvantage of being wrong for
65 #define SIG_PC_FP_OFFSET 530
70 #if !defined (BPT_VECTOR)
71 #define BPT_VECTOR 0xf
74 #if !defined (REMOTE_BPT_VECTOR)
75 #define REMOTE_BPT_VECTOR 1
79 void m68k_frame_init_saved_regs (struct frame_info
*frame_info
);
82 /* gdbarch_breakpoint_from_pc is set to m68k_local_breakpoint_from_pc
83 so m68k_remote_breakpoint_from_pc is currently not used. */
85 const static unsigned char *
86 m68k_remote_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
88 static unsigned char break_insn
[] = {0x4e, (0x40 | REMOTE_BPT_VECTOR
)};
89 *lenptr
= sizeof (break_insn
);
93 const static unsigned char *
94 m68k_local_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
96 static unsigned char break_insn
[] = {0x4e, (0x40 | BPT_VECTOR
)};
97 *lenptr
= sizeof (break_insn
);
103 m68k_register_bytes_ok (long numbytes
)
105 return ((numbytes
== REGISTER_BYTES_FP
)
106 || (numbytes
== REGISTER_BYTES_NOFP
));
109 /* Number of bytes of storage in the actual machine representation
110 for register regnum. On the 68000, all regs are 4 bytes
111 except the floating point regs which are 12 bytes. */
112 /* Note that the unsigned cast here forces the result of the
113 subtraction to very high positive values if regnum < FP0_REGNUM */
116 m68k_register_raw_size (int regnum
)
118 return (((unsigned) (regnum
) - FP0_REGNUM
) < 8 ? 12 : 4);
121 /* Number of bytes of storage in the program's representation
122 for register regnum. On the 68000, all regs are 4 bytes
123 except the floating point regs which are 12-byte long doubles. */
126 m68k_register_virtual_size (int regnum
)
128 return (((unsigned) (regnum
) - FP0_REGNUM
) < 8 ? 12 : 4);
131 /* Return the GDB type object for the "standard" data type of data in
132 register N. This should be int for D0-D7, SR, FPCONTROL and
133 FPSTATUS, long double for FP0-FP7, and void pointer for all others
134 (A0-A7, PC, FPIADDR). Note, for registers which contain
135 addresses return pointer to void, not pointer to char, because we
136 don't want to attempt to print the string after printing the
140 m68k_register_virtual_type (int regnum
)
142 if (regnum
>= FP0_REGNUM
&& regnum
<= FP0_REGNUM
+ 7)
143 return builtin_type_m68881_ext
;
145 if (regnum
== M68K_FPI_REGNUM
|| regnum
== PC_REGNUM
)
146 return builtin_type_void_func_ptr
;
148 if (regnum
== M68K_FPC_REGNUM
|| regnum
== M68K_FPS_REGNUM
149 || regnum
== PS_REGNUM
)
150 return builtin_type_int32
;
152 if (regnum
>= M68K_A0_REGNUM
&& regnum
<= M68K_A0_REGNUM
+ 7)
153 return builtin_type_void_data_ptr
;
155 return builtin_type_int32
;
158 /* Function: m68k_register_name
159 Returns the name of the standard m68k register regnum. */
162 m68k_register_name (int regnum
)
164 static char *register_names
[] = {
165 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
166 "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp",
168 "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7",
169 "fpcontrol", "fpstatus", "fpiaddr", "fpcode", "fpflags"
173 regnum
>= sizeof (register_names
) / sizeof (register_names
[0]))
174 internal_error (__FILE__
, __LINE__
,
175 "m68k_register_name: illegal register number %d", regnum
);
177 return register_names
[regnum
];
180 /* Stack must be kept short aligned when doing function calls. */
183 m68k_stack_align (CORE_ADDR addr
)
185 return ((addr
+ 1) & ~1);
188 /* Index within `registers' of the first byte of the space for
192 m68k_register_byte (int regnum
)
194 if (regnum
>= M68K_FPC_REGNUM
)
195 return (((regnum
- M68K_FPC_REGNUM
) * 4) + 168);
196 else if (regnum
>= FP0_REGNUM
)
197 return (((regnum
- FP0_REGNUM
) * 12) + 72);
202 /* Store the address of the place in which to copy the structure the
203 subroutine will return. This is called from call_function. */
206 m68k_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
208 write_register (M68K_A1_REGNUM
, addr
);
211 /* Extract from an array regbuf containing the (raw) register state
212 a function return value of type type, and copy that, in virtual format,
213 into valbuf. This is assuming that floating point values are returned
214 as doubles in d0/d1. */
217 m68k_deprecated_extract_return_value (struct type
*type
, char *regbuf
,
221 int typeLength
= TYPE_LENGTH (type
);
224 offset
= 4 - typeLength
;
226 memcpy (valbuf
, regbuf
+ offset
, typeLength
);
230 m68k_deprecated_extract_struct_value_address (char *regbuf
)
232 return (*(CORE_ADDR
*) (regbuf
));
235 /* Write into appropriate registers a function return value
236 of type TYPE, given in virtual format. Assumes floats are passed
240 m68k_store_return_value (struct type
*type
, char *valbuf
)
242 deprecated_write_register_bytes (0, valbuf
, TYPE_LENGTH (type
));
245 /* Describe the pointer in each stack frame to the previous stack frame
248 /* DEPRECATED_FRAME_CHAIN takes a frame's nominal address and produces
249 the frame's chain-pointer. In the case of the 68000, the frame's
250 nominal address is the address of a 4-byte word containing the
251 calling frame's address. */
253 /* If we are chaining from sigtramp, then manufacture a sigtramp frame
254 (which isn't really on the stack. I'm not sure this is right for anything
255 but BSD4.3 on an hp300. */
258 m68k_frame_chain (struct frame_info
*thisframe
)
260 if (get_frame_type (thisframe
) == SIGTRAMP_FRAME
)
261 return get_frame_base (thisframe
);
262 else if (!inside_entry_file (get_frame_pc (thisframe
)))
263 return read_memory_unsigned_integer (get_frame_base (thisframe
), 4);
268 /* A function that tells us whether the function invocation represented
269 by fi does not have a frame on the stack associated with it. If it
270 does not, FRAMELESS is set to 1, else 0. */
273 m68k_frameless_function_invocation (struct frame_info
*fi
)
275 if (get_frame_type (fi
) == SIGTRAMP_FRAME
)
278 return frameless_look_for_prologue (fi
);
282 m68k_frame_saved_pc (struct frame_info
*frame
)
284 if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
286 if (get_next_frame (frame
))
287 return read_memory_unsigned_integer (get_frame_base (get_next_frame (frame
))
288 + SIG_PC_FP_OFFSET
, 4);
290 return read_memory_unsigned_integer (read_register (SP_REGNUM
)
291 + SIG_PC_FP_OFFSET
- 8, 4);
294 return read_memory_unsigned_integer (get_frame_base (frame
) + 4, 4);
298 /* The only reason this is here is the tm-altos.h reference below. It
299 was moved back here from tm-m68k.h. FIXME? */
302 altos_skip_prologue (CORE_ADDR pc
)
304 register int op
= read_memory_unsigned_integer (pc
, 2);
305 if (op
== P_LINKW_FP
)
306 pc
+= 4; /* Skip link #word */
307 else if (op
== P_LINKL_FP
)
308 pc
+= 6; /* Skip link #long */
309 /* Not sure why branches are here. */
310 /* From tm-altos.h */
311 else if (op
== 0060000)
312 pc
+= 4; /* Skip bra #word */
313 else if (op
== 00600377)
314 pc
+= 6; /* skip bra #long */
315 else if ((op
& 0177400) == 0060000)
316 pc
+= 2; /* skip bra #char */
321 delta68_in_sigtramp (CORE_ADDR pc
, char *name
)
324 return strcmp (name
, "_sigcode") == 0;
330 delta68_frame_args_address (struct frame_info
*frame_info
)
332 /* we assume here that the only frameless functions are the system calls
333 or other functions who do not put anything on the stack. */
334 if (get_frame_type (frame_info
) == SIGTRAMP_FRAME
)
335 return get_frame_base (frame_info
) + 12;
336 else if (frameless_look_for_prologue (frame_info
))
338 /* Check for an interrupted system call */
339 if (get_next_frame (frame_info
) && (get_frame_type (get_next_frame (frame_info
)) == SIGTRAMP_FRAME
))
340 return get_frame_base (get_next_frame (frame_info
)) + 16;
342 return get_frame_base (frame_info
) + 4;
345 return get_frame_base (frame_info
);
349 delta68_frame_saved_pc (struct frame_info
*frame_info
)
351 return read_memory_unsigned_integer (delta68_frame_args_address (frame_info
)
355 /* Return number of args passed to a frame.
356 Can return -1, meaning no way to tell. */
359 isi_frame_num_args (struct frame_info
*fi
)
362 CORE_ADDR pc
= DEPRECATED_FRAME_SAVED_PC (fi
);
363 int insn
= read_memory_unsigned_integer (pc
, 2);
365 if (insn
== 0047757 || insn
== 0157374) /* lea W(sp),sp or addaw #W,sp */
366 val
= read_memory_integer (pc
+ 2, 2);
367 else if ((insn
& 0170777) == 0050217 /* addql #N, sp */
368 || (insn
& 0170777) == 0050117) /* addqw */
370 val
= (insn
>> 9) & 7;
374 else if (insn
== 0157774) /* addal #WW, sp */
375 val
= read_memory_integer (pc
+ 2, 4);
381 delta68_frame_num_args (struct frame_info
*fi
)
384 CORE_ADDR pc
= DEPRECATED_FRAME_SAVED_PC (fi
);
385 int insn
= read_memory_unsigned_integer (pc
, 2);
387 if (insn
== 0047757 || insn
== 0157374) /* lea W(sp),sp or addaw #W,sp */
388 val
= read_memory_integer (pc
+ 2, 2);
389 else if ((insn
& 0170777) == 0050217 /* addql #N, sp */
390 || (insn
& 0170777) == 0050117) /* addqw */
392 val
= (insn
>> 9) & 7;
396 else if (insn
== 0157774) /* addal #WW, sp */
397 val
= read_memory_integer (pc
+ 2, 4);
403 news_frame_num_args (struct frame_info
*fi
)
406 CORE_ADDR pc
= DEPRECATED_FRAME_SAVED_PC (fi
);
407 int insn
= read_memory_unsigned_integer (pc
, 2);
409 if (insn
== 0047757 || insn
== 0157374) /* lea W(sp),sp or addaw #W,sp */
410 val
= read_memory_integer (pc
+ 2, 2);
411 else if ((insn
& 0170777) == 0050217 /* addql #N, sp */
412 || (insn
& 0170777) == 0050117) /* addqw */
414 val
= (insn
>> 9) & 7;
418 else if (insn
== 0157774) /* addal #WW, sp */
419 val
= read_memory_integer (pc
+ 2, 4);
424 /* Insert the specified number of args and function address
425 into a call sequence of the above form stored at DUMMYNAME.
426 We use the BFD routines to store a big-endian value of known size. */
429 m68k_fix_call_dummy (char *dummy
, CORE_ADDR pc
, CORE_ADDR fun
, int nargs
,
430 struct value
**args
, struct type
*type
, int gcc_p
)
432 bfd_putb32 (fun
, (unsigned char *) dummy
+ DEPRECATED_CALL_DUMMY_START_OFFSET
+ 2);
433 bfd_putb32 (nargs
* 4,
434 (unsigned char *) dummy
+ DEPRECATED_CALL_DUMMY_START_OFFSET
+ 8);
438 /* Push an empty stack frame, to record the current PC, etc. */
441 m68k_push_dummy_frame (void)
443 register CORE_ADDR sp
= read_register (SP_REGNUM
);
447 sp
= push_word (sp
, read_register (PC_REGNUM
));
448 sp
= push_word (sp
, read_register (DEPRECATED_FP_REGNUM
));
449 write_register (DEPRECATED_FP_REGNUM
, sp
);
451 /* Always save the floating-point registers, whether they exist on
452 this target or not. */
453 for (regnum
= FP0_REGNUM
+ 7; regnum
>= FP0_REGNUM
; regnum
--)
455 deprecated_read_register_bytes (REGISTER_BYTE (regnum
), raw_buffer
, 12);
456 sp
= push_bytes (sp
, raw_buffer
, 12);
459 for (regnum
= DEPRECATED_FP_REGNUM
- 1; regnum
>= 0; regnum
--)
461 sp
= push_word (sp
, read_register (regnum
));
463 sp
= push_word (sp
, read_register (PS_REGNUM
));
464 write_register (SP_REGNUM
, sp
);
467 /* Discard from the stack the innermost frame,
468 restoring all saved registers. */
471 m68k_pop_frame (void)
473 register struct frame_info
*frame
= get_current_frame ();
474 register CORE_ADDR fp
;
478 fp
= get_frame_base (frame
);
479 m68k_frame_init_saved_regs (frame
);
480 for (regnum
= FP0_REGNUM
+ 7; regnum
>= FP0_REGNUM
; regnum
--)
482 if (get_frame_saved_regs (frame
)[regnum
])
484 read_memory (get_frame_saved_regs (frame
)[regnum
], raw_buffer
, 12);
485 deprecated_write_register_bytes (REGISTER_BYTE (regnum
), raw_buffer
,
489 for (regnum
= DEPRECATED_FP_REGNUM
- 1; regnum
>= 0; regnum
--)
491 if (get_frame_saved_regs (frame
)[regnum
])
493 write_register (regnum
,
494 read_memory_integer (get_frame_saved_regs (frame
)[regnum
], 4));
497 if (get_frame_saved_regs (frame
)[PS_REGNUM
])
499 write_register (PS_REGNUM
,
500 read_memory_integer (get_frame_saved_regs (frame
)[PS_REGNUM
], 4));
502 write_register (DEPRECATED_FP_REGNUM
, read_memory_integer (fp
, 4));
503 write_register (PC_REGNUM
, read_memory_integer (fp
+ 4, 4));
504 write_register (SP_REGNUM
, fp
+ 8);
505 flush_cached_frames ();
509 /* Given an ip value corresponding to the start of a function,
510 return the ip of the first instruction after the function
511 prologue. This is the generic m68k support. Machines which
512 require something different can override the SKIP_PROLOGUE
513 macro to point elsewhere.
515 Some instructions which typically may appear in a function
518 A link instruction, word form:
520 link.w %a6,&0 4e56 XXXX
522 A link instruction, long form:
524 link.l %fp,&F%1 480e XXXX XXXX
526 A movm instruction to preserve integer regs:
528 movm.l &M%1,(4,%sp) 48ef XXXX XXXX
530 A fmovm instruction to preserve float regs:
532 fmovm &FPM%1,(FPO%1,%sp) f237 XXXX XXXX XXXX XXXX
534 Some profiling setup code (FIXME, not recognized yet):
536 lea.l (.L3,%pc),%a1 43fb XXXX XXXX XXXX
537 bsr _mcount 61ff XXXX XXXX
542 m68k_skip_prologue (CORE_ADDR ip
)
544 register CORE_ADDR limit
;
545 struct symtab_and_line sal
;
548 /* Find out if there is a known limit for the extent of the prologue.
549 If so, ensure we don't go past it. If not, assume "infinity". */
551 sal
= find_pc_line (ip
, 0);
552 limit
= (sal
.end
) ? sal
.end
: (CORE_ADDR
) ~0;
556 op
= read_memory_unsigned_integer (ip
, 2);
558 if (op
== P_LINKW_FP
)
559 ip
+= 4; /* Skip link.w */
560 else if (op
== P_PEA_FP
)
561 ip
+= 2; /* Skip pea %fp */
562 else if (op
== P_MOVL_SP_FP
)
563 ip
+= 2; /* Skip move.l %sp, %fp */
564 else if (op
== P_LINKL_FP
)
565 ip
+= 6; /* Skip link.l */
566 else if (op
== P_MOVML
)
567 ip
+= 6; /* Skip movm.l */
568 else if (op
== P_FMOVM
)
569 ip
+= 10; /* Skip fmovm */
571 break; /* Found unknown code, bail out. */
576 /* Store the addresses of the saved registers of the frame described by
577 FRAME_INFO in its saved_regs field.
578 This includes special registers such as pc and fp saved in special
579 ways in the stack frame. sp is even more special:
580 the address we return for it IS the sp for the next frame. */
583 m68k_frame_init_saved_regs (struct frame_info
*frame_info
)
586 register int regmask
;
587 register CORE_ADDR next_addr
;
588 register CORE_ADDR pc
;
590 /* First possible address for a pc in a call dummy for this frame. */
591 CORE_ADDR possible_call_dummy_start
=
592 get_frame_base (frame_info
) - 28 - DEPRECATED_FP_REGNUM
* 4 - 4 - 8 * 12;
596 if (get_frame_saved_regs (frame_info
))
599 frame_saved_regs_zalloc (frame_info
);
601 memset (get_frame_saved_regs (frame_info
), 0, SIZEOF_FRAME_SAVED_REGS
);
603 if (get_frame_pc (frame_info
) >= possible_call_dummy_start
604 && get_frame_pc (frame_info
) <= get_frame_base (frame_info
))
607 /* It is a call dummy. We could just stop now, since we know
608 what the call dummy saves and where. But this code proceeds
609 to parse the "prologue" which is part of the call dummy.
610 This is needlessly complex and confusing. FIXME. */
612 next_addr
= get_frame_base (frame_info
);
613 pc
= possible_call_dummy_start
;
617 pc
= get_frame_func (frame_info
);
619 nextinsn
= read_memory_unsigned_integer (pc
, 2);
620 if (P_PEA_FP
== nextinsn
621 && P_MOVL_SP_FP
== read_memory_unsigned_integer (pc
+ 2, 2))
625 next_addr
= get_frame_base (frame_info
);
628 else if (P_LINKL_FP
== nextinsn
)
630 /* Find the address above the saved
631 regs using the amount of storage from the link instruction. */
633 next_addr
= get_frame_base (frame_info
) + read_memory_integer (pc
+ 2, 4);
636 else if (P_LINKW_FP
== nextinsn
)
638 /* Find the address above the saved
639 regs using the amount of storage from the link instruction. */
641 next_addr
= get_frame_base (frame_info
) + read_memory_integer (pc
+ 2, 2);
647 /* If have an addal #-n, sp next, adjust next_addr. */
648 if (read_memory_unsigned_integer (pc
, 2) == 0157774)
649 next_addr
+= read_memory_integer (pc
+= 2, 4), pc
+= 4;
654 nextinsn
= read_memory_unsigned_integer (pc
, 2);
655 regmask
= read_memory_unsigned_integer (pc
+ 2, 2);
656 /* fmovemx to -(sp) */
657 if (0xf227 == nextinsn
&& (regmask
& 0xff00) == 0xe000)
659 /* Regmask's low bit is for register fp7, the first pushed */
660 for (regnum
= FP0_REGNUM
+ 8; --regnum
>= FP0_REGNUM
; regmask
>>= 1)
662 get_frame_saved_regs (frame_info
)[regnum
] = (next_addr
-= 12);
665 /* fmovemx to (fp + displacement) */
666 else if (0171056 == nextinsn
&& (regmask
& 0xff00) == 0xf000)
668 register CORE_ADDR addr
;
670 addr
= get_frame_base (frame_info
) + read_memory_integer (pc
+ 4, 2);
671 /* Regmask's low bit is for register fp7, the first pushed */
672 for (regnum
= FP0_REGNUM
+ 8; --regnum
>= FP0_REGNUM
; regmask
>>= 1)
675 get_frame_saved_regs (frame_info
)[regnum
] = addr
;
681 else if (0044327 == nextinsn
)
683 /* Regmask's low bit is for register 0, the first written */
684 for (regnum
= 0; regnum
< 16; regnum
++, regmask
>>= 1)
687 get_frame_saved_regs (frame_info
)[regnum
] = next_addr
;
692 /* moveml to (fp + displacement) */
693 else if (0044356 == nextinsn
)
695 register CORE_ADDR addr
;
697 addr
= get_frame_base (frame_info
) + read_memory_integer (pc
+ 4, 2);
698 /* Regmask's low bit is for register 0, the first written */
699 for (regnum
= 0; regnum
< 16; regnum
++, regmask
>>= 1)
702 get_frame_saved_regs (frame_info
)[regnum
] = addr
;
707 /* moveml to -(sp) */
708 else if (0044347 == nextinsn
)
710 /* Regmask's low bit is for register 15, the first pushed */
711 for (regnum
= 16; --regnum
>= 0; regmask
>>= 1)
713 get_frame_saved_regs (frame_info
)[regnum
] = (next_addr
-= 4);
717 else if (0x2f00 == (0xfff0 & nextinsn
))
719 regnum
= 0xf & nextinsn
;
720 get_frame_saved_regs (frame_info
)[regnum
] = (next_addr
-= 4);
723 /* fmovemx to index of sp */
724 else if (0xf236 == nextinsn
&& (regmask
& 0xff00) == 0xf000)
726 /* Regmask's low bit is for register fp0, the first written */
727 for (regnum
= FP0_REGNUM
+ 8; --regnum
>= FP0_REGNUM
; regmask
>>= 1)
730 get_frame_saved_regs (frame_info
)[regnum
] = next_addr
;
735 /* clrw -(sp); movw ccr,-(sp) */
736 else if (0x4267 == nextinsn
&& 0x42e7 == regmask
)
738 get_frame_saved_regs (frame_info
)[PS_REGNUM
] = (next_addr
-= 4);
745 get_frame_saved_regs (frame_info
)[SP_REGNUM
] = get_frame_base (frame_info
) + 8;
746 get_frame_saved_regs (frame_info
)[DEPRECATED_FP_REGNUM
] = get_frame_base (frame_info
);
747 get_frame_saved_regs (frame_info
)[PC_REGNUM
] = get_frame_base (frame_info
) + 4;
748 #ifdef SIG_SP_FP_OFFSET
749 /* Adjust saved SP_REGNUM for fake _sigtramp frames. */
750 if ((get_frame_type (frame_info
) == SIGTRAMP_FRAME
) && frame_info
->next
)
751 frame_info
->saved_regs
[SP_REGNUM
] =
752 frame_info
->next
->frame
+ SIG_SP_FP_OFFSET
;
757 #ifdef USE_PROC_FS /* Target dependent support for /proc */
759 #include <sys/procfs.h>
761 /* Prototypes for supply_gregset etc. */
764 /* The /proc interface divides the target machine's register set up into
765 two different sets, the general register set (gregset) and the floating
766 point register set (fpregset). For each set, there is an ioctl to get
767 the current register set and another ioctl to set the current values.
769 The actual structure passed through the ioctl interface is, of course,
770 naturally machine dependent, and is different for each set of registers.
771 For the m68k for example, the general register set is typically defined
774 typedef int gregset_t[18];
780 and the floating point set by:
782 typedef struct fpregset {
786 int f_fpregs[8][3]; (8 regs, 96 bits each)
789 These routines provide the packing and unpacking of gregset_t and
790 fpregset_t formatted data.
794 /* Atari SVR4 has R_SR but not R_PS */
796 #if !defined (R_PS) && defined (R_SR)
800 /* Given a pointer to a general register set in /proc format (gregset_t *),
801 unpack the register contents and supply them as gdb's idea of the current
805 supply_gregset (gregset_t
*gregsetp
)
808 register greg_t
*regp
= (greg_t
*) gregsetp
;
810 for (regi
= 0; regi
< R_PC
; regi
++)
812 supply_register (regi
, (char *) (regp
+ regi
));
814 supply_register (PS_REGNUM
, (char *) (regp
+ R_PS
));
815 supply_register (PC_REGNUM
, (char *) (regp
+ R_PC
));
819 fill_gregset (gregset_t
*gregsetp
, int regno
)
822 register greg_t
*regp
= (greg_t
*) gregsetp
;
824 for (regi
= 0; regi
< R_PC
; regi
++)
826 if ((regno
== -1) || (regno
== regi
))
828 *(regp
+ regi
) = *(int *) &deprecated_registers
[REGISTER_BYTE (regi
)];
831 if ((regno
== -1) || (regno
== PS_REGNUM
))
833 *(regp
+ R_PS
) = *(int *) &deprecated_registers
[REGISTER_BYTE (PS_REGNUM
)];
835 if ((regno
== -1) || (regno
== PC_REGNUM
))
837 *(regp
+ R_PC
) = *(int *) &deprecated_registers
[REGISTER_BYTE (PC_REGNUM
)];
841 #if defined (FP0_REGNUM)
843 /* Given a pointer to a floating point register set in /proc format
844 (fpregset_t *), unpack the register contents and supply them as gdb's
845 idea of the current floating point register values. */
848 supply_fpregset (fpregset_t
*fpregsetp
)
853 for (regi
= FP0_REGNUM
; regi
< M68K_FPC_REGNUM
; regi
++)
855 from
= (char *) &(fpregsetp
->f_fpregs
[regi
- FP0_REGNUM
][0]);
856 supply_register (regi
, from
);
858 supply_register (M68K_FPC_REGNUM
, (char *) &(fpregsetp
->f_pcr
));
859 supply_register (M68K_FPS_REGNUM
, (char *) &(fpregsetp
->f_psr
));
860 supply_register (M68K_FPI_REGNUM
, (char *) &(fpregsetp
->f_fpiaddr
));
863 /* Given a pointer to a floating point register set in /proc format
864 (fpregset_t *), update the register specified by REGNO from gdb's idea
865 of the current floating point register set. If REGNO is -1, update
869 fill_fpregset (fpregset_t
*fpregsetp
, int regno
)
875 for (regi
= FP0_REGNUM
; regi
< M68K_FPC_REGNUM
; regi
++)
877 if ((regno
== -1) || (regno
== regi
))
879 from
= (char *) &deprecated_registers
[REGISTER_BYTE (regi
)];
880 to
= (char *) &(fpregsetp
->f_fpregs
[regi
- FP0_REGNUM
][0]);
881 memcpy (to
, from
, REGISTER_RAW_SIZE (regi
));
884 if ((regno
== -1) || (regno
== M68K_FPC_REGNUM
))
886 fpregsetp
->f_pcr
= *(int *) &deprecated_registers
[REGISTER_BYTE (M68K_FPC_REGNUM
)];
888 if ((regno
== -1) || (regno
== M68K_FPS_REGNUM
))
890 fpregsetp
->f_psr
= *(int *) &deprecated_registers
[REGISTER_BYTE (M68K_FPS_REGNUM
)];
892 if ((regno
== -1) || (regno
== M68K_FPI_REGNUM
))
894 fpregsetp
->f_fpiaddr
= *(int *) &deprecated_registers
[REGISTER_BYTE (M68K_FPI_REGNUM
)];
898 #endif /* defined (FP0_REGNUM) */
900 #endif /* USE_PROC_FS */
902 /* Figure out where the longjmp will land. Slurp the args out of the stack.
903 We expect the first arg to be a pointer to the jmp_buf structure from which
904 we extract the pc (JB_PC) that we will land at. The pc is copied into PC.
905 This routine returns true on success. */
907 /* NOTE: cagney/2000-11-08: For this function to be fully multi-arched
908 the macro's JB_PC and JB_ELEMENT_SIZE would need to be moved into
909 the ``struct gdbarch_tdep'' object and then set on a target ISA/ABI
913 m68k_get_longjmp_target (CORE_ADDR
*pc
)
915 #if defined (JB_PC) && defined (JB_ELEMENT_SIZE)
917 CORE_ADDR sp
, jb_addr
;
919 buf
= alloca (TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
920 sp
= read_register (SP_REGNUM
);
922 if (target_read_memory (sp
+ SP_ARG0
, /* Offset of first arg on stack */
923 buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
))
926 jb_addr
= extract_address (buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
928 if (target_read_memory (jb_addr
+ JB_PC
* JB_ELEMENT_SIZE
, buf
,
929 TARGET_PTR_BIT
/ TARGET_CHAR_BIT
))
932 *pc
= extract_address (buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
936 internal_error (__FILE__
, __LINE__
,
937 "m68k_get_longjmp_target: not implemented");
942 /* Immediately after a function call, return the saved pc before the frame
943 is setup. For sun3's, we check for the common case of being inside of a
944 system call, and if so, we know that Sun pushes the call # on the stack
945 prior to doing the trap. */
948 m68k_saved_pc_after_call (struct frame_info
*frame
)
953 op
= read_memory_unsigned_integer (frame
->pc
- SYSCALL_TRAP_OFFSET
, 2);
955 if (op
== SYSCALL_TRAP
)
956 return read_memory_unsigned_integer (read_register (SP_REGNUM
) + 4, 4);
958 #endif /* SYSCALL_TRAP */
959 return read_memory_unsigned_integer (read_register (SP_REGNUM
), 4);
962 /* Function: m68k_gdbarch_init
963 Initializer function for the m68k gdbarch vector.
964 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
966 static struct gdbarch
*
967 m68k_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
969 static LONGEST call_dummy_words
[7] = { 0xf227e0ff, 0x48e7fffc, 0x426742e7,
970 0x4eb93232, 0x3232dffc, 0x69696969,
971 (0x4e404e71 | (BPT_VECTOR
<< 16))
973 struct gdbarch_tdep
*tdep
= NULL
;
974 struct gdbarch
*gdbarch
;
976 /* find a candidate among the list of pre-declared architectures. */
977 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
979 return (arches
->gdbarch
);
982 tdep
= (struct gdbarch_tdep
*) xmalloc (sizeof (struct gdbarch_tdep
));
985 gdbarch
= gdbarch_alloc (&info
, 0);
987 /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
988 ready to unwind the PC first (see frame.c:get_prev_frame()). */
989 set_gdbarch_deprecated_init_frame_pc (gdbarch
, init_frame_pc_default
);
991 set_gdbarch_long_double_format (gdbarch
, &floatformat_m68881_ext
);
992 set_gdbarch_long_double_bit (gdbarch
, 96);
994 set_gdbarch_function_start_offset (gdbarch
, 0);
996 set_gdbarch_skip_prologue (gdbarch
, m68k_skip_prologue
);
997 set_gdbarch_deprecated_saved_pc_after_call (gdbarch
, m68k_saved_pc_after_call
);
998 set_gdbarch_breakpoint_from_pc (gdbarch
, m68k_local_breakpoint_from_pc
);
1000 /* Stack grows down. */
1001 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1002 set_gdbarch_stack_align (gdbarch
, m68k_stack_align
);
1003 set_gdbarch_deprecated_extra_stack_alignment_needed (gdbarch
, 1);
1005 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
1006 set_gdbarch_decr_pc_after_break (gdbarch
, 2);
1008 set_gdbarch_deprecated_store_struct_return (gdbarch
, m68k_store_struct_return
);
1009 set_gdbarch_deprecated_extract_return_value (gdbarch
,
1010 m68k_deprecated_extract_return_value
);
1011 set_gdbarch_deprecated_store_return_value (gdbarch
, m68k_store_return_value
);
1013 set_gdbarch_deprecated_frame_chain (gdbarch
, m68k_frame_chain
);
1014 set_gdbarch_deprecated_frame_saved_pc (gdbarch
, m68k_frame_saved_pc
);
1015 set_gdbarch_deprecated_frame_init_saved_regs (gdbarch
, m68k_frame_init_saved_regs
);
1016 set_gdbarch_frameless_function_invocation (gdbarch
,
1017 m68k_frameless_function_invocation
);
1018 /* OK to default this value to 'unknown'. */
1019 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
1020 set_gdbarch_frame_args_skip (gdbarch
, 8);
1022 set_gdbarch_register_raw_size (gdbarch
, m68k_register_raw_size
);
1023 set_gdbarch_register_virtual_size (gdbarch
, m68k_register_virtual_size
);
1024 set_gdbarch_deprecated_max_register_raw_size (gdbarch
, 12);
1025 set_gdbarch_deprecated_max_register_virtual_size (gdbarch
, 12);
1026 set_gdbarch_register_virtual_type (gdbarch
, m68k_register_virtual_type
);
1027 set_gdbarch_register_name (gdbarch
, m68k_register_name
);
1028 set_gdbarch_deprecated_register_size (gdbarch
, 4);
1029 set_gdbarch_register_byte (gdbarch
, m68k_register_byte
);
1030 set_gdbarch_num_regs (gdbarch
, 29);
1031 set_gdbarch_register_bytes_ok (gdbarch
, m68k_register_bytes_ok
);
1032 set_gdbarch_deprecated_register_bytes (gdbarch
, (16 * 4 + 8 + 8 * 12 + 3 * 4));
1033 set_gdbarch_sp_regnum (gdbarch
, M68K_SP_REGNUM
);
1034 set_gdbarch_deprecated_fp_regnum (gdbarch
, M68K_FP_REGNUM
);
1035 set_gdbarch_pc_regnum (gdbarch
, M68K_PC_REGNUM
);
1036 set_gdbarch_ps_regnum (gdbarch
, M68K_PS_REGNUM
);
1037 set_gdbarch_fp0_regnum (gdbarch
, M68K_FP0_REGNUM
);
1039 set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch
, 0);
1040 set_gdbarch_call_dummy_location (gdbarch
, ON_STACK
);
1041 set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch
, 24);
1042 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch
, deprecated_pc_in_call_dummy_on_stack
);
1043 set_gdbarch_deprecated_call_dummy_length (gdbarch
, 28);
1044 set_gdbarch_deprecated_call_dummy_start_offset (gdbarch
, 12);
1046 set_gdbarch_deprecated_call_dummy_words (gdbarch
, call_dummy_words
);
1047 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch
, sizeof (call_dummy_words
));
1048 set_gdbarch_deprecated_fix_call_dummy (gdbarch
, m68k_fix_call_dummy
);
1049 set_gdbarch_deprecated_push_dummy_frame (gdbarch
, m68k_push_dummy_frame
);
1050 set_gdbarch_deprecated_pop_frame (gdbarch
, m68k_pop_frame
);
1052 /* Should be using push_dummy_call. */
1053 set_gdbarch_deprecated_dummy_write_sp (gdbarch
, generic_target_write_sp
);
1060 m68k_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
1066 _initialize_m68k_tdep (void)
1068 gdbarch_register (bfd_arch_m68k
, m68k_gdbarch_init
, m68k_dump_tdep
);
1069 deprecated_tm_print_insn
= print_insn_m68k
;