1 /* Target dependent code for the Motorola 68000 series.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1999, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
27 #include "gdb_string.h"
30 #include "arch-utils.h"
33 #define P_LINKL_FP 0x480e
34 #define P_LINKW_FP 0x4e56
35 #define P_PEA_FP 0x4856
36 #define P_MOVL_SP_FP 0x2c4f
41 #define P_MOVML 0x48ef
42 #define P_FMOVM 0xf237
45 void m68k_frame_init_saved_regs (struct frame_info
*frame_info
);
48 m68k_register_bytes_ok (numbytes
)
50 return ((numbytes
== REGISTER_BYTES_FP
)
51 || (numbytes
== REGISTER_BYTES_NOFP
));
54 /* Number of bytes of storage in the actual machine representation
55 for register regnum. On the 68000, all regs are 4 bytes
56 except the floating point regs which are 12 bytes. */
57 /* Note that the unsigned cast here forces the result of the
58 subtraction to very high positive values if regnum < FP0_REGNUM */
61 m68k_register_raw_size (int regnum
)
63 return (((unsigned) (regnum
) - FP0_REGNUM
) < 8 ? 12 : 4);
66 /* Number of bytes of storage in the program's representation
67 for register regnum. On the 68000, all regs are 4 bytes
68 except the floating point regs which are 12-byte long doubles. */
71 m68k_register_virtual_size (int regnum
)
73 return (((unsigned) (regnum
) - FP0_REGNUM
) < 8 ? 12 : 4);
76 /* Return the GDB type object for the "standard" data type of data
77 in register N. This should be int for D0-D7, long double for FP0-FP7,
78 and void pointer for all others (A0-A7, PC, SR, FPCONTROL etc).
79 Note, for registers which contain addresses return pointer to void,
80 not pointer to char, because we don't want to attempt to print
81 the string after printing the address. */
84 m68k_register_virtual_type (int regnum
)
86 if ((unsigned) regnum
>= FPC_REGNUM
)
87 return lookup_pointer_type (builtin_type_void
);
88 else if ((unsigned) regnum
>= FP0_REGNUM
)
89 return builtin_type_long_double
;
90 else if ((unsigned) regnum
>= A0_REGNUM
)
91 return lookup_pointer_type (builtin_type_void
);
93 return builtin_type_int
;
96 /* Function: m68k_register_name
97 Returns the name of the standard m68k register regnum. */
100 m68k_register_name (int regnum
)
102 static char *register_names
[] = {
103 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
104 "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp",
106 "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7",
107 "fpcontrol", "fpstatus", "fpiaddr", "fpcode", "fpflags"
111 regnum
>= sizeof (register_names
) / sizeof (register_names
[0]))
112 internal_error (__FILE__
, __LINE__
,
113 "m68k_register_name: illegal register number %d", regnum
);
115 return register_names
[regnum
];
118 /* Stack must be kept short aligned when doing function calls. */
121 m68k_stack_align (CORE_ADDR addr
)
123 return ((addr
+ 1) & ~1);
126 /* Index within `registers' of the first byte of the space for
130 m68k_register_byte (int regnum
)
132 if (regnum
>= FPC_REGNUM
)
133 return (((regnum
- FPC_REGNUM
) * 4) + 168);
134 else if (regnum
>= FP0_REGNUM
)
135 return (((regnum
- FP0_REGNUM
) * 12) + 72);
140 /* Store the address of the place in which to copy the structure the
141 subroutine will return. This is called from call_function. */
144 m68k_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
146 write_register (A1_REGNUM
, addr
);
149 /* Extract from an array regbuf containing the (raw) register state
150 a function return value of type type, and copy that, in virtual format,
151 into valbuf. This is assuming that floating point values are returned
152 as doubles in d0/d1. */
155 m68k_deprecated_extract_return_value (struct type
*type
, char *regbuf
,
159 int typeLength
= TYPE_LENGTH (type
);
162 offset
= 4 - typeLength
;
164 memcpy (valbuf
, regbuf
+ offset
, typeLength
);
168 m68k_deprecated_extract_struct_value_address (char *regbuf
)
170 return (*(CORE_ADDR
*) (regbuf
));
173 /* Write into appropriate registers a function return value
174 of type TYPE, given in virtual format. Assumes floats are passed
178 m68k_store_return_value (struct type
*type
, char *valbuf
)
180 write_register_bytes (0, valbuf
, TYPE_LENGTH (type
));
183 /* Describe the pointer in each stack frame to the previous stack frame
186 /* FRAME_CHAIN takes a frame's nominal address and produces the frame's
188 In the case of the 68000, the frame's nominal address
189 is the address of a 4-byte word containing the calling frame's address. */
191 /* If we are chaining from sigtramp, then manufacture a sigtramp frame
192 (which isn't really on the stack. I'm not sure this is right for anything
193 but BSD4.3 on an hp300. */
196 m68k_frame_chain (struct frame_info
*thisframe
)
198 if (thisframe
->signal_handler_caller
)
199 return thisframe
->frame
;
200 else if (!inside_entry_file ((thisframe
)->pc
))
201 return read_memory_integer ((thisframe
)->frame
, 4);
206 /* A function that tells us whether the function invocation represented
207 by fi does not have a frame on the stack associated with it. If it
208 does not, FRAMELESS is set to 1, else 0. */
211 m68k_frameless_function_invocation (struct frame_info
*fi
)
213 if (fi
->signal_handler_caller
)
216 return frameless_look_for_prologue (fi
);
220 m68k_frame_saved_pc (struct frame_info
*frame
)
222 if (frame
->signal_handler_caller
)
225 return read_memory_integer (frame
->next
->frame
+ SIG_PC_FP_OFFSET
, 4);
227 return read_memory_integer (read_register (SP_REGNUM
)
228 + SIG_PC_FP_OFFSET
- 8, 4);
231 return read_memory_integer (frame
->frame
+ 4, 4);
235 /* The only reason this is here is the tm-altos.h reference below. It
236 was moved back here from tm-m68k.h. FIXME? */
239 altos_skip_prologue (CORE_ADDR pc
)
241 register int op
= read_memory_integer (pc
, 2);
242 if (op
== P_LINKW_FP
)
243 pc
+= 4; /* Skip link #word */
244 else if (op
== P_LINKL_FP
)
245 pc
+= 6; /* Skip link #long */
246 /* Not sure why branches are here. */
247 /* From tm-altos.h */
248 else if (op
== 0060000)
249 pc
+= 4; /* Skip bra #word */
250 else if (op
== 00600377)
251 pc
+= 6; /* skip bra #long */
252 else if ((op
& 0177400) == 0060000)
253 pc
+= 2; /* skip bra #char */
258 delta68_in_sigtramp (CORE_ADDR pc
, char *name
)
261 return strcmp (name
, "_sigcode") == 0;
267 delta68_frame_args_address (struct frame_info
*frame_info
)
269 /* we assume here that the only frameless functions are the system calls
270 or other functions who do not put anything on the stack. */
271 if (frame_info
->signal_handler_caller
)
272 return frame_info
->frame
+ 12;
273 else if (frameless_look_for_prologue (frame_info
))
275 /* Check for an interrupted system call */
276 if (frame_info
->next
&& frame_info
->next
->signal_handler_caller
)
277 return frame_info
->next
->frame
+ 16;
279 return frame_info
->frame
+ 4;
282 return frame_info
->frame
;
286 delta68_frame_saved_pc (struct frame_info
*frame_info
)
288 return read_memory_integer (delta68_frame_args_address (frame_info
) + 4, 4);
291 /* Return number of args passed to a frame.
292 Can return -1, meaning no way to tell. */
295 isi_frame_num_args (struct frame_info
*fi
)
298 CORE_ADDR pc
= FRAME_SAVED_PC (fi
);
299 int insn
= 0177777 & read_memory_integer (pc
, 2);
301 if (insn
== 0047757 || insn
== 0157374) /* lea W(sp),sp or addaw #W,sp */
302 val
= read_memory_integer (pc
+ 2, 2);
303 else if ((insn
& 0170777) == 0050217 /* addql #N, sp */
304 || (insn
& 0170777) == 0050117) /* addqw */
306 val
= (insn
>> 9) & 7;
310 else if (insn
== 0157774) /* addal #WW, sp */
311 val
= read_memory_integer (pc
+ 2, 4);
317 delta68_frame_num_args (struct frame_info
*fi
)
320 CORE_ADDR pc
= FRAME_SAVED_PC (fi
);
321 int insn
= 0177777 & read_memory_integer (pc
, 2);
323 if (insn
== 0047757 || insn
== 0157374) /* lea W(sp),sp or addaw #W,sp */
324 val
= read_memory_integer (pc
+ 2, 2);
325 else if ((insn
& 0170777) == 0050217 /* addql #N, sp */
326 || (insn
& 0170777) == 0050117) /* addqw */
328 val
= (insn
>> 9) & 7;
332 else if (insn
== 0157774) /* addal #WW, sp */
333 val
= read_memory_integer (pc
+ 2, 4);
339 news_frame_num_args (struct frame_info
*fi
)
342 CORE_ADDR pc
= FRAME_SAVED_PC (fi
);
343 int insn
= 0177777 & read_memory_integer (pc
, 2);
345 if (insn
== 0047757 || insn
== 0157374) /* lea W(sp),sp or addaw #W,sp */
346 val
= read_memory_integer (pc
+ 2, 2);
347 else if ((insn
& 0170777) == 0050217 /* addql #N, sp */
348 || (insn
& 0170777) == 0050117) /* addqw */
350 val
= (insn
>> 9) & 7;
354 else if (insn
== 0157774) /* addal #WW, sp */
355 val
= read_memory_integer (pc
+ 2, 4);
360 /* Insert the specified number of args and function address
361 into a call sequence of the above form stored at DUMMYNAME.
362 We use the BFD routines to store a big-endian value of known size. */
365 m68k_fix_call_dummy (char *dummy
, CORE_ADDR pc
, CORE_ADDR fun
, int nargs
,
366 struct value
**args
, struct type
*type
, int gcc_p
)
368 bfd_putb32 (fun
, (unsigned char *) dummy
+ CALL_DUMMY_START_OFFSET
+ 2);
369 bfd_putb32 (nargs
* 4,
370 (unsigned char *) dummy
+ CALL_DUMMY_START_OFFSET
+ 8);
374 /* Push an empty stack frame, to record the current PC, etc. */
377 m68k_push_dummy_frame (void)
379 register CORE_ADDR sp
= read_register (SP_REGNUM
);
383 sp
= push_word (sp
, read_register (PC_REGNUM
));
384 sp
= push_word (sp
, read_register (FP_REGNUM
));
385 write_register (FP_REGNUM
, sp
);
387 /* Always save the floating-point registers, whether they exist on
388 this target or not. */
389 for (regnum
= FP0_REGNUM
+ 7; regnum
>= FP0_REGNUM
; regnum
--)
391 read_register_bytes (REGISTER_BYTE (regnum
), raw_buffer
, 12);
392 sp
= push_bytes (sp
, raw_buffer
, 12);
395 for (regnum
= FP_REGNUM
- 1; regnum
>= 0; regnum
--)
397 sp
= push_word (sp
, read_register (regnum
));
399 sp
= push_word (sp
, read_register (PS_REGNUM
));
400 write_register (SP_REGNUM
, sp
);
403 /* Discard from the stack the innermost frame,
404 restoring all saved registers. */
407 m68k_pop_frame (void)
409 register struct frame_info
*frame
= get_current_frame ();
410 register CORE_ADDR fp
;
414 fp
= FRAME_FP (frame
);
415 m68k_frame_init_saved_regs (frame
);
416 for (regnum
= FP0_REGNUM
+ 7; regnum
>= FP0_REGNUM
; regnum
--)
418 if (frame
->saved_regs
[regnum
])
420 read_memory (frame
->saved_regs
[regnum
], raw_buffer
, 12);
421 write_register_bytes (REGISTER_BYTE (regnum
), raw_buffer
, 12);
424 for (regnum
= FP_REGNUM
- 1; regnum
>= 0; regnum
--)
426 if (frame
->saved_regs
[regnum
])
428 write_register (regnum
,
429 read_memory_integer (frame
->saved_regs
[regnum
], 4));
432 if (frame
->saved_regs
[PS_REGNUM
])
434 write_register (PS_REGNUM
,
435 read_memory_integer (frame
->saved_regs
[PS_REGNUM
], 4));
437 write_register (FP_REGNUM
, read_memory_integer (fp
, 4));
438 write_register (PC_REGNUM
, read_memory_integer (fp
+ 4, 4));
439 write_register (SP_REGNUM
, fp
+ 8);
440 flush_cached_frames ();
444 /* Given an ip value corresponding to the start of a function,
445 return the ip of the first instruction after the function
446 prologue. This is the generic m68k support. Machines which
447 require something different can override the SKIP_PROLOGUE
448 macro to point elsewhere.
450 Some instructions which typically may appear in a function
453 A link instruction, word form:
455 link.w %a6,&0 4e56 XXXX
457 A link instruction, long form:
459 link.l %fp,&F%1 480e XXXX XXXX
461 A movm instruction to preserve integer regs:
463 movm.l &M%1,(4,%sp) 48ef XXXX XXXX
465 A fmovm instruction to preserve float regs:
467 fmovm &FPM%1,(FPO%1,%sp) f237 XXXX XXXX XXXX XXXX
469 Some profiling setup code (FIXME, not recognized yet):
471 lea.l (.L3,%pc),%a1 43fb XXXX XXXX XXXX
472 bsr _mcount 61ff XXXX XXXX
477 m68k_skip_prologue (CORE_ADDR ip
)
479 register CORE_ADDR limit
;
480 struct symtab_and_line sal
;
483 /* Find out if there is a known limit for the extent of the prologue.
484 If so, ensure we don't go past it. If not, assume "infinity". */
486 sal
= find_pc_line (ip
, 0);
487 limit
= (sal
.end
) ? sal
.end
: (CORE_ADDR
) ~0;
491 op
= read_memory_integer (ip
, 2);
494 if (op
== P_LINKW_FP
)
495 ip
+= 4; /* Skip link.w */
496 else if (op
== P_PEA_FP
)
497 ip
+= 2; /* Skip pea %fp */
498 else if (op
== P_MOVL_SP_FP
)
499 ip
+= 2; /* Skip move.l %sp, %fp */
500 else if (op
== P_LINKL_FP
)
501 ip
+= 6; /* Skip link.l */
502 else if (op
== P_MOVML
)
503 ip
+= 6; /* Skip movm.l */
504 else if (op
== P_FMOVM
)
505 ip
+= 10; /* Skip fmovm */
507 break; /* Found unknown code, bail out. */
512 /* Store the addresses of the saved registers of the frame described by
513 FRAME_INFO in its saved_regs field.
514 This includes special registers such as pc and fp saved in special
515 ways in the stack frame. sp is even more special:
516 the address we return for it IS the sp for the next frame. */
519 m68k_frame_init_saved_regs (struct frame_info
*frame_info
)
522 register int regmask
;
523 register CORE_ADDR next_addr
;
524 register CORE_ADDR pc
;
526 /* First possible address for a pc in a call dummy for this frame. */
527 CORE_ADDR possible_call_dummy_start
=
528 (frame_info
)->frame
- 28 - FP_REGNUM
* 4 - 4 - 8 * 12;
532 if (frame_info
->saved_regs
)
535 frame_saved_regs_zalloc (frame_info
);
537 memset (frame_info
->saved_regs
, 0, SIZEOF_FRAME_SAVED_REGS
);
539 if ((frame_info
)->pc
>= possible_call_dummy_start
540 && (frame_info
)->pc
<= (frame_info
)->frame
)
543 /* It is a call dummy. We could just stop now, since we know
544 what the call dummy saves and where. But this code proceeds
545 to parse the "prologue" which is part of the call dummy.
546 This is needlessly complex and confusing. FIXME. */
548 next_addr
= (frame_info
)->frame
;
549 pc
= possible_call_dummy_start
;
553 pc
= get_pc_function_start ((frame_info
)->pc
);
555 nextinsn
= read_memory_integer (pc
, 2);
556 if (P_PEA_FP
== nextinsn
557 && P_MOVL_SP_FP
== read_memory_integer (pc
+ 2, 2))
561 next_addr
= frame_info
->frame
;
564 else if (P_LINKL_FP
== nextinsn
)
566 /* Find the address above the saved
567 regs using the amount of storage from the link instruction. */
569 next_addr
= (frame_info
)->frame
+ read_memory_integer (pc
+ 2, 4);
572 else if (P_LINKW_FP
== nextinsn
)
574 /* Find the address above the saved
575 regs using the amount of storage from the link instruction. */
577 next_addr
= (frame_info
)->frame
+ read_memory_integer (pc
+ 2, 2);
583 /* If have an addal #-n, sp next, adjust next_addr. */
584 if ((0177777 & read_memory_integer (pc
, 2)) == 0157774)
585 next_addr
+= read_memory_integer (pc
+= 2, 4), pc
+= 4;
590 nextinsn
= 0xffff & read_memory_integer (pc
, 2);
591 regmask
= read_memory_integer (pc
+ 2, 2);
592 /* fmovemx to -(sp) */
593 if (0xf227 == nextinsn
&& (regmask
& 0xff00) == 0xe000)
595 /* Regmask's low bit is for register fp7, the first pushed */
596 for (regnum
= FP0_REGNUM
+ 8; --regnum
>= FP0_REGNUM
; regmask
>>= 1)
598 frame_info
->saved_regs
[regnum
] = (next_addr
-= 12);
601 /* fmovemx to (fp + displacement) */
602 else if (0171056 == nextinsn
&& (regmask
& 0xff00) == 0xf000)
604 register CORE_ADDR addr
;
606 addr
= (frame_info
)->frame
+ read_memory_integer (pc
+ 4, 2);
607 /* Regmask's low bit is for register fp7, the first pushed */
608 for (regnum
= FP0_REGNUM
+ 8; --regnum
>= FP0_REGNUM
; regmask
>>= 1)
611 frame_info
->saved_regs
[regnum
] = addr
;
617 else if (0044327 == nextinsn
)
619 /* Regmask's low bit is for register 0, the first written */
620 for (regnum
= 0; regnum
< 16; regnum
++, regmask
>>= 1)
623 frame_info
->saved_regs
[regnum
] = next_addr
;
628 /* moveml to (fp + displacement) */
629 else if (0044356 == nextinsn
)
631 register CORE_ADDR addr
;
633 addr
= (frame_info
)->frame
+ read_memory_integer (pc
+ 4, 2);
634 /* Regmask's low bit is for register 0, the first written */
635 for (regnum
= 0; regnum
< 16; regnum
++, regmask
>>= 1)
638 frame_info
->saved_regs
[regnum
] = addr
;
643 /* moveml to -(sp) */
644 else if (0044347 == nextinsn
)
646 /* Regmask's low bit is for register 15, the first pushed */
647 for (regnum
= 16; --regnum
>= 0; regmask
>>= 1)
649 frame_info
->saved_regs
[regnum
] = (next_addr
-= 4);
653 else if (0x2f00 == (0xfff0 & nextinsn
))
655 regnum
= 0xf & nextinsn
;
656 frame_info
->saved_regs
[regnum
] = (next_addr
-= 4);
659 /* fmovemx to index of sp */
660 else if (0xf236 == nextinsn
&& (regmask
& 0xff00) == 0xf000)
662 /* Regmask's low bit is for register fp0, the first written */
663 for (regnum
= FP0_REGNUM
+ 8; --regnum
>= FP0_REGNUM
; regmask
>>= 1)
666 frame_info
->saved_regs
[regnum
] = next_addr
;
671 /* clrw -(sp); movw ccr,-(sp) */
672 else if (0x4267 == nextinsn
&& 0x42e7 == regmask
)
674 frame_info
->saved_regs
[PS_REGNUM
] = (next_addr
-= 4);
681 frame_info
->saved_regs
[SP_REGNUM
] = (frame_info
)->frame
+ 8;
682 frame_info
->saved_regs
[FP_REGNUM
] = (frame_info
)->frame
;
683 frame_info
->saved_regs
[PC_REGNUM
] = (frame_info
)->frame
+ 4;
684 #ifdef SIG_SP_FP_OFFSET
685 /* Adjust saved SP_REGNUM for fake _sigtramp frames. */
686 if (frame_info
->signal_handler_caller
&& frame_info
->next
)
687 frame_info
->saved_regs
[SP_REGNUM
] =
688 frame_info
->next
->frame
+ SIG_SP_FP_OFFSET
;
693 #ifdef USE_PROC_FS /* Target dependent support for /proc */
695 #include <sys/procfs.h>
697 /* Prototypes for supply_gregset etc. */
700 /* The /proc interface divides the target machine's register set up into
701 two different sets, the general register set (gregset) and the floating
702 point register set (fpregset). For each set, there is an ioctl to get
703 the current register set and another ioctl to set the current values.
705 The actual structure passed through the ioctl interface is, of course,
706 naturally machine dependent, and is different for each set of registers.
707 For the m68k for example, the general register set is typically defined
710 typedef int gregset_t[18];
716 and the floating point set by:
718 typedef struct fpregset {
722 int f_fpregs[8][3]; (8 regs, 96 bits each)
725 These routines provide the packing and unpacking of gregset_t and
726 fpregset_t formatted data.
730 /* Atari SVR4 has R_SR but not R_PS */
732 #if !defined (R_PS) && defined (R_SR)
736 /* Given a pointer to a general register set in /proc format (gregset_t *),
737 unpack the register contents and supply them as gdb's idea of the current
741 supply_gregset (gregset_t
*gregsetp
)
744 register greg_t
*regp
= (greg_t
*) gregsetp
;
746 for (regi
= 0; regi
< R_PC
; regi
++)
748 supply_register (regi
, (char *) (regp
+ regi
));
750 supply_register (PS_REGNUM
, (char *) (regp
+ R_PS
));
751 supply_register (PC_REGNUM
, (char *) (regp
+ R_PC
));
755 fill_gregset (gregset_t
*gregsetp
, int regno
)
758 register greg_t
*regp
= (greg_t
*) gregsetp
;
760 for (regi
= 0; regi
< R_PC
; regi
++)
762 if ((regno
== -1) || (regno
== regi
))
764 *(regp
+ regi
) = *(int *) ®isters
[REGISTER_BYTE (regi
)];
767 if ((regno
== -1) || (regno
== PS_REGNUM
))
769 *(regp
+ R_PS
) = *(int *) ®isters
[REGISTER_BYTE (PS_REGNUM
)];
771 if ((regno
== -1) || (regno
== PC_REGNUM
))
773 *(regp
+ R_PC
) = *(int *) ®isters
[REGISTER_BYTE (PC_REGNUM
)];
777 #if defined (FP0_REGNUM)
779 /* Given a pointer to a floating point register set in /proc format
780 (fpregset_t *), unpack the register contents and supply them as gdb's
781 idea of the current floating point register values. */
784 supply_fpregset (fpregset_t
*fpregsetp
)
789 for (regi
= FP0_REGNUM
; regi
< FPC_REGNUM
; regi
++)
791 from
= (char *) &(fpregsetp
->f_fpregs
[regi
- FP0_REGNUM
][0]);
792 supply_register (regi
, from
);
794 supply_register (FPC_REGNUM
, (char *) &(fpregsetp
->f_pcr
));
795 supply_register (FPS_REGNUM
, (char *) &(fpregsetp
->f_psr
));
796 supply_register (FPI_REGNUM
, (char *) &(fpregsetp
->f_fpiaddr
));
799 /* Given a pointer to a floating point register set in /proc format
800 (fpregset_t *), update the register specified by REGNO from gdb's idea
801 of the current floating point register set. If REGNO is -1, update
805 fill_fpregset (fpregset_t
*fpregsetp
, int regno
)
811 for (regi
= FP0_REGNUM
; regi
< FPC_REGNUM
; regi
++)
813 if ((regno
== -1) || (regno
== regi
))
815 from
= (char *) ®isters
[REGISTER_BYTE (regi
)];
816 to
= (char *) &(fpregsetp
->f_fpregs
[regi
- FP0_REGNUM
][0]);
817 memcpy (to
, from
, REGISTER_RAW_SIZE (regi
));
820 if ((regno
== -1) || (regno
== FPC_REGNUM
))
822 fpregsetp
->f_pcr
= *(int *) ®isters
[REGISTER_BYTE (FPC_REGNUM
)];
824 if ((regno
== -1) || (regno
== FPS_REGNUM
))
826 fpregsetp
->f_psr
= *(int *) ®isters
[REGISTER_BYTE (FPS_REGNUM
)];
828 if ((regno
== -1) || (regno
== FPI_REGNUM
))
830 fpregsetp
->f_fpiaddr
= *(int *) ®isters
[REGISTER_BYTE (FPI_REGNUM
)];
834 #endif /* defined (FP0_REGNUM) */
836 #endif /* USE_PROC_FS */
838 /* Figure out where the longjmp will land. Slurp the args out of the stack.
839 We expect the first arg to be a pointer to the jmp_buf structure from which
840 we extract the pc (JB_PC) that we will land at. The pc is copied into PC.
841 This routine returns true on success. */
843 /* NOTE: cagney/2000-11-08: For this function to be fully multi-arched
844 the macro's JB_PC and JB_ELEMENT_SIZE would need to be moved into
845 the ``struct gdbarch_tdep'' object and then set on a target ISA/ABI
849 m68k_get_longjmp_target (CORE_ADDR
*pc
)
851 #if defined (JB_PC) && defined (JB_ELEMENT_SIZE)
853 CORE_ADDR sp
, jb_addr
;
855 buf
= alloca (TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
856 sp
= read_register (SP_REGNUM
);
858 if (target_read_memory (sp
+ SP_ARG0
, /* Offset of first arg on stack */
859 buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
))
862 jb_addr
= extract_address (buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
864 if (target_read_memory (jb_addr
+ JB_PC
* JB_ELEMENT_SIZE
, buf
,
865 TARGET_PTR_BIT
/ TARGET_CHAR_BIT
))
868 *pc
= extract_address (buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
872 internal_error (__FILE__
, __LINE__
,
873 "m68k_get_longjmp_target: not implemented");
878 /* Immediately after a function call, return the saved pc before the frame
879 is setup. For sun3's, we check for the common case of being inside of a
880 system call, and if so, we know that Sun pushes the call # on the stack
881 prior to doing the trap. */
884 m68k_saved_pc_after_call (struct frame_info
*frame
)
889 op
= read_memory_integer (frame
->pc
- SYSCALL_TRAP_OFFSET
, 2);
891 if (op
== SYSCALL_TRAP
)
892 return read_memory_integer (read_register (SP_REGNUM
) + 4, 4);
894 #endif /* SYSCALL_TRAP */
895 return read_memory_integer (read_register (SP_REGNUM
), 4);
898 /* Function: m68k_gdbarch_init
899 Initializer function for the m68k gdbarch vector.
900 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
902 static struct gdbarch
*
903 m68k_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
905 static LONGEST call_dummy_words
[7] = { 0xf227e0ff, 0x48e7fffc, 0x426742e7,
906 0x4eb93232, 0x3232dffc, 0x69696969,
907 (0x4e404e71 | (BPT_VECTOR
<< 16))
909 struct gdbarch_tdep
*tdep
= NULL
;
910 struct gdbarch
*gdbarch
;
912 /* find a candidate among the list of pre-declared architectures. */
913 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
915 return (arches
->gdbarch
);
918 tdep
= (struct gdbarch_tdep
*) xmalloc (sizeof (struct gdbarch_tdep
));
921 gdbarch
= gdbarch_alloc (&info
, 0);
923 set_gdbarch_long_double_format (gdbarch
, &floatformat_m68881_ext
);
924 set_gdbarch_long_double_bit (gdbarch
, 96);
926 set_gdbarch_function_start_offset (gdbarch
, 0);
928 set_gdbarch_skip_prologue (gdbarch
, m68k_skip_prologue
);
929 set_gdbarch_saved_pc_after_call (gdbarch
, m68k_saved_pc_after_call
);
931 /* Stack grows down. */
932 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
933 set_gdbarch_stack_align (gdbarch
, m68k_stack_align
);
935 set_gdbarch_decr_pc_after_break (gdbarch
, 2);
937 set_gdbarch_store_struct_return (gdbarch
, m68k_store_struct_return
);
938 set_gdbarch_deprecated_extract_return_value (gdbarch
,
939 m68k_deprecated_extract_return_value
);
940 set_gdbarch_store_return_value (gdbarch
, m68k_store_return_value
);
942 set_gdbarch_frame_chain (gdbarch
, m68k_frame_chain
);
943 set_gdbarch_frame_saved_pc (gdbarch
, m68k_frame_saved_pc
);
944 set_gdbarch_frame_init_saved_regs (gdbarch
, m68k_frame_init_saved_regs
);
945 set_gdbarch_frameless_function_invocation (gdbarch
,
946 m68k_frameless_function_invocation
);
948 set_gdbarch_register_raw_size (gdbarch
, m68k_register_raw_size
);
949 set_gdbarch_register_virtual_size (gdbarch
, m68k_register_virtual_size
);
950 set_gdbarch_max_register_raw_size (gdbarch
, 12);
951 set_gdbarch_max_register_virtual_size (gdbarch
, 12);
952 set_gdbarch_register_virtual_type (gdbarch
, m68k_register_virtual_type
);
953 set_gdbarch_register_name (gdbarch
, m68k_register_name
);
954 set_gdbarch_register_size (gdbarch
, 4);
955 set_gdbarch_register_byte (gdbarch
, m68k_register_byte
);
956 set_gdbarch_num_regs (gdbarch
, 29);
957 set_gdbarch_register_bytes_ok (gdbarch
, m68k_register_bytes_ok
);
958 set_gdbarch_register_bytes (gdbarch
, (16 * 4 + 8 + 8 * 12 + 3 * 4));
960 set_gdbarch_use_generic_dummy_frames (gdbarch
, 0);
961 set_gdbarch_call_dummy_location (gdbarch
, ON_STACK
);
962 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch
, 1);
963 set_gdbarch_call_dummy_breakpoint_offset (gdbarch
, 24);
964 set_gdbarch_pc_in_call_dummy (gdbarch
, pc_in_call_dummy_on_stack
);
965 set_gdbarch_call_dummy_p (gdbarch
, 1);
966 set_gdbarch_call_dummy_stack_adjust_p (gdbarch
, 0);
967 set_gdbarch_call_dummy_length (gdbarch
, 28);
968 set_gdbarch_call_dummy_start_offset (gdbarch
, 12);
970 set_gdbarch_call_dummy_words (gdbarch
, call_dummy_words
);
971 set_gdbarch_sizeof_call_dummy_words (gdbarch
, sizeof (call_dummy_words
));
972 set_gdbarch_call_dummy_stack_adjust_p (gdbarch
, 0);
973 set_gdbarch_fix_call_dummy (gdbarch
, m68k_fix_call_dummy
);
974 set_gdbarch_push_dummy_frame (gdbarch
, m68k_push_dummy_frame
);
975 set_gdbarch_pop_frame (gdbarch
, m68k_pop_frame
);
982 m68k_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
988 _initialize_m68k_tdep (void)
990 gdbarch_register (bfd_arch_m68k
, m68k_gdbarch_init
, m68k_dump_tdep
);
991 tm_print_insn
= print_insn_m68k
;