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 (gdbarch
);
110 if (tdep
->fpregs_present
)
112 if (regnum
>= gdbarch_fp0_regnum (gdbarch
)
113 && regnum
<= gdbarch_fp0_regnum (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 (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 (get_frame_arch (frame
),
188 /* We only support floating-point values. */
189 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
191 warning (_("Cannot convert floating-point register value "
192 "to non-floating-point type."));
196 /* Convert to TYPE. This should be a no-op if TYPE is equivalent to
197 the extended floating-point format used by the FPU. */
198 get_frame_register (frame
, regnum
, from
);
199 convert_typed_floating (from
, fpreg_type
, to
, type
);
202 /* Write the contents FROM of a value of type TYPE into register
203 REGNUM in frame FRAME. */
206 m68k_value_to_register (struct frame_info
*frame
, int regnum
,
207 struct type
*type
, const gdb_byte
*from
)
209 gdb_byte to
[M68K_MAX_REGISTER_SIZE
];
210 struct type
*fpreg_type
= register_type (get_frame_arch (frame
),
213 /* We only support floating-point values. */
214 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
216 warning (_("Cannot convert non-floating-point type "
217 "to floating-point register value."));
221 /* Convert from TYPE. This should be a no-op if TYPE is equivalent
222 to the extended floating-point format used by the FPU. */
223 convert_typed_floating (from
, type
, to
, fpreg_type
);
224 put_frame_register (frame
, regnum
, to
);
228 /* There is a fair number of calling conventions that are in somewhat
229 wide use. The 68000/08/10 don't support an FPU, not even as a
230 coprocessor. All function return values are stored in %d0/%d1.
231 Structures are returned in a static buffer, a pointer to which is
232 returned in %d0. This means that functions returning a structure
233 are not re-entrant. To avoid this problem some systems use a
234 convention where the caller passes a pointer to a buffer in %a1
235 where the return values is to be stored. This convention is the
236 default, and is implemented in the function m68k_return_value.
238 The 68020/030/040/060 do support an FPU, either as a coprocessor
239 (68881/2) or built-in (68040/68060). That's why System V release 4
240 (SVR4) instroduces a new calling convention specified by the SVR4
241 psABI. Integer values are returned in %d0/%d1, pointer return
242 values in %a0 and floating values in %fp0. When calling functions
243 returning a structure the caller should pass a pointer to a buffer
244 for the return value in %a0. This convention is implemented in the
245 function m68k_svr4_return_value, and by appropriately setting the
246 struct_value_regnum member of `struct gdbarch_tdep'.
248 GNU/Linux returns values in the same way as SVR4 does, but uses %a1
249 for passing the structure return value buffer.
251 GCC can also generate code where small structures are returned in
252 %d0/%d1 instead of in memory by using -freg-struct-return. This is
253 the default on NetBSD a.out, OpenBSD and GNU/Linux and several
254 embedded systems. This convention is implemented by setting the
255 struct_return member of `struct gdbarch_tdep' to reg_struct_return. */
257 /* Read a function return value of TYPE from REGCACHE, and copy that
261 m68k_extract_return_value (struct type
*type
, struct regcache
*regcache
,
264 int len
= TYPE_LENGTH (type
);
265 gdb_byte buf
[M68K_MAX_REGISTER_SIZE
];
269 regcache_raw_read (regcache
, M68K_D0_REGNUM
, buf
);
270 memcpy (valbuf
, buf
+ (4 - len
), len
);
274 regcache_raw_read (regcache
, M68K_D0_REGNUM
, buf
);
275 memcpy (valbuf
, buf
+ (8 - len
), len
- 4);
276 regcache_raw_read (regcache
, M68K_D1_REGNUM
, valbuf
+ (len
- 4));
279 internal_error (__FILE__
, __LINE__
,
280 _("Cannot extract return value of %d bytes long."), len
);
284 m68k_svr4_extract_return_value (struct type
*type
, struct regcache
*regcache
,
287 int len
= TYPE_LENGTH (type
);
288 gdb_byte buf
[M68K_MAX_REGISTER_SIZE
];
289 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
290 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
292 if (tdep
->float_return
&& TYPE_CODE (type
) == TYPE_CODE_FLT
)
294 struct type
*fpreg_type
= register_type (gdbarch
, M68K_FP0_REGNUM
);
295 regcache_raw_read (regcache
, M68K_FP0_REGNUM
, buf
);
296 convert_typed_floating (buf
, fpreg_type
, valbuf
, type
);
298 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
&& len
== 4)
299 regcache_raw_read (regcache
, M68K_A0_REGNUM
, valbuf
);
301 m68k_extract_return_value (type
, regcache
, valbuf
);
304 /* Write a function return value of TYPE from VALBUF into REGCACHE. */
307 m68k_store_return_value (struct type
*type
, struct regcache
*regcache
,
308 const gdb_byte
*valbuf
)
310 int len
= TYPE_LENGTH (type
);
313 regcache_raw_write_part (regcache
, M68K_D0_REGNUM
, 4 - len
, len
, valbuf
);
316 regcache_raw_write_part (regcache
, M68K_D0_REGNUM
, 8 - len
,
318 regcache_raw_write (regcache
, M68K_D1_REGNUM
, valbuf
+ (len
- 4));
321 internal_error (__FILE__
, __LINE__
,
322 _("Cannot store return value of %d bytes long."), len
);
326 m68k_svr4_store_return_value (struct type
*type
, struct regcache
*regcache
,
327 const gdb_byte
*valbuf
)
329 int len
= TYPE_LENGTH (type
);
330 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
331 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
333 if (tdep
->float_return
&& TYPE_CODE (type
) == TYPE_CODE_FLT
)
335 struct type
*fpreg_type
= register_type (gdbarch
, M68K_FP0_REGNUM
);
336 gdb_byte buf
[M68K_MAX_REGISTER_SIZE
];
337 convert_typed_floating (valbuf
, type
, buf
, fpreg_type
);
338 regcache_raw_write (regcache
, M68K_FP0_REGNUM
, buf
);
340 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
&& len
== 4)
342 regcache_raw_write (regcache
, M68K_A0_REGNUM
, valbuf
);
343 regcache_raw_write (regcache
, M68K_D0_REGNUM
, valbuf
);
346 m68k_store_return_value (type
, regcache
, valbuf
);
349 /* Return non-zero if TYPE, which is assumed to be a structure or
350 union type, should be returned in registers for architecture
354 m68k_reg_struct_return_p (struct gdbarch
*gdbarch
, struct type
*type
)
356 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
357 enum type_code code
= TYPE_CODE (type
);
358 int len
= TYPE_LENGTH (type
);
360 gdb_assert (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
);
362 if (tdep
->struct_return
== pcc_struct_return
)
365 return (len
== 1 || len
== 2 || len
== 4 || len
== 8);
368 /* Determine, for architecture GDBARCH, how a return value of TYPE
369 should be returned. If it is supposed to be returned in registers,
370 and READBUF is non-zero, read the appropriate value from REGCACHE,
371 and copy it into READBUF. If WRITEBUF is non-zero, write the value
372 from WRITEBUF into REGCACHE. */
374 static enum return_value_convention
375 m68k_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
376 struct regcache
*regcache
, gdb_byte
*readbuf
,
377 const gdb_byte
*writebuf
)
379 enum type_code code
= TYPE_CODE (type
);
381 /* GCC returns a `long double' in memory too. */
382 if (((code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
383 && !m68k_reg_struct_return_p (gdbarch
, type
))
384 || (code
== TYPE_CODE_FLT
&& TYPE_LENGTH (type
) == 12))
386 /* The default on m68k is to return structures in static memory.
387 Consequently a function must return the address where we can
388 find the return value. */
394 regcache_raw_read_unsigned (regcache
, M68K_D0_REGNUM
, &addr
);
395 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
398 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
402 m68k_extract_return_value (type
, regcache
, readbuf
);
404 m68k_store_return_value (type
, regcache
, writebuf
);
406 return RETURN_VALUE_REGISTER_CONVENTION
;
409 static enum return_value_convention
410 m68k_svr4_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
411 struct regcache
*regcache
, gdb_byte
*readbuf
,
412 const gdb_byte
*writebuf
)
414 enum type_code code
= TYPE_CODE (type
);
416 if ((code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
417 && !m68k_reg_struct_return_p (gdbarch
, type
))
419 /* The System V ABI says that:
421 "A function returning a structure or union also sets %a0 to
422 the value it finds in %a0. Thus when the caller receives
423 control again, the address of the returned object resides in
426 So the ABI guarantees that we can always find the return
427 value just after the function has returned. */
433 regcache_raw_read_unsigned (regcache
, M68K_A0_REGNUM
, &addr
);
434 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
437 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
440 /* This special case is for structures consisting of a single
441 `float' or `double' member. These structures are returned in
442 %fp0. For these structures, we call ourselves recursively,
443 changing TYPE into the type of the first member of the structure.
444 Since that should work for all structures that have only one
445 member, we don't bother to check the member's type here. */
446 if (code
== TYPE_CODE_STRUCT
&& TYPE_NFIELDS (type
) == 1)
448 type
= check_typedef (TYPE_FIELD_TYPE (type
, 0));
449 return m68k_svr4_return_value (gdbarch
, type
, regcache
,
454 m68k_svr4_extract_return_value (type
, regcache
, readbuf
);
456 m68k_svr4_store_return_value (type
, regcache
, writebuf
);
458 return RETURN_VALUE_REGISTER_CONVENTION
;
462 /* Always align the frame to a 4-byte boundary. This is required on
463 coldfire and harmless on the rest. */
466 m68k_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
468 /* Align the stack to four bytes. */
473 m68k_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
474 struct regcache
*regcache
, CORE_ADDR bp_addr
, int nargs
,
475 struct value
**args
, CORE_ADDR sp
, int struct_return
,
476 CORE_ADDR struct_addr
)
478 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
482 /* Push arguments in reverse order. */
483 for (i
= nargs
- 1; i
>= 0; i
--)
485 struct type
*value_type
= value_enclosing_type (args
[i
]);
486 int len
= TYPE_LENGTH (value_type
);
487 int container_len
= (len
+ 3) & ~3;
490 /* Non-scalars bigger than 4 bytes are left aligned, others are
492 if ((TYPE_CODE (value_type
) == TYPE_CODE_STRUCT
493 || TYPE_CODE (value_type
) == TYPE_CODE_UNION
494 || TYPE_CODE (value_type
) == TYPE_CODE_ARRAY
)
498 offset
= container_len
- len
;
500 write_memory (sp
+ offset
, value_contents_all (args
[i
]), len
);
503 /* Store struct value address. */
506 store_unsigned_integer (buf
, 4, struct_addr
);
507 regcache_cooked_write (regcache
, tdep
->struct_value_regnum
, buf
);
510 /* Store return address. */
512 store_unsigned_integer (buf
, 4, bp_addr
);
513 write_memory (sp
, buf
, 4);
515 /* Finally, update the stack pointer... */
516 store_unsigned_integer (buf
, 4, sp
);
517 regcache_cooked_write (regcache
, M68K_SP_REGNUM
, buf
);
519 /* ...and fake a frame pointer. */
520 regcache_cooked_write (regcache
, M68K_FP_REGNUM
, buf
);
522 /* DWARF2/GCC uses the stack address *before* the function call as a
527 /* Convert a dwarf or dwarf2 regnumber to a GDB regnum. */
530 m68k_dwarf_reg_to_regnum (int num
)
534 return (num
- 0) + M68K_D0_REGNUM
;
537 return (num
- 8) + M68K_A0_REGNUM
;
538 else if (num
< 24 && gdbarch_tdep (current_gdbarch
)->fpregs_present
)
540 return (num
- 16) + M68K_FP0_REGNUM
;
543 return M68K_PC_REGNUM
;
545 return gdbarch_num_regs (current_gdbarch
)
546 + gdbarch_num_pseudo_regs (current_gdbarch
);
550 struct m68k_frame_cache
557 /* Saved registers. */
558 CORE_ADDR saved_regs
[M68K_NUM_REGS
];
561 /* Stack space reserved for local variables. */
565 /* Allocate and initialize a frame cache. */
567 static struct m68k_frame_cache
*
568 m68k_alloc_frame_cache (void)
570 struct m68k_frame_cache
*cache
;
573 cache
= FRAME_OBSTACK_ZALLOC (struct m68k_frame_cache
);
577 cache
->sp_offset
= -4;
580 /* Saved registers. We initialize these to -1 since zero is a valid
581 offset (that's where %fp is supposed to be stored). */
582 for (i
= 0; i
< M68K_NUM_REGS
; i
++)
583 cache
->saved_regs
[i
] = -1;
585 /* Frameless until proven otherwise. */
591 /* Check whether PC points at a code that sets up a new stack frame.
592 If so, it updates CACHE and returns the address of the first
593 instruction after the sequence that sets removes the "hidden"
594 argument from the stack or CURRENT_PC, whichever is smaller.
595 Otherwise, return PC. */
598 m68k_analyze_frame_setup (CORE_ADDR pc
, CORE_ADDR current_pc
,
599 struct m68k_frame_cache
*cache
)
603 if (pc
>= current_pc
)
606 op
= read_memory_unsigned_integer (pc
, 2);
608 if (op
== P_LINKW_FP
|| op
== P_LINKL_FP
|| op
== P_PEA_FP
)
610 cache
->saved_regs
[M68K_FP_REGNUM
] = 0;
611 cache
->sp_offset
+= 4;
612 if (op
== P_LINKW_FP
)
614 /* link.w %fp, #-N */
615 /* link.w %fp, #0; adda.l #-N, %sp */
616 cache
->locals
= -read_memory_integer (pc
+ 2, 2);
618 if (pc
+ 4 < current_pc
&& cache
->locals
== 0)
620 op
= read_memory_unsigned_integer (pc
+ 4, 2);
621 if (op
== P_ADDAL_SP
)
623 cache
->locals
= read_memory_integer (pc
+ 6, 4);
630 else if (op
== P_LINKL_FP
)
632 /* link.l %fp, #-N */
633 cache
->locals
= -read_memory_integer (pc
+ 2, 4);
638 /* pea (%fp); movea.l %sp, %fp */
641 if (pc
+ 2 < current_pc
)
643 op
= read_memory_unsigned_integer (pc
+ 2, 2);
645 if (op
== P_MOVEAL_SP_FP
)
647 /* move.l %sp, %fp */
655 else if ((op
& 0170777) == P_SUBQW_SP
|| (op
& 0170777) == P_SUBQL_SP
)
657 /* subq.[wl] #N,%sp */
658 /* subq.[wl] #8,%sp; subq.[wl] #N,%sp */
659 cache
->locals
= (op
& 07000) == 0 ? 8 : (op
& 07000) >> 9;
660 if (pc
+ 2 < current_pc
)
662 op
= read_memory_unsigned_integer (pc
+ 2, 2);
663 if ((op
& 0170777) == P_SUBQW_SP
|| (op
& 0170777) == P_SUBQL_SP
)
665 cache
->locals
+= (op
& 07000) == 0 ? 8 : (op
& 07000) >> 9;
671 else if (op
== P_ADDAW_SP
|| op
== P_LEA_SP_SP
)
674 /* lea (-N,%sp),%sp */
675 cache
->locals
= -read_memory_integer (pc
+ 2, 2);
678 else if (op
== P_ADDAL_SP
)
681 cache
->locals
= -read_memory_integer (pc
+ 2, 4);
688 /* Check whether PC points at code that saves registers on the stack.
689 If so, it updates CACHE and returns the address of the first
690 instruction after the register saves or CURRENT_PC, whichever is
691 smaller. Otherwise, return PC. */
694 m68k_analyze_register_saves (CORE_ADDR pc
, CORE_ADDR current_pc
,
695 struct m68k_frame_cache
*cache
)
697 if (cache
->locals
>= 0)
703 offset
= -4 - cache
->locals
;
704 while (pc
< current_pc
)
706 op
= read_memory_unsigned_integer (pc
, 2);
707 if (op
== P_FMOVEMX_SP
708 && gdbarch_tdep (current_gdbarch
)->fpregs_present
)
710 /* fmovem.x REGS,-(%sp) */
711 op
= read_memory_unsigned_integer (pc
+ 2, 2);
712 if ((op
& 0xff00) == 0xe000)
715 for (i
= 0; i
< 16; i
++, mask
>>= 1)
719 cache
->saved_regs
[i
+ M68K_FP0_REGNUM
] = offset
;
728 else if ((op
& 0177760) == P_MOVEL_SP
)
730 /* move.l %R,-(%sp) */
732 cache
->saved_regs
[regno
] = offset
;
736 else if (op
== P_MOVEML_SP
)
738 /* movem.l REGS,-(%sp) */
739 mask
= read_memory_unsigned_integer (pc
+ 2, 2);
740 for (i
= 0; i
< 16; i
++, mask
>>= 1)
744 cache
->saved_regs
[15 - i
] = offset
;
759 /* Do a full analysis of the prologue at PC and update CACHE
760 accordingly. Bail out early if CURRENT_PC is reached. Return the
761 address where the analysis stopped.
763 We handle all cases that can be generated by gcc.
765 For allocating a stack frame:
769 pea (%fp); move.l %sp,%fp
770 link.w %a6,#0; add.l #-N,%sp
773 subq.w #8,%sp; subq.w #N-8,%sp
778 For saving registers:
782 move.l R1,-(%sp); move.l R2,-(%sp)
785 For setting up the PIC register:
792 m68k_analyze_prologue (CORE_ADDR pc
, CORE_ADDR current_pc
,
793 struct m68k_frame_cache
*cache
)
797 pc
= m68k_analyze_frame_setup (pc
, current_pc
, cache
);
798 pc
= m68k_analyze_register_saves (pc
, current_pc
, cache
);
799 if (pc
>= current_pc
)
802 /* Check for GOT setup. */
803 op
= read_memory_unsigned_integer (pc
, 4);
804 if (op
== P_LEA_PC_A5
)
806 /* lea (%pc,N),%a5 */
813 /* Return PC of first real instruction. */
816 m68k_skip_prologue (CORE_ADDR start_pc
)
818 struct m68k_frame_cache cache
;
823 pc
= m68k_analyze_prologue (start_pc
, (CORE_ADDR
) -1, &cache
);
824 if (cache
.locals
< 0)
830 m68k_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
834 frame_unwind_register (next_frame
, gdbarch_pc_regnum (gdbarch
), buf
);
835 return extract_typed_address (buf
, builtin_type_void_func_ptr
);
840 static struct m68k_frame_cache
*
841 m68k_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
843 struct m68k_frame_cache
*cache
;
850 cache
= m68k_alloc_frame_cache ();
853 /* In principle, for normal frames, %fp holds the frame pointer,
854 which holds the base address for the current stack frame.
855 However, for functions that don't need it, the frame pointer is
856 optional. For these "frameless" functions the frame pointer is
857 actually the frame pointer of the calling frame. Signal
858 trampolines are just a special case of a "frameless" function.
859 They (usually) share their frame pointer with the frame that was
860 in progress when the signal occurred. */
862 frame_unwind_register (next_frame
, M68K_FP_REGNUM
, buf
);
863 cache
->base
= extract_unsigned_integer (buf
, 4);
864 if (cache
->base
== 0)
867 /* For normal frames, %pc is stored at 4(%fp). */
868 cache
->saved_regs
[M68K_PC_REGNUM
] = 4;
870 cache
->pc
= frame_func_unwind (next_frame
, NORMAL_FRAME
);
872 m68k_analyze_prologue (cache
->pc
, frame_pc_unwind (next_frame
), cache
);
874 if (cache
->locals
< 0)
876 /* We didn't find a valid frame, which means that CACHE->base
877 currently holds the frame pointer for our calling frame. If
878 we're at the start of a function, or somewhere half-way its
879 prologue, the function's frame probably hasn't been fully
880 setup yet. Try to reconstruct the base address for the stack
881 frame by looking at the stack pointer. For truly "frameless"
882 functions this might work too. */
884 frame_unwind_register (next_frame
, M68K_SP_REGNUM
, buf
);
885 cache
->base
= extract_unsigned_integer (buf
, 4) + cache
->sp_offset
;
888 /* Now that we have the base address for the stack frame we can
889 calculate the value of %sp in the calling frame. */
890 cache
->saved_sp
= cache
->base
+ 8;
892 /* Adjust all the saved registers such that they contain addresses
893 instead of offsets. */
894 for (i
= 0; i
< M68K_NUM_REGS
; i
++)
895 if (cache
->saved_regs
[i
] != -1)
896 cache
->saved_regs
[i
] += cache
->base
;
902 m68k_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
903 struct frame_id
*this_id
)
905 struct m68k_frame_cache
*cache
= m68k_frame_cache (next_frame
, this_cache
);
907 /* This marks the outermost frame. */
908 if (cache
->base
== 0)
911 /* See the end of m68k_push_dummy_call. */
912 *this_id
= frame_id_build (cache
->base
+ 8, cache
->pc
);
916 m68k_frame_prev_register (struct frame_info
*next_frame
, void **this_cache
,
917 int regnum
, int *optimizedp
,
918 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
919 int *realnump
, gdb_byte
*valuep
)
921 struct m68k_frame_cache
*cache
= m68k_frame_cache (next_frame
, this_cache
);
923 gdb_assert (regnum
>= 0);
925 if (regnum
== M68K_SP_REGNUM
&& cache
->saved_sp
)
933 /* Store the value. */
934 store_unsigned_integer (valuep
, 4, cache
->saved_sp
);
939 if (regnum
< M68K_NUM_REGS
&& cache
->saved_regs
[regnum
] != -1)
942 *lvalp
= lval_memory
;
943 *addrp
= cache
->saved_regs
[regnum
];
947 /* Read the value in from memory. */
948 read_memory (*addrp
, valuep
,
949 register_size (get_frame_arch (next_frame
), regnum
));
955 *lvalp
= lval_register
;
959 frame_unwind_register (next_frame
, (*realnump
), valuep
);
962 static const struct frame_unwind m68k_frame_unwind
=
966 m68k_frame_prev_register
969 static const struct frame_unwind
*
970 m68k_frame_sniffer (struct frame_info
*next_frame
)
972 return &m68k_frame_unwind
;
976 m68k_frame_base_address (struct frame_info
*next_frame
, void **this_cache
)
978 struct m68k_frame_cache
*cache
= m68k_frame_cache (next_frame
, this_cache
);
983 static const struct frame_base m68k_frame_base
=
986 m68k_frame_base_address
,
987 m68k_frame_base_address
,
988 m68k_frame_base_address
991 static struct frame_id
992 m68k_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
997 frame_unwind_register (next_frame
, M68K_FP_REGNUM
, buf
);
998 fp
= extract_unsigned_integer (buf
, 4);
1000 /* See the end of m68k_push_dummy_call. */
1001 return frame_id_build (fp
+ 8, frame_pc_unwind (next_frame
));
1005 /* Figure out where the longjmp will land. Slurp the args out of the stack.
1006 We expect the first arg to be a pointer to the jmp_buf structure from which
1007 we extract the pc (JB_PC) that we will land at. The pc is copied into PC.
1008 This routine returns true on success. */
1011 m68k_get_longjmp_target (struct frame_info
*frame
, CORE_ADDR
*pc
)
1014 CORE_ADDR sp
, jb_addr
;
1015 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1016 struct gdbarch_tdep
*tdep
= gdbarch_tdep (get_frame_arch (frame
));
1018 if (tdep
->jb_pc
< 0)
1020 internal_error (__FILE__
, __LINE__
,
1021 _("m68k_get_longjmp_target: not implemented"));
1025 buf
= alloca (gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
);
1026 sp
= get_frame_register_unsigned (frame
, gdbarch_sp_regnum (gdbarch
));
1028 if (target_read_memory (sp
+ SP_ARG0
, /* Offset of first arg on stack */
1029 buf
, gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
))
1032 jb_addr
= extract_unsigned_integer (buf
, gdbarch_ptr_bit (gdbarch
)
1035 if (target_read_memory (jb_addr
+ tdep
->jb_pc
* tdep
->jb_elt_size
, buf
,
1036 gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
))
1039 *pc
= extract_unsigned_integer (buf
, gdbarch_ptr_bit (gdbarch
)
1045 /* System V Release 4 (SVR4). */
1048 m68k_svr4_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1050 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1052 /* SVR4 uses a different calling convention. */
1053 set_gdbarch_return_value (gdbarch
, m68k_svr4_return_value
);
1055 /* SVR4 uses %a0 instead of %a1. */
1056 tdep
->struct_value_regnum
= M68K_A0_REGNUM
;
1060 /* Function: m68k_gdbarch_init
1061 Initializer function for the m68k gdbarch vector.
1062 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
1064 static struct gdbarch
*
1065 m68k_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1067 struct gdbarch_tdep
*tdep
= NULL
;
1068 struct gdbarch
*gdbarch
;
1069 struct gdbarch_list
*best_arch
;
1070 struct tdesc_arch_data
*tdesc_data
= NULL
;
1072 enum m68k_flavour flavour
= m68k_no_flavour
;
1074 const struct floatformat
**long_double_format
= floatformats_m68881_ext
;
1076 /* Check any target description for validity. */
1077 if (tdesc_has_registers (info
.target_desc
))
1079 const struct tdesc_feature
*feature
;
1082 feature
= tdesc_find_feature (info
.target_desc
,
1083 "org.gnu.gdb.m68k.core");
1084 if (feature
!= NULL
)
1088 if (feature
== NULL
)
1090 feature
= tdesc_find_feature (info
.target_desc
,
1091 "org.gnu.gdb.coldfire.core");
1092 if (feature
!= NULL
)
1093 flavour
= m68k_coldfire_flavour
;
1096 if (feature
== NULL
)
1098 feature
= tdesc_find_feature (info
.target_desc
,
1099 "org.gnu.gdb.fido.core");
1100 if (feature
!= NULL
)
1101 flavour
= m68k_fido_flavour
;
1104 if (feature
== NULL
)
1107 tdesc_data
= tdesc_data_alloc ();
1110 for (i
= 0; i
<= M68K_PC_REGNUM
; i
++)
1111 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
, i
,
1112 m68k_register_names
[i
]);
1116 tdesc_data_cleanup (tdesc_data
);
1120 feature
= tdesc_find_feature (info
.target_desc
,
1121 "org.gnu.gdb.coldfire.fp");
1122 if (feature
!= NULL
)
1125 for (i
= M68K_FP0_REGNUM
; i
<= M68K_FPI_REGNUM
; i
++)
1126 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
, i
,
1127 m68k_register_names
[i
]);
1130 tdesc_data_cleanup (tdesc_data
);
1138 /* The mechanism for returning floating values from function
1139 and the type of long double depend on whether we're
1140 on ColdFire or standard m68k. */
1142 if (info
.bfd_arch_info
&& info
.bfd_arch_info
->mach
!= 0)
1144 const bfd_arch_info_type
*coldfire_arch
=
1145 bfd_lookup_arch (bfd_arch_m68k
, bfd_mach_mcf_isa_a_nodiv
);
1148 && ((*info
.bfd_arch_info
->compatible
)
1149 (info
.bfd_arch_info
, coldfire_arch
)))
1150 flavour
= m68k_coldfire_flavour
;
1153 /* If there is already a candidate, use it. */
1154 for (best_arch
= gdbarch_list_lookup_by_info (arches
, &info
);
1156 best_arch
= gdbarch_list_lookup_by_info (best_arch
->next
, &info
))
1158 if (flavour
!= gdbarch_tdep (best_arch
->gdbarch
)->flavour
)
1161 if (has_fp
!= gdbarch_tdep (best_arch
->gdbarch
)->fpregs_present
)
1167 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1168 gdbarch
= gdbarch_alloc (&info
, tdep
);
1169 tdep
->fpregs_present
= has_fp
;
1170 tdep
->flavour
= flavour
;
1172 if (flavour
== m68k_coldfire_flavour
|| flavour
== m68k_fido_flavour
)
1173 long_double_format
= floatformats_ieee_double
;
1174 set_gdbarch_long_double_format (gdbarch
, long_double_format
);
1175 set_gdbarch_long_double_bit (gdbarch
, long_double_format
[0]->totalsize
);
1177 set_gdbarch_skip_prologue (gdbarch
, m68k_skip_prologue
);
1178 set_gdbarch_breakpoint_from_pc (gdbarch
, m68k_local_breakpoint_from_pc
);
1180 /* Stack grows down. */
1181 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1182 set_gdbarch_frame_align (gdbarch
, m68k_frame_align
);
1184 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
1185 if (flavour
== m68k_coldfire_flavour
|| flavour
== m68k_fido_flavour
)
1186 set_gdbarch_decr_pc_after_break (gdbarch
, 2);
1188 set_gdbarch_frame_args_skip (gdbarch
, 8);
1189 set_gdbarch_dwarf_reg_to_regnum (gdbarch
, m68k_dwarf_reg_to_regnum
);
1190 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, m68k_dwarf_reg_to_regnum
);
1192 set_gdbarch_register_type (gdbarch
, m68k_register_type
);
1193 set_gdbarch_register_name (gdbarch
, m68k_register_name
);
1194 set_gdbarch_num_regs (gdbarch
, M68K_NUM_REGS
);
1195 set_gdbarch_sp_regnum (gdbarch
, M68K_SP_REGNUM
);
1196 set_gdbarch_pc_regnum (gdbarch
, M68K_PC_REGNUM
);
1197 set_gdbarch_ps_regnum (gdbarch
, M68K_PS_REGNUM
);
1198 set_gdbarch_fp0_regnum (gdbarch
, M68K_FP0_REGNUM
);
1199 set_gdbarch_convert_register_p (gdbarch
, m68k_convert_register_p
);
1200 set_gdbarch_register_to_value (gdbarch
, m68k_register_to_value
);
1201 set_gdbarch_value_to_register (gdbarch
, m68k_value_to_register
);
1204 set_gdbarch_fp0_regnum (gdbarch
, M68K_FP0_REGNUM
);
1206 /* Try to figure out if the arch uses floating registers to return
1207 floating point values from functions. */
1210 /* On ColdFire, floating point values are returned in D0. */
1211 if (flavour
== m68k_coldfire_flavour
)
1212 tdep
->float_return
= 0;
1214 tdep
->float_return
= 1;
1218 /* No floating registers, so can't use them for returning values. */
1219 tdep
->float_return
= 0;
1222 /* Function call & return */
1223 set_gdbarch_push_dummy_call (gdbarch
, m68k_push_dummy_call
);
1224 set_gdbarch_return_value (gdbarch
, m68k_return_value
);
1228 set_gdbarch_print_insn (gdbarch
, print_insn_m68k
);
1230 #if defined JB_PC && defined JB_ELEMENT_SIZE
1231 tdep
->jb_pc
= JB_PC
;
1232 tdep
->jb_elt_size
= JB_ELEMENT_SIZE
;
1236 tdep
->struct_value_regnum
= M68K_A1_REGNUM
;
1237 tdep
->struct_return
= reg_struct_return
;
1239 /* Frame unwinder. */
1240 set_gdbarch_unwind_dummy_id (gdbarch
, m68k_unwind_dummy_id
);
1241 set_gdbarch_unwind_pc (gdbarch
, m68k_unwind_pc
);
1243 /* Hook in the DWARF CFI frame unwinder. */
1244 frame_unwind_append_sniffer (gdbarch
, dwarf2_frame_sniffer
);
1246 frame_base_set_default (gdbarch
, &m68k_frame_base
);
1248 /* Hook in ABI-specific overrides, if they have been registered. */
1249 gdbarch_init_osabi (info
, gdbarch
);
1251 /* Now we have tuned the configuration, set a few final things,
1252 based on what the OS ABI has told us. */
1254 if (tdep
->jb_pc
>= 0)
1255 set_gdbarch_get_longjmp_target (gdbarch
, m68k_get_longjmp_target
);
1257 frame_unwind_append_sniffer (gdbarch
, m68k_frame_sniffer
);
1260 tdesc_use_registers (gdbarch
, tdesc_data
);
1267 m68k_dump_tdep (struct gdbarch
*gdbarch
, struct ui_file
*file
)
1269 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1275 extern initialize_file_ftype _initialize_m68k_tdep
; /* -Wmissing-prototypes */
1278 _initialize_m68k_tdep (void)
1280 gdbarch_register (bfd_arch_m68k
, m68k_gdbarch_init
, m68k_dump_tdep
);
1282 /* Initialize the m68k-specific register types. */