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 3 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, see <http://www.gnu.org/licenses/>. */
22 #include "dwarf2-frame.h"
24 #include "frame-base.h"
25 #include "frame-unwind.h"
30 #include "gdb_string.h"
31 #include "gdb_assert.h"
34 #include "arch-utils.h"
37 #include "target-descriptions.h"
39 #include "m68k-tdep.h"
42 #define P_LINKL_FP 0x480e
43 #define P_LINKW_FP 0x4e56
44 #define P_PEA_FP 0x4856
45 #define P_MOVEAL_SP_FP 0x2c4f
46 #define P_ADDAW_SP 0xdefc
47 #define P_ADDAL_SP 0xdffc
48 #define P_SUBQW_SP 0x514f
49 #define P_SUBQL_SP 0x518f
50 #define P_LEA_SP_SP 0x4fef
51 #define P_LEA_PC_A5 0x4bfb0170
52 #define P_FMOVEMX_SP 0xf227
53 #define P_MOVEL_SP 0x2f00
54 #define P_MOVEML_SP 0x48e7
56 /* Offset from SP to first arg on stack at first instruction of a function */
57 #define SP_ARG0 (1 * 4)
59 #if !defined (BPT_VECTOR)
60 #define BPT_VECTOR 0xf
63 static const gdb_byte
*
64 m68k_local_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
66 static gdb_byte break_insn
[] = {0x4e, (0x40 | BPT_VECTOR
)};
67 *lenptr
= sizeof (break_insn
);
73 struct type
*m68k_ps_type
;
75 /* Construct types for ISA-specific registers. */
77 m68k_init_types (void)
81 type
= init_flags_type ("builtin_type_m68k_ps", 4);
82 append_flags_type_flag (type
, 0, "C");
83 append_flags_type_flag (type
, 1, "V");
84 append_flags_type_flag (type
, 2, "Z");
85 append_flags_type_flag (type
, 3, "N");
86 append_flags_type_flag (type
, 4, "X");
87 append_flags_type_flag (type
, 8, "I0");
88 append_flags_type_flag (type
, 9, "I1");
89 append_flags_type_flag (type
, 10, "I2");
90 append_flags_type_flag (type
, 12, "M");
91 append_flags_type_flag (type
, 13, "S");
92 append_flags_type_flag (type
, 14, "T0");
93 append_flags_type_flag (type
, 15, "T1");
97 /* Return the GDB type object for the "standard" data type of data in
98 register N. This should be int for D0-D7, SR, FPCONTROL and
99 FPSTATUS, long double for FP0-FP7, and void pointer for all others
100 (A0-A7, PC, FPIADDR). Note, for registers which contain
101 addresses return pointer to void, not pointer to char, because we
102 don't want to attempt to print the string after printing the
106 m68k_register_type (struct gdbarch
*gdbarch
, int regnum
)
108 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
110 if (tdep
->fpregs_present
)
112 if (regnum
>= gdbarch_fp0_regnum (current_gdbarch
)
113 && regnum
<= gdbarch_fp0_regnum (current_gdbarch
) + 7)
115 if (tdep
->flavour
== m68k_coldfire_flavour
)
116 return builtin_type (gdbarch
)->builtin_double
;
118 return builtin_type_m68881_ext
;
121 if (regnum
== M68K_FPI_REGNUM
)
122 return builtin_type_void_func_ptr
;
124 if (regnum
== M68K_FPC_REGNUM
|| regnum
== M68K_FPS_REGNUM
)
125 return builtin_type_int32
;
129 if (regnum
>= M68K_FP0_REGNUM
&& regnum
<= M68K_FPI_REGNUM
)
130 return builtin_type_int0
;
133 if (regnum
== gdbarch_pc_regnum (current_gdbarch
))
134 return builtin_type_void_func_ptr
;
136 if (regnum
>= M68K_A0_REGNUM
&& regnum
<= M68K_A0_REGNUM
+ 7)
137 return builtin_type_void_data_ptr
;
139 if (regnum
== M68K_PS_REGNUM
)
142 return builtin_type_int32
;
145 static const char *m68k_register_names
[] = {
146 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
147 "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp",
149 "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7",
150 "fpcontrol", "fpstatus", "fpiaddr"
153 /* Function: m68k_register_name
154 Returns the name of the standard m68k register regnum. */
157 m68k_register_name (int regnum
)
159 if (regnum
< 0 || regnum
>= ARRAY_SIZE (m68k_register_names
))
160 internal_error (__FILE__
, __LINE__
,
161 _("m68k_register_name: illegal register number %d"), regnum
);
163 return m68k_register_names
[regnum
];
166 /* Return nonzero if a value of type TYPE stored in register REGNUM
167 needs any special handling. */
170 m68k_convert_register_p (int regnum
, struct type
*type
)
172 if (!gdbarch_tdep (current_gdbarch
)->fpregs_present
)
174 return (regnum
>= M68K_FP0_REGNUM
&& regnum
<= M68K_FP0_REGNUM
+ 7);
177 /* Read a value of type TYPE from register REGNUM in frame FRAME, and
178 return its contents in TO. */
181 m68k_register_to_value (struct frame_info
*frame
, int regnum
,
182 struct type
*type
, gdb_byte
*to
)
184 gdb_byte from
[M68K_MAX_REGISTER_SIZE
];
185 struct type
*fpreg_type
= register_type (current_gdbarch
, M68K_FP0_REGNUM
);
187 /* We only support floating-point values. */
188 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
190 warning (_("Cannot convert floating-point register value "
191 "to non-floating-point type."));
195 /* Convert to TYPE. This should be a no-op if TYPE is equivalent to
196 the extended floating-point format used by the FPU. */
197 get_frame_register (frame
, regnum
, from
);
198 convert_typed_floating (from
, fpreg_type
, to
, type
);
201 /* Write the contents FROM of a value of type TYPE into register
202 REGNUM in frame FRAME. */
205 m68k_value_to_register (struct frame_info
*frame
, int regnum
,
206 struct type
*type
, const gdb_byte
*from
)
208 gdb_byte to
[M68K_MAX_REGISTER_SIZE
];
209 struct type
*fpreg_type
= register_type (current_gdbarch
, M68K_FP0_REGNUM
);
211 /* We only support floating-point values. */
212 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
214 warning (_("Cannot convert non-floating-point type "
215 "to floating-point register value."));
219 /* Convert from TYPE. This should be a no-op if TYPE is equivalent
220 to the extended floating-point format used by the FPU. */
221 convert_typed_floating (from
, type
, to
, fpreg_type
);
222 put_frame_register (frame
, regnum
, to
);
226 /* There is a fair number of calling conventions that are in somewhat
227 wide use. The 68000/08/10 don't support an FPU, not even as a
228 coprocessor. All function return values are stored in %d0/%d1.
229 Structures are returned in a static buffer, a pointer to which is
230 returned in %d0. This means that functions returning a structure
231 are not re-entrant. To avoid this problem some systems use a
232 convention where the caller passes a pointer to a buffer in %a1
233 where the return values is to be stored. This convention is the
234 default, and is implemented in the function m68k_return_value.
236 The 68020/030/040/060 do support an FPU, either as a coprocessor
237 (68881/2) or built-in (68040/68060). That's why System V release 4
238 (SVR4) instroduces a new calling convention specified by the SVR4
239 psABI. Integer values are returned in %d0/%d1, pointer return
240 values in %a0 and floating values in %fp0. When calling functions
241 returning a structure the caller should pass a pointer to a buffer
242 for the return value in %a0. This convention is implemented in the
243 function m68k_svr4_return_value, and by appropriately setting the
244 struct_value_regnum member of `struct gdbarch_tdep'.
246 GNU/Linux returns values in the same way as SVR4 does, but uses %a1
247 for passing the structure return value buffer.
249 GCC can also generate code where small structures are returned in
250 %d0/%d1 instead of in memory by using -freg-struct-return. This is
251 the default on NetBSD a.out, OpenBSD and GNU/Linux and several
252 embedded systems. This convention is implemented by setting the
253 struct_return member of `struct gdbarch_tdep' to reg_struct_return. */
255 /* Read a function return value of TYPE from REGCACHE, and copy that
259 m68k_extract_return_value (struct type
*type
, struct regcache
*regcache
,
262 int len
= TYPE_LENGTH (type
);
263 gdb_byte buf
[M68K_MAX_REGISTER_SIZE
];
267 regcache_raw_read (regcache
, M68K_D0_REGNUM
, buf
);
268 memcpy (valbuf
, buf
+ (4 - len
), len
);
272 regcache_raw_read (regcache
, M68K_D0_REGNUM
, buf
);
273 memcpy (valbuf
, buf
+ (8 - len
), len
- 4);
274 regcache_raw_read (regcache
, M68K_D1_REGNUM
, valbuf
+ (len
- 4));
277 internal_error (__FILE__
, __LINE__
,
278 _("Cannot extract return value of %d bytes long."), len
);
282 m68k_svr4_extract_return_value (struct type
*type
, struct regcache
*regcache
,
285 int len
= TYPE_LENGTH (type
);
286 gdb_byte buf
[M68K_MAX_REGISTER_SIZE
];
287 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
289 if (tdep
->float_return
&& TYPE_CODE (type
) == TYPE_CODE_FLT
)
291 struct type
*fpreg_type
= register_type
292 (current_gdbarch
, M68K_FP0_REGNUM
);
293 regcache_raw_read (regcache
, M68K_FP0_REGNUM
, buf
);
294 convert_typed_floating (buf
, fpreg_type
, valbuf
, type
);
296 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
&& len
== 4)
297 regcache_raw_read (regcache
, M68K_A0_REGNUM
, valbuf
);
299 m68k_extract_return_value (type
, regcache
, valbuf
);
302 /* Write a function return value of TYPE from VALBUF into REGCACHE. */
305 m68k_store_return_value (struct type
*type
, struct regcache
*regcache
,
306 const gdb_byte
*valbuf
)
308 int len
= TYPE_LENGTH (type
);
311 regcache_raw_write_part (regcache
, M68K_D0_REGNUM
, 4 - len
, len
, valbuf
);
314 regcache_raw_write_part (regcache
, M68K_D0_REGNUM
, 8 - len
,
316 regcache_raw_write (regcache
, M68K_D1_REGNUM
, valbuf
+ (len
- 4));
319 internal_error (__FILE__
, __LINE__
,
320 _("Cannot store return value of %d bytes long."), len
);
324 m68k_svr4_store_return_value (struct type
*type
, struct regcache
*regcache
,
325 const gdb_byte
*valbuf
)
327 int len
= TYPE_LENGTH (type
);
328 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
330 if (tdep
->float_return
&& TYPE_CODE (type
) == TYPE_CODE_FLT
)
332 struct type
*fpreg_type
= register_type
333 (current_gdbarch
, M68K_FP0_REGNUM
);
334 gdb_byte buf
[M68K_MAX_REGISTER_SIZE
];
335 convert_typed_floating (valbuf
, type
, buf
, fpreg_type
);
336 regcache_raw_write (regcache
, M68K_FP0_REGNUM
, buf
);
338 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
&& len
== 4)
340 regcache_raw_write (regcache
, M68K_A0_REGNUM
, valbuf
);
341 regcache_raw_write (regcache
, M68K_D0_REGNUM
, valbuf
);
344 m68k_store_return_value (type
, regcache
, valbuf
);
347 /* Return non-zero if TYPE, which is assumed to be a structure or
348 union type, should be returned in registers for architecture
352 m68k_reg_struct_return_p (struct gdbarch
*gdbarch
, struct type
*type
)
354 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
355 enum type_code code
= TYPE_CODE (type
);
356 int len
= TYPE_LENGTH (type
);
358 gdb_assert (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
);
360 if (tdep
->struct_return
== pcc_struct_return
)
363 return (len
== 1 || len
== 2 || len
== 4 || len
== 8);
366 /* Determine, for architecture GDBARCH, how a return value of TYPE
367 should be returned. If it is supposed to be returned in registers,
368 and READBUF is non-zero, read the appropriate value from REGCACHE,
369 and copy it into READBUF. If WRITEBUF is non-zero, write the value
370 from WRITEBUF into REGCACHE. */
372 static enum return_value_convention
373 m68k_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
374 struct regcache
*regcache
, gdb_byte
*readbuf
,
375 const gdb_byte
*writebuf
)
377 enum type_code code
= TYPE_CODE (type
);
379 /* GCC returns a `long double' in memory too. */
380 if (((code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
381 && !m68k_reg_struct_return_p (gdbarch
, type
))
382 || (code
== TYPE_CODE_FLT
&& TYPE_LENGTH (type
) == 12))
384 /* The default on m68k is to return structures in static memory.
385 Consequently a function must return the address where we can
386 find the return value. */
392 regcache_raw_read_unsigned (regcache
, M68K_D0_REGNUM
, &addr
);
393 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
396 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
400 m68k_extract_return_value (type
, regcache
, readbuf
);
402 m68k_store_return_value (type
, regcache
, writebuf
);
404 return RETURN_VALUE_REGISTER_CONVENTION
;
407 static enum return_value_convention
408 m68k_svr4_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
409 struct regcache
*regcache
, gdb_byte
*readbuf
,
410 const gdb_byte
*writebuf
)
412 enum type_code code
= TYPE_CODE (type
);
414 if ((code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
415 && !m68k_reg_struct_return_p (gdbarch
, type
))
417 /* The System V ABI says that:
419 "A function returning a structure or union also sets %a0 to
420 the value it finds in %a0. Thus when the caller receives
421 control again, the address of the returned object resides in
424 So the ABI guarantees that we can always find the return
425 value just after the function has returned. */
431 regcache_raw_read_unsigned (regcache
, M68K_A0_REGNUM
, &addr
);
432 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
435 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
438 /* This special case is for structures consisting of a single
439 `float' or `double' member. These structures are returned in
440 %fp0. For these structures, we call ourselves recursively,
441 changing TYPE into the type of the first member of the structure.
442 Since that should work for all structures that have only one
443 member, we don't bother to check the member's type here. */
444 if (code
== TYPE_CODE_STRUCT
&& TYPE_NFIELDS (type
) == 1)
446 type
= check_typedef (TYPE_FIELD_TYPE (type
, 0));
447 return m68k_svr4_return_value (gdbarch
, type
, regcache
,
452 m68k_svr4_extract_return_value (type
, regcache
, readbuf
);
454 m68k_svr4_store_return_value (type
, regcache
, writebuf
);
456 return RETURN_VALUE_REGISTER_CONVENTION
;
460 /* Always align the frame to a 4-byte boundary. This is required on
461 coldfire and harmless on the rest. */
464 m68k_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
466 /* Align the stack to four bytes. */
471 m68k_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
472 struct regcache
*regcache
, CORE_ADDR bp_addr
, int nargs
,
473 struct value
**args
, CORE_ADDR sp
, int struct_return
,
474 CORE_ADDR struct_addr
)
476 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
480 /* Push arguments in reverse order. */
481 for (i
= nargs
- 1; i
>= 0; i
--)
483 struct type
*value_type
= value_enclosing_type (args
[i
]);
484 int len
= TYPE_LENGTH (value_type
);
485 int container_len
= (len
+ 3) & ~3;
488 /* Non-scalars bigger than 4 bytes are left aligned, others are
490 if ((TYPE_CODE (value_type
) == TYPE_CODE_STRUCT
491 || TYPE_CODE (value_type
) == TYPE_CODE_UNION
492 || TYPE_CODE (value_type
) == TYPE_CODE_ARRAY
)
496 offset
= container_len
- len
;
498 write_memory (sp
+ offset
, value_contents_all (args
[i
]), len
);
501 /* Store struct value address. */
504 store_unsigned_integer (buf
, 4, struct_addr
);
505 regcache_cooked_write (regcache
, tdep
->struct_value_regnum
, buf
);
508 /* Store return address. */
510 store_unsigned_integer (buf
, 4, bp_addr
);
511 write_memory (sp
, buf
, 4);
513 /* Finally, update the stack pointer... */
514 store_unsigned_integer (buf
, 4, sp
);
515 regcache_cooked_write (regcache
, M68K_SP_REGNUM
, buf
);
517 /* ...and fake a frame pointer. */
518 regcache_cooked_write (regcache
, M68K_FP_REGNUM
, buf
);
520 /* DWARF2/GCC uses the stack address *before* the function call as a
525 /* Convert a dwarf or dwarf2 regnumber to a GDB regnum. */
528 m68k_dwarf_reg_to_regnum (int num
)
532 return (num
- 0) + M68K_D0_REGNUM
;
535 return (num
- 8) + M68K_A0_REGNUM
;
536 else if (num
< 24 && gdbarch_tdep (current_gdbarch
)->fpregs_present
)
538 return (num
- 16) + M68K_FP0_REGNUM
;
541 return M68K_PC_REGNUM
;
543 return gdbarch_num_regs (current_gdbarch
)
544 + gdbarch_num_pseudo_regs (current_gdbarch
);
548 struct m68k_frame_cache
555 /* Saved registers. */
556 CORE_ADDR saved_regs
[M68K_NUM_REGS
];
559 /* Stack space reserved for local variables. */
563 /* Allocate and initialize a frame cache. */
565 static struct m68k_frame_cache
*
566 m68k_alloc_frame_cache (void)
568 struct m68k_frame_cache
*cache
;
571 cache
= FRAME_OBSTACK_ZALLOC (struct m68k_frame_cache
);
575 cache
->sp_offset
= -4;
578 /* Saved registers. We initialize these to -1 since zero is a valid
579 offset (that's where %fp is supposed to be stored). */
580 for (i
= 0; i
< M68K_NUM_REGS
; i
++)
581 cache
->saved_regs
[i
] = -1;
583 /* Frameless until proven otherwise. */
589 /* Check whether PC points at a code that sets up a new stack frame.
590 If so, it updates CACHE and returns the address of the first
591 instruction after the sequence that sets removes the "hidden"
592 argument from the stack or CURRENT_PC, whichever is smaller.
593 Otherwise, return PC. */
596 m68k_analyze_frame_setup (CORE_ADDR pc
, CORE_ADDR current_pc
,
597 struct m68k_frame_cache
*cache
)
601 if (pc
>= current_pc
)
604 op
= read_memory_unsigned_integer (pc
, 2);
606 if (op
== P_LINKW_FP
|| op
== P_LINKL_FP
|| op
== P_PEA_FP
)
608 cache
->saved_regs
[M68K_FP_REGNUM
] = 0;
609 cache
->sp_offset
+= 4;
610 if (op
== P_LINKW_FP
)
612 /* link.w %fp, #-N */
613 /* link.w %fp, #0; adda.l #-N, %sp */
614 cache
->locals
= -read_memory_integer (pc
+ 2, 2);
616 if (pc
+ 4 < current_pc
&& cache
->locals
== 0)
618 op
= read_memory_unsigned_integer (pc
+ 4, 2);
619 if (op
== P_ADDAL_SP
)
621 cache
->locals
= read_memory_integer (pc
+ 6, 4);
628 else if (op
== P_LINKL_FP
)
630 /* link.l %fp, #-N */
631 cache
->locals
= -read_memory_integer (pc
+ 2, 4);
636 /* pea (%fp); movea.l %sp, %fp */
639 if (pc
+ 2 < current_pc
)
641 op
= read_memory_unsigned_integer (pc
+ 2, 2);
643 if (op
== P_MOVEAL_SP_FP
)
645 /* move.l %sp, %fp */
653 else if ((op
& 0170777) == P_SUBQW_SP
|| (op
& 0170777) == P_SUBQL_SP
)
655 /* subq.[wl] #N,%sp */
656 /* subq.[wl] #8,%sp; subq.[wl] #N,%sp */
657 cache
->locals
= (op
& 07000) == 0 ? 8 : (op
& 07000) >> 9;
658 if (pc
+ 2 < current_pc
)
660 op
= read_memory_unsigned_integer (pc
+ 2, 2);
661 if ((op
& 0170777) == P_SUBQW_SP
|| (op
& 0170777) == P_SUBQL_SP
)
663 cache
->locals
+= (op
& 07000) == 0 ? 8 : (op
& 07000) >> 9;
669 else if (op
== P_ADDAW_SP
|| op
== P_LEA_SP_SP
)
672 /* lea (-N,%sp),%sp */
673 cache
->locals
= -read_memory_integer (pc
+ 2, 2);
676 else if (op
== P_ADDAL_SP
)
679 cache
->locals
= -read_memory_integer (pc
+ 2, 4);
686 /* Check whether PC points at code that saves registers on the stack.
687 If so, it updates CACHE and returns the address of the first
688 instruction after the register saves or CURRENT_PC, whichever is
689 smaller. Otherwise, return PC. */
692 m68k_analyze_register_saves (CORE_ADDR pc
, CORE_ADDR current_pc
,
693 struct m68k_frame_cache
*cache
)
695 if (cache
->locals
>= 0)
701 offset
= -4 - cache
->locals
;
702 while (pc
< current_pc
)
704 op
= read_memory_unsigned_integer (pc
, 2);
705 if (op
== P_FMOVEMX_SP
706 && gdbarch_tdep (current_gdbarch
)->fpregs_present
)
708 /* fmovem.x REGS,-(%sp) */
709 op
= read_memory_unsigned_integer (pc
+ 2, 2);
710 if ((op
& 0xff00) == 0xe000)
713 for (i
= 0; i
< 16; i
++, mask
>>= 1)
717 cache
->saved_regs
[i
+ M68K_FP0_REGNUM
] = offset
;
726 else if ((op
& 0177760) == P_MOVEL_SP
)
728 /* move.l %R,-(%sp) */
730 cache
->saved_regs
[regno
] = offset
;
734 else if (op
== P_MOVEML_SP
)
736 /* movem.l REGS,-(%sp) */
737 mask
= read_memory_unsigned_integer (pc
+ 2, 2);
738 for (i
= 0; i
< 16; i
++, mask
>>= 1)
742 cache
->saved_regs
[15 - i
] = offset
;
757 /* Do a full analysis of the prologue at PC and update CACHE
758 accordingly. Bail out early if CURRENT_PC is reached. Return the
759 address where the analysis stopped.
761 We handle all cases that can be generated by gcc.
763 For allocating a stack frame:
767 pea (%fp); move.l %sp,%fp
768 link.w %a6,#0; add.l #-N,%sp
771 subq.w #8,%sp; subq.w #N-8,%sp
776 For saving registers:
780 move.l R1,-(%sp); move.l R2,-(%sp)
783 For setting up the PIC register:
790 m68k_analyze_prologue (CORE_ADDR pc
, CORE_ADDR current_pc
,
791 struct m68k_frame_cache
*cache
)
795 pc
= m68k_analyze_frame_setup (pc
, current_pc
, cache
);
796 pc
= m68k_analyze_register_saves (pc
, current_pc
, cache
);
797 if (pc
>= current_pc
)
800 /* Check for GOT setup. */
801 op
= read_memory_unsigned_integer (pc
, 4);
802 if (op
== P_LEA_PC_A5
)
804 /* lea (%pc,N),%a5 */
811 /* Return PC of first real instruction. */
814 m68k_skip_prologue (CORE_ADDR start_pc
)
816 struct m68k_frame_cache cache
;
821 pc
= m68k_analyze_prologue (start_pc
, (CORE_ADDR
) -1, &cache
);
822 if (cache
.locals
< 0)
828 m68k_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
832 frame_unwind_register (next_frame
, gdbarch_pc_regnum (current_gdbarch
), buf
);
833 return extract_typed_address (buf
, builtin_type_void_func_ptr
);
838 static struct m68k_frame_cache
*
839 m68k_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
841 struct m68k_frame_cache
*cache
;
848 cache
= m68k_alloc_frame_cache ();
851 /* In principle, for normal frames, %fp holds the frame pointer,
852 which holds the base address for the current stack frame.
853 However, for functions that don't need it, the frame pointer is
854 optional. For these "frameless" functions the frame pointer is
855 actually the frame pointer of the calling frame. Signal
856 trampolines are just a special case of a "frameless" function.
857 They (usually) share their frame pointer with the frame that was
858 in progress when the signal occurred. */
860 frame_unwind_register (next_frame
, M68K_FP_REGNUM
, buf
);
861 cache
->base
= extract_unsigned_integer (buf
, 4);
862 if (cache
->base
== 0)
865 /* For normal frames, %pc is stored at 4(%fp). */
866 cache
->saved_regs
[M68K_PC_REGNUM
] = 4;
868 cache
->pc
= frame_func_unwind (next_frame
, NORMAL_FRAME
);
870 m68k_analyze_prologue (cache
->pc
, frame_pc_unwind (next_frame
), cache
);
872 if (cache
->locals
< 0)
874 /* We didn't find a valid frame, which means that CACHE->base
875 currently holds the frame pointer for our calling frame. If
876 we're at the start of a function, or somewhere half-way its
877 prologue, the function's frame probably hasn't been fully
878 setup yet. Try to reconstruct the base address for the stack
879 frame by looking at the stack pointer. For truly "frameless"
880 functions this might work too. */
882 frame_unwind_register (next_frame
, M68K_SP_REGNUM
, buf
);
883 cache
->base
= extract_unsigned_integer (buf
, 4) + cache
->sp_offset
;
886 /* Now that we have the base address for the stack frame we can
887 calculate the value of %sp in the calling frame. */
888 cache
->saved_sp
= cache
->base
+ 8;
890 /* Adjust all the saved registers such that they contain addresses
891 instead of offsets. */
892 for (i
= 0; i
< M68K_NUM_REGS
; i
++)
893 if (cache
->saved_regs
[i
] != -1)
894 cache
->saved_regs
[i
] += cache
->base
;
900 m68k_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
901 struct frame_id
*this_id
)
903 struct m68k_frame_cache
*cache
= m68k_frame_cache (next_frame
, this_cache
);
905 /* This marks the outermost frame. */
906 if (cache
->base
== 0)
909 /* See the end of m68k_push_dummy_call. */
910 *this_id
= frame_id_build (cache
->base
+ 8, cache
->pc
);
914 m68k_frame_prev_register (struct frame_info
*next_frame
, void **this_cache
,
915 int regnum
, int *optimizedp
,
916 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
917 int *realnump
, gdb_byte
*valuep
)
919 struct m68k_frame_cache
*cache
= m68k_frame_cache (next_frame
, this_cache
);
921 gdb_assert (regnum
>= 0);
923 if (regnum
== M68K_SP_REGNUM
&& cache
->saved_sp
)
931 /* Store the value. */
932 store_unsigned_integer (valuep
, 4, cache
->saved_sp
);
937 if (regnum
< M68K_NUM_REGS
&& cache
->saved_regs
[regnum
] != -1)
940 *lvalp
= lval_memory
;
941 *addrp
= cache
->saved_regs
[regnum
];
945 /* Read the value in from memory. */
946 read_memory (*addrp
, valuep
,
947 register_size (current_gdbarch
, regnum
));
953 *lvalp
= lval_register
;
957 frame_unwind_register (next_frame
, (*realnump
), valuep
);
960 static const struct frame_unwind m68k_frame_unwind
=
964 m68k_frame_prev_register
967 static const struct frame_unwind
*
968 m68k_frame_sniffer (struct frame_info
*next_frame
)
970 return &m68k_frame_unwind
;
974 m68k_frame_base_address (struct frame_info
*next_frame
, void **this_cache
)
976 struct m68k_frame_cache
*cache
= m68k_frame_cache (next_frame
, this_cache
);
981 static const struct frame_base m68k_frame_base
=
984 m68k_frame_base_address
,
985 m68k_frame_base_address
,
986 m68k_frame_base_address
989 static struct frame_id
990 m68k_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
995 frame_unwind_register (next_frame
, M68K_FP_REGNUM
, buf
);
996 fp
= extract_unsigned_integer (buf
, 4);
998 /* See the end of m68k_push_dummy_call. */
999 return frame_id_build (fp
+ 8, frame_pc_unwind (next_frame
));
1003 /* Figure out where the longjmp will land. Slurp the args out of the stack.
1004 We expect the first arg to be a pointer to the jmp_buf structure from which
1005 we extract the pc (JB_PC) that we will land at. The pc is copied into PC.
1006 This routine returns true on success. */
1009 m68k_get_longjmp_target (struct frame_info
*frame
, CORE_ADDR
*pc
)
1012 CORE_ADDR sp
, jb_addr
;
1013 struct gdbarch_tdep
*tdep
= gdbarch_tdep (get_frame_arch (frame
));
1015 if (tdep
->jb_pc
< 0)
1017 internal_error (__FILE__
, __LINE__
,
1018 _("m68k_get_longjmp_target: not implemented"));
1022 buf
= alloca (gdbarch_ptr_bit (current_gdbarch
) / TARGET_CHAR_BIT
);
1023 sp
= get_frame_register_unsigned (frame
, gdbarch_sp_regnum (current_gdbarch
));
1025 if (target_read_memory (sp
+ SP_ARG0
, /* Offset of first arg on stack */
1027 gdbarch_ptr_bit (current_gdbarch
) / TARGET_CHAR_BIT
))
1030 jb_addr
= extract_unsigned_integer (buf
, gdbarch_ptr_bit (current_gdbarch
)
1033 if (target_read_memory (jb_addr
+ tdep
->jb_pc
* tdep
->jb_elt_size
, buf
,
1034 gdbarch_ptr_bit (current_gdbarch
) / TARGET_CHAR_BIT
))
1037 *pc
= extract_unsigned_integer (buf
, gdbarch_ptr_bit (current_gdbarch
)
1043 /* System V Release 4 (SVR4). */
1046 m68k_svr4_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1048 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1050 /* SVR4 uses a different calling convention. */
1051 set_gdbarch_return_value (gdbarch
, m68k_svr4_return_value
);
1053 /* SVR4 uses %a0 instead of %a1. */
1054 tdep
->struct_value_regnum
= M68K_A0_REGNUM
;
1058 /* Function: m68k_gdbarch_init
1059 Initializer function for the m68k gdbarch vector.
1060 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
1062 static struct gdbarch
*
1063 m68k_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1065 struct gdbarch_tdep
*tdep
= NULL
;
1066 struct gdbarch
*gdbarch
;
1067 struct gdbarch_list
*best_arch
;
1068 struct tdesc_arch_data
*tdesc_data
= NULL
;
1070 enum m68k_flavour flavour
= m68k_no_flavour
;
1072 const struct floatformat
**long_double_format
= floatformats_m68881_ext
;
1074 /* Check any target description for validity. */
1075 if (tdesc_has_registers (info
.target_desc
))
1077 const struct tdesc_feature
*feature
;
1080 feature
= tdesc_find_feature (info
.target_desc
,
1081 "org.gnu.gdb.m68k.core");
1082 if (feature
!= NULL
)
1086 if (feature
== NULL
)
1088 feature
= tdesc_find_feature (info
.target_desc
,
1089 "org.gnu.gdb.coldfire.core");
1090 if (feature
!= NULL
)
1091 flavour
= m68k_coldfire_flavour
;
1094 if (feature
== NULL
)
1096 feature
= tdesc_find_feature (info
.target_desc
,
1097 "org.gnu.gdb.fido.core");
1098 if (feature
!= NULL
)
1099 flavour
= m68k_fido_flavour
;
1102 if (feature
== NULL
)
1105 tdesc_data
= tdesc_data_alloc ();
1108 for (i
= 0; i
<= M68K_PC_REGNUM
; i
++)
1109 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
, i
,
1110 m68k_register_names
[i
]);
1114 tdesc_data_cleanup (tdesc_data
);
1118 feature
= tdesc_find_feature (info
.target_desc
,
1119 "org.gnu.gdb.coldfire.fp");
1120 if (feature
!= NULL
)
1123 for (i
= M68K_FP0_REGNUM
; i
<= M68K_FPI_REGNUM
; i
++)
1124 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
, i
,
1125 m68k_register_names
[i
]);
1128 tdesc_data_cleanup (tdesc_data
);
1136 /* The mechanism for returning floating values from function
1137 and the type of long double depend on whether we're
1138 on ColdFire or standard m68k. */
1140 if (info
.bfd_arch_info
&& info
.bfd_arch_info
->mach
!= 0)
1142 const bfd_arch_info_type
*coldfire_arch
=
1143 bfd_lookup_arch (bfd_arch_m68k
, bfd_mach_mcf_isa_a_nodiv
);
1146 && ((*info
.bfd_arch_info
->compatible
)
1147 (info
.bfd_arch_info
, coldfire_arch
)))
1148 flavour
= m68k_coldfire_flavour
;
1151 /* If there is already a candidate, use it. */
1152 for (best_arch
= gdbarch_list_lookup_by_info (arches
, &info
);
1154 best_arch
= gdbarch_list_lookup_by_info (best_arch
->next
, &info
))
1156 if (flavour
!= gdbarch_tdep (best_arch
->gdbarch
)->flavour
)
1159 if (has_fp
!= gdbarch_tdep (best_arch
->gdbarch
)->fpregs_present
)
1165 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1166 gdbarch
= gdbarch_alloc (&info
, tdep
);
1167 tdep
->fpregs_present
= has_fp
;
1168 tdep
->flavour
= flavour
;
1170 if (flavour
== m68k_coldfire_flavour
|| flavour
== m68k_fido_flavour
)
1171 long_double_format
= floatformats_ieee_double
;
1172 set_gdbarch_long_double_format (gdbarch
, long_double_format
);
1173 set_gdbarch_long_double_bit (gdbarch
, long_double_format
[0]->totalsize
);
1175 set_gdbarch_skip_prologue (gdbarch
, m68k_skip_prologue
);
1176 set_gdbarch_breakpoint_from_pc (gdbarch
, m68k_local_breakpoint_from_pc
);
1178 /* Stack grows down. */
1179 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1180 set_gdbarch_frame_align (gdbarch
, m68k_frame_align
);
1182 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
1183 if (flavour
== m68k_coldfire_flavour
|| flavour
== m68k_fido_flavour
)
1184 set_gdbarch_decr_pc_after_break (gdbarch
, 2);
1186 set_gdbarch_frame_args_skip (gdbarch
, 8);
1187 set_gdbarch_dwarf_reg_to_regnum (gdbarch
, m68k_dwarf_reg_to_regnum
);
1188 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, m68k_dwarf_reg_to_regnum
);
1190 set_gdbarch_register_type (gdbarch
, m68k_register_type
);
1191 set_gdbarch_register_name (gdbarch
, m68k_register_name
);
1192 set_gdbarch_num_regs (gdbarch
, M68K_NUM_REGS
);
1193 set_gdbarch_sp_regnum (gdbarch
, M68K_SP_REGNUM
);
1194 set_gdbarch_pc_regnum (gdbarch
, M68K_PC_REGNUM
);
1195 set_gdbarch_ps_regnum (gdbarch
, M68K_PS_REGNUM
);
1196 set_gdbarch_fp0_regnum (gdbarch
, M68K_FP0_REGNUM
);
1197 set_gdbarch_convert_register_p (gdbarch
, m68k_convert_register_p
);
1198 set_gdbarch_register_to_value (gdbarch
, m68k_register_to_value
);
1199 set_gdbarch_value_to_register (gdbarch
, m68k_value_to_register
);
1202 set_gdbarch_fp0_regnum (gdbarch
, M68K_FP0_REGNUM
);
1204 /* Try to figure out if the arch uses floating registers to return
1205 floating point values from functions. */
1208 /* On ColdFire, floating point values are returned in D0. */
1209 if (flavour
== m68k_coldfire_flavour
)
1210 tdep
->float_return
= 0;
1212 tdep
->float_return
= 1;
1216 /* No floating registers, so can't use them for returning values. */
1217 tdep
->float_return
= 0;
1220 /* Function call & return */
1221 set_gdbarch_push_dummy_call (gdbarch
, m68k_push_dummy_call
);
1222 set_gdbarch_return_value (gdbarch
, m68k_return_value
);
1226 set_gdbarch_print_insn (gdbarch
, print_insn_m68k
);
1228 #if defined JB_PC && defined JB_ELEMENT_SIZE
1229 tdep
->jb_pc
= JB_PC
;
1230 tdep
->jb_elt_size
= JB_ELEMENT_SIZE
;
1234 tdep
->struct_value_regnum
= M68K_A1_REGNUM
;
1235 tdep
->struct_return
= reg_struct_return
;
1237 /* Frame unwinder. */
1238 set_gdbarch_unwind_dummy_id (gdbarch
, m68k_unwind_dummy_id
);
1239 set_gdbarch_unwind_pc (gdbarch
, m68k_unwind_pc
);
1241 /* Hook in the DWARF CFI frame unwinder. */
1242 frame_unwind_append_sniffer (gdbarch
, dwarf2_frame_sniffer
);
1244 frame_base_set_default (gdbarch
, &m68k_frame_base
);
1246 /* Hook in ABI-specific overrides, if they have been registered. */
1247 gdbarch_init_osabi (info
, gdbarch
);
1249 /* Now we have tuned the configuration, set a few final things,
1250 based on what the OS ABI has told us. */
1252 if (tdep
->jb_pc
>= 0)
1253 set_gdbarch_get_longjmp_target (gdbarch
, m68k_get_longjmp_target
);
1255 frame_unwind_append_sniffer (gdbarch
, m68k_frame_sniffer
);
1258 tdesc_use_registers (gdbarch
, tdesc_data
);
1265 m68k_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
1267 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1273 extern initialize_file_ftype _initialize_m68k_tdep
; /* -Wmissing-prototypes */
1276 _initialize_m68k_tdep (void)
1278 gdbarch_register (bfd_arch_m68k
, m68k_gdbarch_init
, m68k_dump_tdep
);
1280 /* Initialize the m68k-specific register types. */