1 /* Target-dependent code for the Motorola 68000 series.
3 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1999, 2000, 2001,
4 2002, 2003, 2004, 2005, 2006, 2007 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., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
24 #include "dwarf2-frame.h"
26 #include "frame-base.h"
27 #include "frame-unwind.h"
32 #include "gdb_string.h"
33 #include "gdb_assert.h"
36 #include "arch-utils.h"
40 #include "m68k-tdep.h"
43 #define P_LINKL_FP 0x480e
44 #define P_LINKW_FP 0x4e56
45 #define P_PEA_FP 0x4856
46 #define P_MOVEAL_SP_FP 0x2c4f
47 #define P_ADDAW_SP 0xdefc
48 #define P_ADDAL_SP 0xdffc
49 #define P_SUBQW_SP 0x514f
50 #define P_SUBQL_SP 0x518f
51 #define P_LEA_SP_SP 0x4fef
52 #define P_LEA_PC_A5 0x4bfb0170
53 #define P_FMOVEMX_SP 0xf227
54 #define P_MOVEL_SP 0x2f00
55 #define P_MOVEML_SP 0x48e7
58 #define REGISTER_BYTES_FP (16*4 + 8 + 8*12 + 3*4)
59 #define REGISTER_BYTES_NOFP (16*4 + 8)
61 /* Offset from SP to first arg on stack at first instruction of a function */
62 #define SP_ARG0 (1 * 4)
64 #if !defined (BPT_VECTOR)
65 #define BPT_VECTOR 0xf
68 static const gdb_byte
*
69 m68k_local_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
71 static gdb_byte break_insn
[] = {0x4e, (0x40 | BPT_VECTOR
)};
72 *lenptr
= sizeof (break_insn
);
78 m68k_register_bytes_ok (long numbytes
)
80 return ((numbytes
== REGISTER_BYTES_FP
)
81 || (numbytes
== REGISTER_BYTES_NOFP
));
84 /* Return the GDB type object for the "standard" data type of data in
85 register N. This should be int for D0-D7, SR, FPCONTROL and
86 FPSTATUS, long double for FP0-FP7, and void pointer for all others
87 (A0-A7, PC, FPIADDR). Note, for registers which contain
88 addresses return pointer to void, not pointer to char, because we
89 don't want to attempt to print the string after printing the
93 m68k_register_type (struct gdbarch
*gdbarch
, int regnum
)
95 if (regnum
>= FP0_REGNUM
&& regnum
<= FP0_REGNUM
+ 7)
96 return builtin_type_m68881_ext
;
98 if (regnum
== M68K_FPI_REGNUM
|| regnum
== PC_REGNUM
)
99 return builtin_type_void_func_ptr
;
101 if (regnum
== M68K_FPC_REGNUM
|| regnum
== M68K_FPS_REGNUM
102 || regnum
== PS_REGNUM
)
103 return builtin_type_int32
;
105 if (regnum
>= M68K_A0_REGNUM
&& regnum
<= M68K_A0_REGNUM
+ 7)
106 return builtin_type_void_data_ptr
;
108 return builtin_type_int32
;
111 /* Function: m68k_register_name
112 Returns the name of the standard m68k register regnum. */
115 m68k_register_name (int regnum
)
117 static char *register_names
[] = {
118 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
119 "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp",
121 "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7",
122 "fpcontrol", "fpstatus", "fpiaddr", "fpcode", "fpflags"
125 if (regnum
< 0 || regnum
>= ARRAY_SIZE (register_names
))
126 internal_error (__FILE__
, __LINE__
,
127 _("m68k_register_name: illegal register number %d"), regnum
);
129 return register_names
[regnum
];
132 /* Return nonzero if a value of type TYPE stored in register REGNUM
133 needs any special handling. */
136 m68k_convert_register_p (int regnum
, struct type
*type
)
138 return (regnum
>= M68K_FP0_REGNUM
&& regnum
<= M68K_FP0_REGNUM
+ 7);
141 /* Read a value of type TYPE from register REGNUM in frame FRAME, and
142 return its contents in TO. */
145 m68k_register_to_value (struct frame_info
*frame
, int regnum
,
146 struct type
*type
, gdb_byte
*to
)
148 gdb_byte from
[M68K_MAX_REGISTER_SIZE
];
150 /* We only support floating-point values. */
151 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
153 warning (_("Cannot convert floating-point register value "
154 "to non-floating-point type."));
158 /* Convert to TYPE. This should be a no-op if TYPE is equivalent to
159 the extended floating-point format used by the FPU. */
160 get_frame_register (frame
, regnum
, from
);
161 convert_typed_floating (from
, builtin_type_m68881_ext
, to
, type
);
164 /* Write the contents FROM of a value of type TYPE into register
165 REGNUM in frame FRAME. */
168 m68k_value_to_register (struct frame_info
*frame
, int regnum
,
169 struct type
*type
, const gdb_byte
*from
)
171 gdb_byte to
[M68K_MAX_REGISTER_SIZE
];
173 /* We only support floating-point values. */
174 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
176 warning (_("Cannot convert non-floating-point type "
177 "to floating-point register value."));
181 /* Convert from TYPE. This should be a no-op if TYPE is equivalent
182 to the extended floating-point format used by the FPU. */
183 convert_typed_floating (from
, type
, to
, builtin_type_m68881_ext
);
184 put_frame_register (frame
, regnum
, to
);
188 /* There is a fair number of calling conventions that are in somewhat
189 wide use. The 68000/08/10 don't support an FPU, not even as a
190 coprocessor. All function return values are stored in %d0/%d1.
191 Structures are returned in a static buffer, a pointer to which is
192 returned in %d0. This means that functions returning a structure
193 are not re-entrant. To avoid this problem some systems use a
194 convention where the caller passes a pointer to a buffer in %a1
195 where the return values is to be stored. This convention is the
196 default, and is implemented in the function m68k_return_value.
198 The 68020/030/040/060 do support an FPU, either as a coprocessor
199 (68881/2) or built-in (68040/68060). That's why System V release 4
200 (SVR4) instroduces a new calling convention specified by the SVR4
201 psABI. Integer values are returned in %d0/%d1, pointer return
202 values in %a0 and floating values in %fp0. When calling functions
203 returning a structure the caller should pass a pointer to a buffer
204 for the return value in %a0. This convention is implemented in the
205 function m68k_svr4_return_value, and by appropriately setting the
206 struct_value_regnum member of `struct gdbarch_tdep'.
208 GNU/Linux returns values in the same way as SVR4 does, but uses %a1
209 for passing the structure return value buffer.
211 GCC can also generate code where small structures are returned in
212 %d0/%d1 instead of in memory by using -freg-struct-return. This is
213 the default on NetBSD a.out, OpenBSD and GNU/Linux and several
214 embedded systems. This convention is implemented by setting the
215 struct_return member of `struct gdbarch_tdep' to reg_struct_return. */
217 /* Read a function return value of TYPE from REGCACHE, and copy that
221 m68k_extract_return_value (struct type
*type
, struct regcache
*regcache
,
224 int len
= TYPE_LENGTH (type
);
225 gdb_byte buf
[M68K_MAX_REGISTER_SIZE
];
229 regcache_raw_read (regcache
, M68K_D0_REGNUM
, buf
);
230 memcpy (valbuf
, buf
+ (4 - len
), len
);
234 regcache_raw_read (regcache
, M68K_D0_REGNUM
, buf
);
235 memcpy (valbuf
, buf
+ (8 - len
), len
- 4);
236 regcache_raw_read (regcache
, M68K_D1_REGNUM
, valbuf
+ (len
- 4));
239 internal_error (__FILE__
, __LINE__
,
240 _("Cannot extract return value of %d bytes long."), len
);
244 m68k_svr4_extract_return_value (struct type
*type
, struct regcache
*regcache
,
247 int len
= TYPE_LENGTH (type
);
248 gdb_byte buf
[M68K_MAX_REGISTER_SIZE
];
250 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
252 regcache_raw_read (regcache
, M68K_FP0_REGNUM
, buf
);
253 convert_typed_floating (buf
, builtin_type_m68881_ext
, valbuf
, type
);
255 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
&& len
== 4)
256 regcache_raw_read (regcache
, M68K_A0_REGNUM
, valbuf
);
258 m68k_extract_return_value (type
, regcache
, valbuf
);
261 /* Write a function return value of TYPE from VALBUF into REGCACHE. */
264 m68k_store_return_value (struct type
*type
, struct regcache
*regcache
,
265 const gdb_byte
*valbuf
)
267 int len
= TYPE_LENGTH (type
);
270 regcache_raw_write_part (regcache
, M68K_D0_REGNUM
, 4 - len
, len
, valbuf
);
273 regcache_raw_write_part (regcache
, M68K_D0_REGNUM
, 8 - len
,
275 regcache_raw_write (regcache
, M68K_D1_REGNUM
, valbuf
+ (len
- 4));
278 internal_error (__FILE__
, __LINE__
,
279 _("Cannot store return value of %d bytes long."), len
);
283 m68k_svr4_store_return_value (struct type
*type
, struct regcache
*regcache
,
284 const gdb_byte
*valbuf
)
286 int len
= TYPE_LENGTH (type
);
288 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
290 gdb_byte buf
[M68K_MAX_REGISTER_SIZE
];
291 convert_typed_floating (valbuf
, type
, buf
, builtin_type_m68881_ext
);
292 regcache_raw_write (regcache
, M68K_FP0_REGNUM
, buf
);
294 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
&& len
== 4)
296 regcache_raw_write (regcache
, M68K_A0_REGNUM
, valbuf
);
297 regcache_raw_write (regcache
, M68K_D0_REGNUM
, valbuf
);
300 m68k_store_return_value (type
, regcache
, valbuf
);
303 /* Return non-zero if TYPE, which is assumed to be a structure or
304 union type, should be returned in registers for architecture
308 m68k_reg_struct_return_p (struct gdbarch
*gdbarch
, struct type
*type
)
310 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
311 enum type_code code
= TYPE_CODE (type
);
312 int len
= TYPE_LENGTH (type
);
314 gdb_assert (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
);
316 if (tdep
->struct_return
== pcc_struct_return
)
319 return (len
== 1 || len
== 2 || len
== 4 || len
== 8);
322 /* Determine, for architecture GDBARCH, how a return value of TYPE
323 should be returned. If it is supposed to be returned in registers,
324 and READBUF is non-zero, read the appropriate value from REGCACHE,
325 and copy it into READBUF. If WRITEBUF is non-zero, write the value
326 from WRITEBUF into REGCACHE. */
328 static enum return_value_convention
329 m68k_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
330 struct regcache
*regcache
, gdb_byte
*readbuf
,
331 const gdb_byte
*writebuf
)
333 enum type_code code
= TYPE_CODE (type
);
335 /* GCC returns a `long double' in memory too. */
336 if (((code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
337 && !m68k_reg_struct_return_p (gdbarch
, type
))
338 || (code
== TYPE_CODE_FLT
&& TYPE_LENGTH (type
) == 12))
340 /* The default on m68k is to return structures in static memory.
341 Consequently a function must return the address where we can
342 find the return value. */
348 regcache_raw_read_unsigned (regcache
, M68K_D0_REGNUM
, &addr
);
349 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
352 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
356 m68k_extract_return_value (type
, regcache
, readbuf
);
358 m68k_store_return_value (type
, regcache
, writebuf
);
360 return RETURN_VALUE_REGISTER_CONVENTION
;
363 static enum return_value_convention
364 m68k_svr4_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
365 struct regcache
*regcache
, gdb_byte
*readbuf
,
366 const gdb_byte
*writebuf
)
368 enum type_code code
= TYPE_CODE (type
);
370 if ((code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
371 && !m68k_reg_struct_return_p (gdbarch
, type
))
373 /* The System V ABI says that:
375 "A function returning a structure or union also sets %a0 to
376 the value it finds in %a0. Thus when the caller receives
377 control again, the address of the returned object resides in
380 So the ABI guarantees that we can always find the return
381 value just after the function has returned. */
387 regcache_raw_read_unsigned (regcache
, M68K_A0_REGNUM
, &addr
);
388 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
391 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
394 /* This special case is for structures consisting of a single
395 `float' or `double' member. These structures are returned in
396 %fp0. For these structures, we call ourselves recursively,
397 changing TYPE into the type of the first member of the structure.
398 Since that should work for all structures that have only one
399 member, we don't bother to check the member's type here. */
400 if (code
== TYPE_CODE_STRUCT
&& TYPE_NFIELDS (type
) == 1)
402 type
= check_typedef (TYPE_FIELD_TYPE (type
, 0));
403 return m68k_svr4_return_value (gdbarch
, type
, regcache
,
408 m68k_svr4_extract_return_value (type
, regcache
, readbuf
);
410 m68k_svr4_store_return_value (type
, regcache
, writebuf
);
412 return RETURN_VALUE_REGISTER_CONVENTION
;
416 /* Always align the frame to a 4-byte boundary. This is required on
417 coldfire and harmless on the rest. */
420 m68k_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
422 /* Align the stack to four bytes. */
427 m68k_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
428 struct regcache
*regcache
, CORE_ADDR bp_addr
, int nargs
,
429 struct value
**args
, CORE_ADDR sp
, int struct_return
,
430 CORE_ADDR struct_addr
)
432 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
436 /* Push arguments in reverse order. */
437 for (i
= nargs
- 1; i
>= 0; i
--)
439 struct type
*value_type
= value_enclosing_type (args
[i
]);
440 int len
= TYPE_LENGTH (value_type
);
441 int container_len
= (len
+ 3) & ~3;
444 /* Non-scalars bigger than 4 bytes are left aligned, others are
446 if ((TYPE_CODE (value_type
) == TYPE_CODE_STRUCT
447 || TYPE_CODE (value_type
) == TYPE_CODE_UNION
448 || TYPE_CODE (value_type
) == TYPE_CODE_ARRAY
)
452 offset
= container_len
- len
;
454 write_memory (sp
+ offset
, value_contents_all (args
[i
]), len
);
457 /* Store struct value address. */
460 store_unsigned_integer (buf
, 4, struct_addr
);
461 regcache_cooked_write (regcache
, tdep
->struct_value_regnum
, buf
);
464 /* Store return address. */
466 store_unsigned_integer (buf
, 4, bp_addr
);
467 write_memory (sp
, buf
, 4);
469 /* Finally, update the stack pointer... */
470 store_unsigned_integer (buf
, 4, sp
);
471 regcache_cooked_write (regcache
, M68K_SP_REGNUM
, buf
);
473 /* ...and fake a frame pointer. */
474 regcache_cooked_write (regcache
, M68K_FP_REGNUM
, buf
);
476 /* DWARF2/GCC uses the stack address *before* the function call as a
481 /* Convert a dwarf or dwarf2 regnumber to a GDB regnum. */
484 m68k_dwarf_reg_to_regnum (int num
)
488 return (num
- 0) + M68K_D0_REGNUM
;
491 return (num
- 8) + M68K_A0_REGNUM
;
494 return (num
- 16) + M68K_FP0_REGNUM
;
497 return M68K_PC_REGNUM
;
499 return gdbarch_num_regs (current_gdbarch
)
500 + gdbarch_num_pseudo_regs (current_gdbarch
);
504 struct m68k_frame_cache
511 /* Saved registers. */
512 CORE_ADDR saved_regs
[M68K_NUM_REGS
];
515 /* Stack space reserved for local variables. */
519 /* Allocate and initialize a frame cache. */
521 static struct m68k_frame_cache
*
522 m68k_alloc_frame_cache (void)
524 struct m68k_frame_cache
*cache
;
527 cache
= FRAME_OBSTACK_ZALLOC (struct m68k_frame_cache
);
531 cache
->sp_offset
= -4;
534 /* Saved registers. We initialize these to -1 since zero is a valid
535 offset (that's where %fp is supposed to be stored). */
536 for (i
= 0; i
< M68K_NUM_REGS
; i
++)
537 cache
->saved_regs
[i
] = -1;
539 /* Frameless until proven otherwise. */
545 /* Check whether PC points at a code that sets up a new stack frame.
546 If so, it updates CACHE and returns the address of the first
547 instruction after the sequence that sets removes the "hidden"
548 argument from the stack or CURRENT_PC, whichever is smaller.
549 Otherwise, return PC. */
552 m68k_analyze_frame_setup (CORE_ADDR pc
, CORE_ADDR current_pc
,
553 struct m68k_frame_cache
*cache
)
557 if (pc
>= current_pc
)
560 op
= read_memory_unsigned_integer (pc
, 2);
562 if (op
== P_LINKW_FP
|| op
== P_LINKL_FP
|| op
== P_PEA_FP
)
564 cache
->saved_regs
[M68K_FP_REGNUM
] = 0;
565 cache
->sp_offset
+= 4;
566 if (op
== P_LINKW_FP
)
568 /* link.w %fp, #-N */
569 /* link.w %fp, #0; adda.l #-N, %sp */
570 cache
->locals
= -read_memory_integer (pc
+ 2, 2);
572 if (pc
+ 4 < current_pc
&& cache
->locals
== 0)
574 op
= read_memory_unsigned_integer (pc
+ 4, 2);
575 if (op
== P_ADDAL_SP
)
577 cache
->locals
= read_memory_integer (pc
+ 6, 4);
584 else if (op
== P_LINKL_FP
)
586 /* link.l %fp, #-N */
587 cache
->locals
= -read_memory_integer (pc
+ 2, 4);
592 /* pea (%fp); movea.l %sp, %fp */
595 if (pc
+ 2 < current_pc
)
597 op
= read_memory_unsigned_integer (pc
+ 2, 2);
599 if (op
== P_MOVEAL_SP_FP
)
601 /* move.l %sp, %fp */
609 else if ((op
& 0170777) == P_SUBQW_SP
|| (op
& 0170777) == P_SUBQL_SP
)
611 /* subq.[wl] #N,%sp */
612 /* subq.[wl] #8,%sp; subq.[wl] #N,%sp */
613 cache
->locals
= (op
& 07000) == 0 ? 8 : (op
& 07000) >> 9;
614 if (pc
+ 2 < current_pc
)
616 op
= read_memory_unsigned_integer (pc
+ 2, 2);
617 if ((op
& 0170777) == P_SUBQW_SP
|| (op
& 0170777) == P_SUBQL_SP
)
619 cache
->locals
+= (op
& 07000) == 0 ? 8 : (op
& 07000) >> 9;
625 else if (op
== P_ADDAW_SP
|| op
== P_LEA_SP_SP
)
628 /* lea (-N,%sp),%sp */
629 cache
->locals
= -read_memory_integer (pc
+ 2, 2);
632 else if (op
== P_ADDAL_SP
)
635 cache
->locals
= -read_memory_integer (pc
+ 2, 4);
642 /* Check whether PC points at code that saves registers on the stack.
643 If so, it updates CACHE and returns the address of the first
644 instruction after the register saves or CURRENT_PC, whichever is
645 smaller. Otherwise, return PC. */
648 m68k_analyze_register_saves (CORE_ADDR pc
, CORE_ADDR current_pc
,
649 struct m68k_frame_cache
*cache
)
651 if (cache
->locals
>= 0)
657 offset
= -4 - cache
->locals
;
658 while (pc
< current_pc
)
660 op
= read_memory_unsigned_integer (pc
, 2);
661 if (op
== P_FMOVEMX_SP
)
663 /* fmovem.x REGS,-(%sp) */
664 op
= read_memory_unsigned_integer (pc
+ 2, 2);
665 if ((op
& 0xff00) == 0xe000)
668 for (i
= 0; i
< 16; i
++, mask
>>= 1)
672 cache
->saved_regs
[i
+ M68K_FP0_REGNUM
] = offset
;
681 else if ((op
& 0177760) == P_MOVEL_SP
)
683 /* move.l %R,-(%sp) */
685 cache
->saved_regs
[regno
] = offset
;
689 else if (op
== P_MOVEML_SP
)
691 /* movem.l REGS,-(%sp) */
692 mask
= read_memory_unsigned_integer (pc
+ 2, 2);
693 for (i
= 0; i
< 16; i
++, mask
>>= 1)
697 cache
->saved_regs
[15 - i
] = offset
;
712 /* Do a full analysis of the prologue at PC and update CACHE
713 accordingly. Bail out early if CURRENT_PC is reached. Return the
714 address where the analysis stopped.
716 We handle all cases that can be generated by gcc.
718 For allocating a stack frame:
722 pea (%fp); move.l %sp,%fp
723 link.w %a6,#0; add.l #-N,%sp
726 subq.w #8,%sp; subq.w #N-8,%sp
731 For saving registers:
735 move.l R1,-(%sp); move.l R2,-(%sp)
738 For setting up the PIC register:
745 m68k_analyze_prologue (CORE_ADDR pc
, CORE_ADDR current_pc
,
746 struct m68k_frame_cache
*cache
)
750 pc
= m68k_analyze_frame_setup (pc
, current_pc
, cache
);
751 pc
= m68k_analyze_register_saves (pc
, current_pc
, cache
);
752 if (pc
>= current_pc
)
755 /* Check for GOT setup. */
756 op
= read_memory_unsigned_integer (pc
, 4);
757 if (op
== P_LEA_PC_A5
)
759 /* lea (%pc,N),%a5 */
766 /* Return PC of first real instruction. */
769 m68k_skip_prologue (CORE_ADDR start_pc
)
771 struct m68k_frame_cache cache
;
776 pc
= m68k_analyze_prologue (start_pc
, (CORE_ADDR
) -1, &cache
);
777 if (cache
.locals
< 0)
783 m68k_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
787 frame_unwind_register (next_frame
, PC_REGNUM
, buf
);
788 return extract_typed_address (buf
, builtin_type_void_func_ptr
);
793 static struct m68k_frame_cache
*
794 m68k_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
796 struct m68k_frame_cache
*cache
;
803 cache
= m68k_alloc_frame_cache ();
806 /* In principle, for normal frames, %fp holds the frame pointer,
807 which holds the base address for the current stack frame.
808 However, for functions that don't need it, the frame pointer is
809 optional. For these "frameless" functions the frame pointer is
810 actually the frame pointer of the calling frame. Signal
811 trampolines are just a special case of a "frameless" function.
812 They (usually) share their frame pointer with the frame that was
813 in progress when the signal occurred. */
815 frame_unwind_register (next_frame
, M68K_FP_REGNUM
, buf
);
816 cache
->base
= extract_unsigned_integer (buf
, 4);
817 if (cache
->base
== 0)
820 /* For normal frames, %pc is stored at 4(%fp). */
821 cache
->saved_regs
[M68K_PC_REGNUM
] = 4;
823 cache
->pc
= frame_func_unwind (next_frame
, NORMAL_FRAME
);
825 m68k_analyze_prologue (cache
->pc
, frame_pc_unwind (next_frame
), cache
);
827 if (cache
->locals
< 0)
829 /* We didn't find a valid frame, which means that CACHE->base
830 currently holds the frame pointer for our calling frame. If
831 we're at the start of a function, or somewhere half-way its
832 prologue, the function's frame probably hasn't been fully
833 setup yet. Try to reconstruct the base address for the stack
834 frame by looking at the stack pointer. For truly "frameless"
835 functions this might work too. */
837 frame_unwind_register (next_frame
, M68K_SP_REGNUM
, buf
);
838 cache
->base
= extract_unsigned_integer (buf
, 4) + cache
->sp_offset
;
841 /* Now that we have the base address for the stack frame we can
842 calculate the value of %sp in the calling frame. */
843 cache
->saved_sp
= cache
->base
+ 8;
845 /* Adjust all the saved registers such that they contain addresses
846 instead of offsets. */
847 for (i
= 0; i
< M68K_NUM_REGS
; i
++)
848 if (cache
->saved_regs
[i
] != -1)
849 cache
->saved_regs
[i
] += cache
->base
;
855 m68k_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
856 struct frame_id
*this_id
)
858 struct m68k_frame_cache
*cache
= m68k_frame_cache (next_frame
, this_cache
);
860 /* This marks the outermost frame. */
861 if (cache
->base
== 0)
864 /* See the end of m68k_push_dummy_call. */
865 *this_id
= frame_id_build (cache
->base
+ 8, cache
->pc
);
869 m68k_frame_prev_register (struct frame_info
*next_frame
, void **this_cache
,
870 int regnum
, int *optimizedp
,
871 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
872 int *realnump
, gdb_byte
*valuep
)
874 struct m68k_frame_cache
*cache
= m68k_frame_cache (next_frame
, this_cache
);
876 gdb_assert (regnum
>= 0);
878 if (regnum
== M68K_SP_REGNUM
&& cache
->saved_sp
)
886 /* Store the value. */
887 store_unsigned_integer (valuep
, 4, cache
->saved_sp
);
892 if (regnum
< M68K_NUM_REGS
&& cache
->saved_regs
[regnum
] != -1)
895 *lvalp
= lval_memory
;
896 *addrp
= cache
->saved_regs
[regnum
];
900 /* Read the value in from memory. */
901 read_memory (*addrp
, valuep
,
902 register_size (current_gdbarch
, regnum
));
908 *lvalp
= lval_register
;
912 frame_unwind_register (next_frame
, (*realnump
), valuep
);
915 static const struct frame_unwind m68k_frame_unwind
=
919 m68k_frame_prev_register
922 static const struct frame_unwind
*
923 m68k_frame_sniffer (struct frame_info
*next_frame
)
925 return &m68k_frame_unwind
;
929 m68k_frame_base_address (struct frame_info
*next_frame
, void **this_cache
)
931 struct m68k_frame_cache
*cache
= m68k_frame_cache (next_frame
, this_cache
);
936 static const struct frame_base m68k_frame_base
=
939 m68k_frame_base_address
,
940 m68k_frame_base_address
,
941 m68k_frame_base_address
944 static struct frame_id
945 m68k_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
950 frame_unwind_register (next_frame
, M68K_FP_REGNUM
, buf
);
951 fp
= extract_unsigned_integer (buf
, 4);
953 /* See the end of m68k_push_dummy_call. */
954 return frame_id_build (fp
+ 8, frame_pc_unwind (next_frame
));
958 /* Figure out where the longjmp will land. Slurp the args out of the stack.
959 We expect the first arg to be a pointer to the jmp_buf structure from which
960 we extract the pc (JB_PC) that we will land at. The pc is copied into PC.
961 This routine returns true on success. */
964 m68k_get_longjmp_target (CORE_ADDR
*pc
)
967 CORE_ADDR sp
, jb_addr
;
968 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
972 internal_error (__FILE__
, __LINE__
,
973 _("m68k_get_longjmp_target: not implemented"));
977 buf
= alloca (TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
978 sp
= read_register (SP_REGNUM
);
980 if (target_read_memory (sp
+ SP_ARG0
, /* Offset of first arg on stack */
981 buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
))
984 jb_addr
= extract_unsigned_integer (buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
986 if (target_read_memory (jb_addr
+ tdep
->jb_pc
* tdep
->jb_elt_size
, buf
,
987 TARGET_PTR_BIT
/ TARGET_CHAR_BIT
))
990 *pc
= extract_unsigned_integer (buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
995 /* System V Release 4 (SVR4). */
998 m68k_svr4_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1000 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1002 /* SVR4 uses a different calling convention. */
1003 set_gdbarch_return_value (gdbarch
, m68k_svr4_return_value
);
1005 /* SVR4 uses %a0 instead of %a1. */
1006 tdep
->struct_value_regnum
= M68K_A0_REGNUM
;
1010 /* Function: m68k_gdbarch_init
1011 Initializer function for the m68k gdbarch vector.
1012 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
1014 static struct gdbarch
*
1015 m68k_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1017 struct gdbarch_tdep
*tdep
= NULL
;
1018 struct gdbarch
*gdbarch
;
1020 /* find a candidate among the list of pre-declared architectures. */
1021 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1023 return (arches
->gdbarch
);
1025 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1026 gdbarch
= gdbarch_alloc (&info
, tdep
);
1028 set_gdbarch_long_double_format (gdbarch
, floatformats_m68881_ext
);
1029 set_gdbarch_long_double_bit (gdbarch
, 96);
1031 set_gdbarch_skip_prologue (gdbarch
, m68k_skip_prologue
);
1032 set_gdbarch_breakpoint_from_pc (gdbarch
, m68k_local_breakpoint_from_pc
);
1034 /* Stack grows down. */
1035 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1036 set_gdbarch_frame_align (gdbarch
, m68k_frame_align
);
1038 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
1040 set_gdbarch_frame_args_skip (gdbarch
, 8);
1041 set_gdbarch_dwarf_reg_to_regnum (gdbarch
, m68k_dwarf_reg_to_regnum
);
1042 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, m68k_dwarf_reg_to_regnum
);
1044 set_gdbarch_register_type (gdbarch
, m68k_register_type
);
1045 set_gdbarch_register_name (gdbarch
, m68k_register_name
);
1046 set_gdbarch_num_regs (gdbarch
, M68K_NUM_REGS
);
1047 set_gdbarch_register_bytes_ok (gdbarch
, m68k_register_bytes_ok
);
1048 set_gdbarch_sp_regnum (gdbarch
, M68K_SP_REGNUM
);
1049 set_gdbarch_pc_regnum (gdbarch
, M68K_PC_REGNUM
);
1050 set_gdbarch_ps_regnum (gdbarch
, M68K_PS_REGNUM
);
1051 set_gdbarch_fp0_regnum (gdbarch
, M68K_FP0_REGNUM
);
1052 set_gdbarch_convert_register_p (gdbarch
, m68k_convert_register_p
);
1053 set_gdbarch_register_to_value (gdbarch
, m68k_register_to_value
);
1054 set_gdbarch_value_to_register (gdbarch
, m68k_value_to_register
);
1056 set_gdbarch_push_dummy_call (gdbarch
, m68k_push_dummy_call
);
1057 set_gdbarch_return_value (gdbarch
, m68k_return_value
);
1060 set_gdbarch_print_insn (gdbarch
, print_insn_m68k
);
1062 #if defined JB_PC && defined JB_ELEMENT_SIZE
1063 tdep
->jb_pc
= JB_PC
;
1064 tdep
->jb_elt_size
= JB_ELEMENT_SIZE
;
1068 tdep
->struct_value_regnum
= M68K_A1_REGNUM
;
1069 tdep
->struct_return
= reg_struct_return
;
1071 /* Frame unwinder. */
1072 set_gdbarch_unwind_dummy_id (gdbarch
, m68k_unwind_dummy_id
);
1073 set_gdbarch_unwind_pc (gdbarch
, m68k_unwind_pc
);
1075 /* Hook in the DWARF CFI frame unwinder. */
1076 frame_unwind_append_sniffer (gdbarch
, dwarf2_frame_sniffer
);
1078 frame_base_set_default (gdbarch
, &m68k_frame_base
);
1080 /* Hook in ABI-specific overrides, if they have been registered. */
1081 gdbarch_init_osabi (info
, gdbarch
);
1083 /* Now we have tuned the configuration, set a few final things,
1084 based on what the OS ABI has told us. */
1086 if (tdep
->jb_pc
>= 0)
1087 set_gdbarch_get_longjmp_target (gdbarch
, m68k_get_longjmp_target
);
1089 frame_unwind_append_sniffer (gdbarch
, m68k_frame_sniffer
);
1096 m68k_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
1098 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1104 extern initialize_file_ftype _initialize_m68k_tdep
; /* -Wmissing-prototypes */
1107 _initialize_m68k_tdep (void)
1109 gdbarch_register (bfd_arch_m68k
, m68k_gdbarch_init
, m68k_dump_tdep
);