1 /* Target-dependent code for the Motorola 68000 series.
3 Copyright (C) 1990-2017 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "dwarf2-frame.h"
23 #include "frame-base.h"
24 #include "frame-unwind.h"
31 #include "arch-utils.h"
34 #include "target-descriptions.h"
36 #include "m68k-tdep.h"
39 #define P_LINKL_FP 0x480e
40 #define P_LINKW_FP 0x4e56
41 #define P_PEA_FP 0x4856
42 #define P_MOVEAL_SP_FP 0x2c4f
43 #define P_ADDAW_SP 0xdefc
44 #define P_ADDAL_SP 0xdffc
45 #define P_SUBQW_SP 0x514f
46 #define P_SUBQL_SP 0x518f
47 #define P_LEA_SP_SP 0x4fef
48 #define P_LEA_PC_A5 0x4bfb0170
49 #define P_FMOVEMX_SP 0xf227
50 #define P_MOVEL_SP 0x2f00
51 #define P_MOVEML_SP 0x48e7
53 /* Offset from SP to first arg on stack at first instruction of a function. */
54 #define SP_ARG0 (1 * 4)
56 #if !defined (BPT_VECTOR)
57 #define BPT_VECTOR 0xf
60 constexpr gdb_byte m68k_break_insn
[] = {0x4e, (0x40 | BPT_VECTOR
)};
62 typedef BP_MANIPULATION (m68k_break_insn
) m68k_breakpoint
;
65 /* Construct types for ISA-specific registers. */
67 m68k_ps_type (struct gdbarch
*gdbarch
)
69 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
71 if (!tdep
->m68k_ps_type
)
75 type
= arch_flags_type (gdbarch
, "builtin_type_m68k_ps", 4);
76 append_flags_type_flag (type
, 0, "C");
77 append_flags_type_flag (type
, 1, "V");
78 append_flags_type_flag (type
, 2, "Z");
79 append_flags_type_flag (type
, 3, "N");
80 append_flags_type_flag (type
, 4, "X");
81 append_flags_type_flag (type
, 8, "I0");
82 append_flags_type_flag (type
, 9, "I1");
83 append_flags_type_flag (type
, 10, "I2");
84 append_flags_type_flag (type
, 12, "M");
85 append_flags_type_flag (type
, 13, "S");
86 append_flags_type_flag (type
, 14, "T0");
87 append_flags_type_flag (type
, 15, "T1");
89 tdep
->m68k_ps_type
= type
;
92 return tdep
->m68k_ps_type
;
96 m68881_ext_type (struct gdbarch
*gdbarch
)
98 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
100 if (!tdep
->m68881_ext_type
)
101 tdep
->m68881_ext_type
102 = arch_float_type (gdbarch
, -1, "builtin_type_m68881_ext",
103 floatformats_m68881_ext
);
105 return tdep
->m68881_ext_type
;
108 /* Return the GDB type object for the "standard" data type of data in
109 register N. This should be int for D0-D7, SR, FPCONTROL and
110 FPSTATUS, long double for FP0-FP7, and void pointer for all others
111 (A0-A7, PC, FPIADDR). Note, for registers which contain
112 addresses return pointer to void, not pointer to char, because we
113 don't want to attempt to print the string after printing the
117 m68k_register_type (struct gdbarch
*gdbarch
, int regnum
)
119 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
121 if (tdep
->fpregs_present
)
123 if (regnum
>= gdbarch_fp0_regnum (gdbarch
)
124 && regnum
<= gdbarch_fp0_regnum (gdbarch
) + 7)
126 if (tdep
->flavour
== m68k_coldfire_flavour
)
127 return builtin_type (gdbarch
)->builtin_double
;
129 return m68881_ext_type (gdbarch
);
132 if (regnum
== M68K_FPI_REGNUM
)
133 return builtin_type (gdbarch
)->builtin_func_ptr
;
135 if (regnum
== M68K_FPC_REGNUM
|| regnum
== M68K_FPS_REGNUM
)
136 return builtin_type (gdbarch
)->builtin_int32
;
140 if (regnum
>= M68K_FP0_REGNUM
&& regnum
<= M68K_FPI_REGNUM
)
141 return builtin_type (gdbarch
)->builtin_int0
;
144 if (regnum
== gdbarch_pc_regnum (gdbarch
))
145 return builtin_type (gdbarch
)->builtin_func_ptr
;
147 if (regnum
>= M68K_A0_REGNUM
&& regnum
<= M68K_A0_REGNUM
+ 7)
148 return builtin_type (gdbarch
)->builtin_data_ptr
;
150 if (regnum
== M68K_PS_REGNUM
)
151 return m68k_ps_type (gdbarch
);
153 return builtin_type (gdbarch
)->builtin_int32
;
156 static const char *m68k_register_names
[] = {
157 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
158 "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp",
160 "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7",
161 "fpcontrol", "fpstatus", "fpiaddr"
164 /* Function: m68k_register_name
165 Returns the name of the standard m68k register regnum. */
168 m68k_register_name (struct gdbarch
*gdbarch
, int regnum
)
170 if (regnum
< 0 || regnum
>= ARRAY_SIZE (m68k_register_names
))
171 internal_error (__FILE__
, __LINE__
,
172 _("m68k_register_name: illegal register number %d"),
174 else if (regnum
>= M68K_FP0_REGNUM
&& regnum
<= M68K_FPI_REGNUM
175 && gdbarch_tdep (gdbarch
)->fpregs_present
== 0)
178 return m68k_register_names
[regnum
];
181 /* Return nonzero if a value of type TYPE stored in register REGNUM
182 needs any special handling. */
185 m68k_convert_register_p (struct gdbarch
*gdbarch
,
186 int regnum
, struct type
*type
)
188 if (!gdbarch_tdep (gdbarch
)->fpregs_present
)
190 return (regnum
>= M68K_FP0_REGNUM
&& regnum
<= M68K_FP0_REGNUM
+ 7
191 && type
!= register_type (gdbarch
, M68K_FP0_REGNUM
));
194 /* Read a value of type TYPE from register REGNUM in frame FRAME, and
195 return its contents in TO. */
198 m68k_register_to_value (struct frame_info
*frame
, int regnum
,
199 struct type
*type
, gdb_byte
*to
,
200 int *optimizedp
, int *unavailablep
)
202 gdb_byte from
[M68K_MAX_REGISTER_SIZE
];
203 struct type
*fpreg_type
= register_type (get_frame_arch (frame
),
206 /* We only support floating-point values. */
207 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
209 warning (_("Cannot convert floating-point register value "
210 "to non-floating-point type."));
211 *optimizedp
= *unavailablep
= 0;
215 /* Convert to TYPE. */
217 /* Convert to TYPE. */
218 if (!get_frame_register_bytes (frame
, regnum
, 0, TYPE_LENGTH (type
),
219 from
, optimizedp
, unavailablep
))
222 convert_typed_floating (from
, fpreg_type
, to
, type
);
223 *optimizedp
= *unavailablep
= 0;
227 /* Write the contents FROM of a value of type TYPE into register
228 REGNUM in frame FRAME. */
231 m68k_value_to_register (struct frame_info
*frame
, int regnum
,
232 struct type
*type
, const gdb_byte
*from
)
234 gdb_byte to
[M68K_MAX_REGISTER_SIZE
];
235 struct type
*fpreg_type
= register_type (get_frame_arch (frame
),
238 /* We only support floating-point values. */
239 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
241 warning (_("Cannot convert non-floating-point type "
242 "to floating-point register value."));
246 /* Convert from TYPE. */
247 convert_typed_floating (from
, type
, to
, fpreg_type
);
248 put_frame_register (frame
, regnum
, to
);
252 /* There is a fair number of calling conventions that are in somewhat
253 wide use. The 68000/08/10 don't support an FPU, not even as a
254 coprocessor. All function return values are stored in %d0/%d1.
255 Structures are returned in a static buffer, a pointer to which is
256 returned in %d0. This means that functions returning a structure
257 are not re-entrant. To avoid this problem some systems use a
258 convention where the caller passes a pointer to a buffer in %a1
259 where the return values is to be stored. This convention is the
260 default, and is implemented in the function m68k_return_value.
262 The 68020/030/040/060 do support an FPU, either as a coprocessor
263 (68881/2) or built-in (68040/68060). That's why System V release 4
264 (SVR4) instroduces a new calling convention specified by the SVR4
265 psABI. Integer values are returned in %d0/%d1, pointer return
266 values in %a0 and floating values in %fp0. When calling functions
267 returning a structure the caller should pass a pointer to a buffer
268 for the return value in %a0. This convention is implemented in the
269 function m68k_svr4_return_value, and by appropriately setting the
270 struct_value_regnum member of `struct gdbarch_tdep'.
272 GNU/Linux returns values in the same way as SVR4 does, but uses %a1
273 for passing the structure return value buffer.
275 GCC can also generate code where small structures are returned in
276 %d0/%d1 instead of in memory by using -freg-struct-return. This is
277 the default on NetBSD a.out, OpenBSD and GNU/Linux and several
278 embedded systems. This convention is implemented by setting the
279 struct_return member of `struct gdbarch_tdep' to reg_struct_return. */
281 /* Read a function return value of TYPE from REGCACHE, and copy that
285 m68k_extract_return_value (struct type
*type
, struct regcache
*regcache
,
288 int len
= TYPE_LENGTH (type
);
289 gdb_byte buf
[M68K_MAX_REGISTER_SIZE
];
293 regcache_raw_read (regcache
, M68K_D0_REGNUM
, buf
);
294 memcpy (valbuf
, buf
+ (4 - len
), len
);
298 regcache_raw_read (regcache
, M68K_D0_REGNUM
, buf
);
299 memcpy (valbuf
, buf
+ (8 - len
), len
- 4);
300 regcache_raw_read (regcache
, M68K_D1_REGNUM
, valbuf
+ (len
- 4));
303 internal_error (__FILE__
, __LINE__
,
304 _("Cannot extract return value of %d bytes long."), len
);
308 m68k_svr4_extract_return_value (struct type
*type
, struct regcache
*regcache
,
311 gdb_byte buf
[M68K_MAX_REGISTER_SIZE
];
312 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
313 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
315 if (tdep
->float_return
&& TYPE_CODE (type
) == TYPE_CODE_FLT
)
317 struct type
*fpreg_type
= register_type (gdbarch
, M68K_FP0_REGNUM
);
318 regcache_raw_read (regcache
, M68K_FP0_REGNUM
, buf
);
319 convert_typed_floating (buf
, fpreg_type
, valbuf
, type
);
321 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
&& TYPE_LENGTH (type
) == 4)
322 regcache_raw_read (regcache
, M68K_A0_REGNUM
, valbuf
);
324 m68k_extract_return_value (type
, regcache
, valbuf
);
327 /* Write a function return value of TYPE from VALBUF into REGCACHE. */
330 m68k_store_return_value (struct type
*type
, struct regcache
*regcache
,
331 const gdb_byte
*valbuf
)
333 int len
= TYPE_LENGTH (type
);
336 regcache_raw_write_part (regcache
, M68K_D0_REGNUM
, 4 - len
, len
, valbuf
);
339 regcache_raw_write_part (regcache
, M68K_D0_REGNUM
, 8 - len
,
341 regcache_raw_write (regcache
, M68K_D1_REGNUM
, valbuf
+ (len
- 4));
344 internal_error (__FILE__
, __LINE__
,
345 _("Cannot store return value of %d bytes long."), len
);
349 m68k_svr4_store_return_value (struct type
*type
, struct regcache
*regcache
,
350 const gdb_byte
*valbuf
)
352 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
353 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
355 if (tdep
->float_return
&& TYPE_CODE (type
) == TYPE_CODE_FLT
)
357 struct type
*fpreg_type
= register_type (gdbarch
, M68K_FP0_REGNUM
);
358 gdb_byte buf
[M68K_MAX_REGISTER_SIZE
];
359 convert_typed_floating (valbuf
, type
, buf
, fpreg_type
);
360 regcache_raw_write (regcache
, M68K_FP0_REGNUM
, buf
);
362 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
&& TYPE_LENGTH (type
) == 4)
364 regcache_raw_write (regcache
, M68K_A0_REGNUM
, valbuf
);
365 regcache_raw_write (regcache
, M68K_D0_REGNUM
, valbuf
);
368 m68k_store_return_value (type
, regcache
, valbuf
);
371 /* Return non-zero if TYPE, which is assumed to be a structure, union or
372 complex type, should be returned in registers for architecture
376 m68k_reg_struct_return_p (struct gdbarch
*gdbarch
, struct type
*type
)
378 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
379 enum type_code code
= TYPE_CODE (type
);
380 int len
= TYPE_LENGTH (type
);
382 gdb_assert (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
383 || code
== TYPE_CODE_COMPLEX
);
385 if (tdep
->struct_return
== pcc_struct_return
)
388 return (len
== 1 || len
== 2 || len
== 4 || len
== 8);
391 /* Determine, for architecture GDBARCH, how a return value of TYPE
392 should be returned. If it is supposed to be returned in registers,
393 and READBUF is non-zero, read the appropriate value from REGCACHE,
394 and copy it into READBUF. If WRITEBUF is non-zero, write the value
395 from WRITEBUF into REGCACHE. */
397 static enum return_value_convention
398 m68k_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
399 struct type
*type
, struct regcache
*regcache
,
400 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
402 enum type_code code
= TYPE_CODE (type
);
404 /* GCC returns a `long double' in memory too. */
405 if (((code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
406 || code
== TYPE_CODE_COMPLEX
)
407 && !m68k_reg_struct_return_p (gdbarch
, type
))
408 || (code
== TYPE_CODE_FLT
&& TYPE_LENGTH (type
) == 12))
410 /* The default on m68k is to return structures in static memory.
411 Consequently a function must return the address where we can
412 find the return value. */
418 regcache_raw_read_unsigned (regcache
, M68K_D0_REGNUM
, &addr
);
419 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
422 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
426 m68k_extract_return_value (type
, regcache
, readbuf
);
428 m68k_store_return_value (type
, regcache
, writebuf
);
430 return RETURN_VALUE_REGISTER_CONVENTION
;
433 static enum return_value_convention
434 m68k_svr4_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
435 struct type
*type
, struct regcache
*regcache
,
436 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
438 enum type_code code
= TYPE_CODE (type
);
440 if ((code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
441 || code
== TYPE_CODE_COMPLEX
)
442 && !m68k_reg_struct_return_p (gdbarch
, type
))
444 /* The System V ABI says that:
446 "A function returning a structure or union also sets %a0 to
447 the value it finds in %a0. Thus when the caller receives
448 control again, the address of the returned object resides in
451 So the ABI guarantees that we can always find the return
452 value just after the function has returned. */
458 regcache_raw_read_unsigned (regcache
, M68K_A0_REGNUM
, &addr
);
459 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
462 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
465 /* This special case is for structures consisting of a single
466 `float' or `double' member. These structures are returned in
467 %fp0. For these structures, we call ourselves recursively,
468 changing TYPE into the type of the first member of the structure.
469 Since that should work for all structures that have only one
470 member, we don't bother to check the member's type here. */
471 if (code
== TYPE_CODE_STRUCT
&& TYPE_NFIELDS (type
) == 1)
473 type
= check_typedef (TYPE_FIELD_TYPE (type
, 0));
474 return m68k_svr4_return_value (gdbarch
, function
, type
, regcache
,
479 m68k_svr4_extract_return_value (type
, regcache
, readbuf
);
481 m68k_svr4_store_return_value (type
, regcache
, writebuf
);
483 return RETURN_VALUE_REGISTER_CONVENTION
;
487 /* Always align the frame to a 4-byte boundary. This is required on
488 coldfire and harmless on the rest. */
491 m68k_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
493 /* Align the stack to four bytes. */
498 m68k_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
499 struct regcache
*regcache
, CORE_ADDR bp_addr
, int nargs
,
500 struct value
**args
, CORE_ADDR sp
, int struct_return
,
501 CORE_ADDR struct_addr
)
503 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
504 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
508 /* Push arguments in reverse order. */
509 for (i
= nargs
- 1; i
>= 0; i
--)
511 struct type
*value_type
= value_enclosing_type (args
[i
]);
512 int len
= TYPE_LENGTH (value_type
);
513 int container_len
= (len
+ 3) & ~3;
516 /* Non-scalars bigger than 4 bytes are left aligned, others are
518 if ((TYPE_CODE (value_type
) == TYPE_CODE_STRUCT
519 || TYPE_CODE (value_type
) == TYPE_CODE_UNION
520 || TYPE_CODE (value_type
) == TYPE_CODE_ARRAY
)
524 offset
= container_len
- len
;
526 write_memory (sp
+ offset
, value_contents_all (args
[i
]), len
);
529 /* Store struct value address. */
532 store_unsigned_integer (buf
, 4, byte_order
, struct_addr
);
533 regcache_cooked_write (regcache
, tdep
->struct_value_regnum
, buf
);
536 /* Store return address. */
538 store_unsigned_integer (buf
, 4, byte_order
, bp_addr
);
539 write_memory (sp
, buf
, 4);
541 /* Finally, update the stack pointer... */
542 store_unsigned_integer (buf
, 4, byte_order
, sp
);
543 regcache_cooked_write (regcache
, M68K_SP_REGNUM
, buf
);
545 /* ...and fake a frame pointer. */
546 regcache_cooked_write (regcache
, M68K_FP_REGNUM
, buf
);
548 /* DWARF2/GCC uses the stack address *before* the function call as a
553 /* Convert a dwarf or dwarf2 regnumber to a GDB regnum. */
556 m68k_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int num
)
560 return (num
- 0) + M68K_D0_REGNUM
;
563 return (num
- 8) + M68K_A0_REGNUM
;
564 else if (num
< 24 && gdbarch_tdep (gdbarch
)->fpregs_present
)
566 return (num
- 16) + M68K_FP0_REGNUM
;
569 return M68K_PC_REGNUM
;
575 struct m68k_frame_cache
582 /* Saved registers. */
583 CORE_ADDR saved_regs
[M68K_NUM_REGS
];
586 /* Stack space reserved for local variables. */
590 /* Allocate and initialize a frame cache. */
592 static struct m68k_frame_cache
*
593 m68k_alloc_frame_cache (void)
595 struct m68k_frame_cache
*cache
;
598 cache
= FRAME_OBSTACK_ZALLOC (struct m68k_frame_cache
);
602 cache
->sp_offset
= -4;
605 /* Saved registers. We initialize these to -1 since zero is a valid
606 offset (that's where %fp is supposed to be stored). */
607 for (i
= 0; i
< M68K_NUM_REGS
; i
++)
608 cache
->saved_regs
[i
] = -1;
610 /* Frameless until proven otherwise. */
616 /* Check whether PC points at a code that sets up a new stack frame.
617 If so, it updates CACHE and returns the address of the first
618 instruction after the sequence that sets removes the "hidden"
619 argument from the stack or CURRENT_PC, whichever is smaller.
620 Otherwise, return PC. */
623 m68k_analyze_frame_setup (struct gdbarch
*gdbarch
,
624 CORE_ADDR pc
, CORE_ADDR current_pc
,
625 struct m68k_frame_cache
*cache
)
627 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
630 if (pc
>= current_pc
)
633 op
= read_memory_unsigned_integer (pc
, 2, byte_order
);
635 if (op
== P_LINKW_FP
|| op
== P_LINKL_FP
|| op
== P_PEA_FP
)
637 cache
->saved_regs
[M68K_FP_REGNUM
] = 0;
638 cache
->sp_offset
+= 4;
639 if (op
== P_LINKW_FP
)
641 /* link.w %fp, #-N */
642 /* link.w %fp, #0; adda.l #-N, %sp */
643 cache
->locals
= -read_memory_integer (pc
+ 2, 2, byte_order
);
645 if (pc
+ 4 < current_pc
&& cache
->locals
== 0)
647 op
= read_memory_unsigned_integer (pc
+ 4, 2, byte_order
);
648 if (op
== P_ADDAL_SP
)
650 cache
->locals
= read_memory_integer (pc
+ 6, 4, byte_order
);
657 else if (op
== P_LINKL_FP
)
659 /* link.l %fp, #-N */
660 cache
->locals
= -read_memory_integer (pc
+ 2, 4, byte_order
);
665 /* pea (%fp); movea.l %sp, %fp */
668 if (pc
+ 2 < current_pc
)
670 op
= read_memory_unsigned_integer (pc
+ 2, 2, byte_order
);
672 if (op
== P_MOVEAL_SP_FP
)
674 /* move.l %sp, %fp */
682 else if ((op
& 0170777) == P_SUBQW_SP
|| (op
& 0170777) == P_SUBQL_SP
)
684 /* subq.[wl] #N,%sp */
685 /* subq.[wl] #8,%sp; subq.[wl] #N,%sp */
686 cache
->locals
= (op
& 07000) == 0 ? 8 : (op
& 07000) >> 9;
687 if (pc
+ 2 < current_pc
)
689 op
= read_memory_unsigned_integer (pc
+ 2, 2, byte_order
);
690 if ((op
& 0170777) == P_SUBQW_SP
|| (op
& 0170777) == P_SUBQL_SP
)
692 cache
->locals
+= (op
& 07000) == 0 ? 8 : (op
& 07000) >> 9;
698 else if (op
== P_ADDAW_SP
|| op
== P_LEA_SP_SP
)
701 /* lea (-N,%sp),%sp */
702 cache
->locals
= -read_memory_integer (pc
+ 2, 2, byte_order
);
705 else if (op
== P_ADDAL_SP
)
708 cache
->locals
= -read_memory_integer (pc
+ 2, 4, byte_order
);
715 /* Check whether PC points at code that saves registers on the stack.
716 If so, it updates CACHE and returns the address of the first
717 instruction after the register saves or CURRENT_PC, whichever is
718 smaller. Otherwise, return PC. */
721 m68k_analyze_register_saves (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
722 CORE_ADDR current_pc
,
723 struct m68k_frame_cache
*cache
)
725 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
727 if (cache
->locals
>= 0)
733 offset
= -4 - cache
->locals
;
734 while (pc
< current_pc
)
736 op
= read_memory_unsigned_integer (pc
, 2, byte_order
);
737 if (op
== P_FMOVEMX_SP
738 && gdbarch_tdep (gdbarch
)->fpregs_present
)
740 /* fmovem.x REGS,-(%sp) */
741 op
= read_memory_unsigned_integer (pc
+ 2, 2, byte_order
);
742 if ((op
& 0xff00) == 0xe000)
745 for (i
= 0; i
< 16; i
++, mask
>>= 1)
749 cache
->saved_regs
[i
+ M68K_FP0_REGNUM
] = offset
;
758 else if ((op
& 0177760) == P_MOVEL_SP
)
760 /* move.l %R,-(%sp) */
762 cache
->saved_regs
[regno
] = offset
;
766 else if (op
== P_MOVEML_SP
)
768 /* movem.l REGS,-(%sp) */
769 mask
= read_memory_unsigned_integer (pc
+ 2, 2, byte_order
);
770 for (i
= 0; i
< 16; i
++, mask
>>= 1)
774 cache
->saved_regs
[15 - i
] = offset
;
789 /* Do a full analysis of the prologue at PC and update CACHE
790 accordingly. Bail out early if CURRENT_PC is reached. Return the
791 address where the analysis stopped.
793 We handle all cases that can be generated by gcc.
795 For allocating a stack frame:
799 pea (%fp); move.l %sp,%fp
800 link.w %a6,#0; add.l #-N,%sp
803 subq.w #8,%sp; subq.w #N-8,%sp
808 For saving registers:
812 move.l R1,-(%sp); move.l R2,-(%sp)
815 For setting up the PIC register:
822 m68k_analyze_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
823 CORE_ADDR current_pc
, struct m68k_frame_cache
*cache
)
825 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
828 pc
= m68k_analyze_frame_setup (gdbarch
, pc
, current_pc
, cache
);
829 pc
= m68k_analyze_register_saves (gdbarch
, pc
, current_pc
, cache
);
830 if (pc
>= current_pc
)
833 /* Check for GOT setup. */
834 op
= read_memory_unsigned_integer (pc
, 4, byte_order
);
835 if (op
== P_LEA_PC_A5
)
837 /* lea (%pc,N),%a5 */
844 /* Return PC of first real instruction. */
847 m68k_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR start_pc
)
849 struct m68k_frame_cache cache
;
853 pc
= m68k_analyze_prologue (gdbarch
, start_pc
, (CORE_ADDR
) -1, &cache
);
854 if (cache
.locals
< 0)
860 m68k_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
864 frame_unwind_register (next_frame
, gdbarch_pc_regnum (gdbarch
), buf
);
865 return extract_typed_address (buf
, builtin_type (gdbarch
)->builtin_func_ptr
);
870 static struct m68k_frame_cache
*
871 m68k_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
873 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
874 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
875 struct m68k_frame_cache
*cache
;
880 return (struct m68k_frame_cache
*) *this_cache
;
882 cache
= m68k_alloc_frame_cache ();
885 /* In principle, for normal frames, %fp holds the frame pointer,
886 which holds the base address for the current stack frame.
887 However, for functions that don't need it, the frame pointer is
888 optional. For these "frameless" functions the frame pointer is
889 actually the frame pointer of the calling frame. Signal
890 trampolines are just a special case of a "frameless" function.
891 They (usually) share their frame pointer with the frame that was
892 in progress when the signal occurred. */
894 get_frame_register (this_frame
, M68K_FP_REGNUM
, buf
);
895 cache
->base
= extract_unsigned_integer (buf
, 4, byte_order
);
896 if (cache
->base
== 0)
899 /* For normal frames, %pc is stored at 4(%fp). */
900 cache
->saved_regs
[M68K_PC_REGNUM
] = 4;
902 cache
->pc
= get_frame_func (this_frame
);
904 m68k_analyze_prologue (get_frame_arch (this_frame
), cache
->pc
,
905 get_frame_pc (this_frame
), cache
);
907 if (cache
->locals
< 0)
909 /* We didn't find a valid frame, which means that CACHE->base
910 currently holds the frame pointer for our calling frame. If
911 we're at the start of a function, or somewhere half-way its
912 prologue, the function's frame probably hasn't been fully
913 setup yet. Try to reconstruct the base address for the stack
914 frame by looking at the stack pointer. For truly "frameless"
915 functions this might work too. */
917 get_frame_register (this_frame
, M68K_SP_REGNUM
, buf
);
918 cache
->base
= extract_unsigned_integer (buf
, 4, byte_order
)
922 /* Now that we have the base address for the stack frame we can
923 calculate the value of %sp in the calling frame. */
924 cache
->saved_sp
= cache
->base
+ 8;
926 /* Adjust all the saved registers such that they contain addresses
927 instead of offsets. */
928 for (i
= 0; i
< M68K_NUM_REGS
; i
++)
929 if (cache
->saved_regs
[i
] != -1)
930 cache
->saved_regs
[i
] += cache
->base
;
936 m68k_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
937 struct frame_id
*this_id
)
939 struct m68k_frame_cache
*cache
= m68k_frame_cache (this_frame
, this_cache
);
941 /* This marks the outermost frame. */
942 if (cache
->base
== 0)
945 /* See the end of m68k_push_dummy_call. */
946 *this_id
= frame_id_build (cache
->base
+ 8, cache
->pc
);
949 static struct value
*
950 m68k_frame_prev_register (struct frame_info
*this_frame
, void **this_cache
,
953 struct m68k_frame_cache
*cache
= m68k_frame_cache (this_frame
, this_cache
);
955 gdb_assert (regnum
>= 0);
957 if (regnum
== M68K_SP_REGNUM
&& cache
->saved_sp
)
958 return frame_unwind_got_constant (this_frame
, regnum
, cache
->saved_sp
);
960 if (regnum
< M68K_NUM_REGS
&& cache
->saved_regs
[regnum
] != -1)
961 return frame_unwind_got_memory (this_frame
, regnum
,
962 cache
->saved_regs
[regnum
]);
964 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
967 static const struct frame_unwind m68k_frame_unwind
=
970 default_frame_unwind_stop_reason
,
972 m68k_frame_prev_register
,
974 default_frame_sniffer
978 m68k_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
980 struct m68k_frame_cache
*cache
= m68k_frame_cache (this_frame
, this_cache
);
985 static const struct frame_base m68k_frame_base
=
988 m68k_frame_base_address
,
989 m68k_frame_base_address
,
990 m68k_frame_base_address
993 static struct frame_id
994 m68k_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
998 fp
= get_frame_register_unsigned (this_frame
, M68K_FP_REGNUM
);
1000 /* See the end of m68k_push_dummy_call. */
1001 return frame_id_build (fp
+ 8, get_frame_pc (this_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 (gdbarch
);
1017 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1019 if (tdep
->jb_pc
< 0)
1021 internal_error (__FILE__
, __LINE__
,
1022 _("m68k_get_longjmp_target: not implemented"));
1026 buf
= (gdb_byte
*) alloca (gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
);
1027 sp
= get_frame_register_unsigned (frame
, gdbarch_sp_regnum (gdbarch
));
1029 if (target_read_memory (sp
+ SP_ARG0
, /* Offset of first arg on stack. */
1030 buf
, gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
))
1033 jb_addr
= extract_unsigned_integer (buf
, gdbarch_ptr_bit (gdbarch
)
1034 / TARGET_CHAR_BIT
, byte_order
);
1036 if (target_read_memory (jb_addr
+ tdep
->jb_pc
* tdep
->jb_elt_size
, buf
,
1037 gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
),
1041 *pc
= extract_unsigned_integer (buf
, gdbarch_ptr_bit (gdbarch
)
1042 / TARGET_CHAR_BIT
, byte_order
);
1047 /* This is the implementation of gdbarch method
1048 return_in_first_hidden_param_p. */
1051 m68k_return_in_first_hidden_param_p (struct gdbarch
*gdbarch
,
1057 /* System V Release 4 (SVR4). */
1060 m68k_svr4_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1062 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1064 /* SVR4 uses a different calling convention. */
1065 set_gdbarch_return_value (gdbarch
, m68k_svr4_return_value
);
1067 /* SVR4 uses %a0 instead of %a1. */
1068 tdep
->struct_value_regnum
= M68K_A0_REGNUM
;
1072 /* Function: m68k_gdbarch_init
1073 Initializer function for the m68k gdbarch vector.
1074 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
1076 static struct gdbarch
*
1077 m68k_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1079 struct gdbarch_tdep
*tdep
= NULL
;
1080 struct gdbarch
*gdbarch
;
1081 struct gdbarch_list
*best_arch
;
1082 struct tdesc_arch_data
*tdesc_data
= NULL
;
1084 enum m68k_flavour flavour
= m68k_no_flavour
;
1086 const struct floatformat
**long_double_format
= floatformats_m68881_ext
;
1088 /* Check any target description for validity. */
1089 if (tdesc_has_registers (info
.target_desc
))
1091 const struct tdesc_feature
*feature
;
1094 feature
= tdesc_find_feature (info
.target_desc
,
1095 "org.gnu.gdb.m68k.core");
1097 if (feature
== NULL
)
1099 feature
= tdesc_find_feature (info
.target_desc
,
1100 "org.gnu.gdb.coldfire.core");
1101 if (feature
!= NULL
)
1102 flavour
= m68k_coldfire_flavour
;
1105 if (feature
== NULL
)
1107 feature
= tdesc_find_feature (info
.target_desc
,
1108 "org.gnu.gdb.fido.core");
1109 if (feature
!= NULL
)
1110 flavour
= m68k_fido_flavour
;
1113 if (feature
== NULL
)
1116 tdesc_data
= tdesc_data_alloc ();
1119 for (i
= 0; i
<= M68K_PC_REGNUM
; i
++)
1120 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
, i
,
1121 m68k_register_names
[i
]);
1125 tdesc_data_cleanup (tdesc_data
);
1129 feature
= tdesc_find_feature (info
.target_desc
,
1130 "org.gnu.gdb.coldfire.fp");
1131 if (feature
!= NULL
)
1134 for (i
= M68K_FP0_REGNUM
; i
<= M68K_FPI_REGNUM
; i
++)
1135 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
, i
,
1136 m68k_register_names
[i
]);
1139 tdesc_data_cleanup (tdesc_data
);
1147 /* The mechanism for returning floating values from function
1148 and the type of long double depend on whether we're
1149 on ColdFire or standard m68k. */
1151 if (info
.bfd_arch_info
&& info
.bfd_arch_info
->mach
!= 0)
1153 const bfd_arch_info_type
*coldfire_arch
=
1154 bfd_lookup_arch (bfd_arch_m68k
, bfd_mach_mcf_isa_a_nodiv
);
1157 && ((*info
.bfd_arch_info
->compatible
)
1158 (info
.bfd_arch_info
, coldfire_arch
)))
1159 flavour
= m68k_coldfire_flavour
;
1162 /* If there is already a candidate, use it. */
1163 for (best_arch
= gdbarch_list_lookup_by_info (arches
, &info
);
1165 best_arch
= gdbarch_list_lookup_by_info (best_arch
->next
, &info
))
1167 if (flavour
!= gdbarch_tdep (best_arch
->gdbarch
)->flavour
)
1170 if (has_fp
!= gdbarch_tdep (best_arch
->gdbarch
)->fpregs_present
)
1176 if (best_arch
!= NULL
)
1178 if (tdesc_data
!= NULL
)
1179 tdesc_data_cleanup (tdesc_data
);
1180 return best_arch
->gdbarch
;
1183 tdep
= XCNEW (struct gdbarch_tdep
);
1184 gdbarch
= gdbarch_alloc (&info
, tdep
);
1185 tdep
->fpregs_present
= has_fp
;
1186 tdep
->flavour
= flavour
;
1188 if (flavour
== m68k_coldfire_flavour
|| flavour
== m68k_fido_flavour
)
1189 long_double_format
= floatformats_ieee_double
;
1190 set_gdbarch_long_double_format (gdbarch
, long_double_format
);
1191 set_gdbarch_long_double_bit (gdbarch
, long_double_format
[0]->totalsize
);
1193 set_gdbarch_skip_prologue (gdbarch
, m68k_skip_prologue
);
1194 set_gdbarch_breakpoint_kind_from_pc (gdbarch
, m68k_breakpoint::kind_from_pc
);
1195 set_gdbarch_sw_breakpoint_from_kind (gdbarch
, m68k_breakpoint::bp_from_kind
);
1197 /* Stack grows down. */
1198 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1199 set_gdbarch_frame_align (gdbarch
, m68k_frame_align
);
1201 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
1202 if (flavour
== m68k_coldfire_flavour
|| flavour
== m68k_fido_flavour
)
1203 set_gdbarch_decr_pc_after_break (gdbarch
, 2);
1205 set_gdbarch_frame_args_skip (gdbarch
, 8);
1206 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, m68k_dwarf_reg_to_regnum
);
1208 set_gdbarch_register_type (gdbarch
, m68k_register_type
);
1209 set_gdbarch_register_name (gdbarch
, m68k_register_name
);
1210 set_gdbarch_num_regs (gdbarch
, M68K_NUM_REGS
);
1211 set_gdbarch_sp_regnum (gdbarch
, M68K_SP_REGNUM
);
1212 set_gdbarch_pc_regnum (gdbarch
, M68K_PC_REGNUM
);
1213 set_gdbarch_ps_regnum (gdbarch
, M68K_PS_REGNUM
);
1214 set_gdbarch_convert_register_p (gdbarch
, m68k_convert_register_p
);
1215 set_gdbarch_register_to_value (gdbarch
, m68k_register_to_value
);
1216 set_gdbarch_value_to_register (gdbarch
, m68k_value_to_register
);
1219 set_gdbarch_fp0_regnum (gdbarch
, M68K_FP0_REGNUM
);
1221 /* Try to figure out if the arch uses floating registers to return
1222 floating point values from functions. */
1225 /* On ColdFire, floating point values are returned in D0. */
1226 if (flavour
== m68k_coldfire_flavour
)
1227 tdep
->float_return
= 0;
1229 tdep
->float_return
= 1;
1233 /* No floating registers, so can't use them for returning values. */
1234 tdep
->float_return
= 0;
1237 /* Function call & return. */
1238 set_gdbarch_push_dummy_call (gdbarch
, m68k_push_dummy_call
);
1239 set_gdbarch_return_value (gdbarch
, m68k_return_value
);
1240 set_gdbarch_return_in_first_hidden_param_p (gdbarch
,
1241 m68k_return_in_first_hidden_param_p
);
1245 set_gdbarch_print_insn (gdbarch
, print_insn_m68k
);
1247 #if defined JB_PC && defined JB_ELEMENT_SIZE
1248 tdep
->jb_pc
= JB_PC
;
1249 tdep
->jb_elt_size
= JB_ELEMENT_SIZE
;
1253 tdep
->struct_value_regnum
= M68K_A1_REGNUM
;
1254 tdep
->struct_return
= reg_struct_return
;
1256 /* Frame unwinder. */
1257 set_gdbarch_dummy_id (gdbarch
, m68k_dummy_id
);
1258 set_gdbarch_unwind_pc (gdbarch
, m68k_unwind_pc
);
1260 /* Hook in the DWARF CFI frame unwinder. */
1261 dwarf2_append_unwinders (gdbarch
);
1263 frame_base_set_default (gdbarch
, &m68k_frame_base
);
1265 /* Hook in ABI-specific overrides, if they have been registered. */
1266 gdbarch_init_osabi (info
, gdbarch
);
1268 /* Now we have tuned the configuration, set a few final things,
1269 based on what the OS ABI has told us. */
1271 if (tdep
->jb_pc
>= 0)
1272 set_gdbarch_get_longjmp_target (gdbarch
, m68k_get_longjmp_target
);
1274 frame_unwind_append_unwinder (gdbarch
, &m68k_frame_unwind
);
1277 tdesc_use_registers (gdbarch
, info
.target_desc
, tdesc_data
);
1284 m68k_dump_tdep (struct gdbarch
*gdbarch
, struct ui_file
*file
)
1286 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1292 extern initialize_file_ftype _initialize_m68k_tdep
; /* -Wmissing-prototypes */
1295 _initialize_m68k_tdep (void)
1297 gdbarch_register (bfd_arch_m68k
, m68k_gdbarch_init
, m68k_dump_tdep
);