1 /* Target-dependent code for the Motorola 68000 series.
3 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1999, 2000,
4 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
24 #include "dwarf2-frame.h"
26 #include "frame-base.h"
27 #include "frame-unwind.h"
31 #include "gdb_string.h"
32 #include "gdb_assert.h"
35 #include "arch-utils.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
57 #define REGISTER_BYTES_FP (16*4 + 8 + 8*12 + 3*4)
58 #define REGISTER_BYTES_NOFP (16*4 + 8)
60 /* Offset from SP to first arg on stack at first instruction of a function */
61 #define SP_ARG0 (1 * 4)
63 #if !defined (BPT_VECTOR)
64 #define BPT_VECTOR 0xf
67 static const unsigned char *
68 m68k_local_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
70 static unsigned char break_insn[] = {0x4e, (0x40 | BPT_VECTOR)};
71 *lenptr = sizeof (break_insn);
77 m68k_register_bytes_ok (long numbytes)
79 return ((numbytes == REGISTER_BYTES_FP)
80 || (numbytes == REGISTER_BYTES_NOFP));
83 /* Return the GDB type object for the "standard" data type of data in
84 register N. This should be int for D0-D7, SR, FPCONTROL and
85 FPSTATUS, long double for FP0-FP7, and void pointer for all others
86 (A0-A7, PC, FPIADDR). Note, for registers which contain
87 addresses return pointer to void, not pointer to char, because we
88 don't want to attempt to print the string after printing the
92 m68k_register_type (struct gdbarch *gdbarch, int regnum)
94 if (regnum >= FP0_REGNUM && regnum <= FP0_REGNUM + 7)
95 return builtin_type_m68881_ext;
97 if (regnum == M68K_FPI_REGNUM || regnum == PC_REGNUM)
98 return builtin_type_void_func_ptr;
100 if (regnum == M68K_FPC_REGNUM || regnum == M68K_FPS_REGNUM
101 || regnum == PS_REGNUM)
102 return builtin_type_int32;
104 if (regnum >= M68K_A0_REGNUM && regnum <= M68K_A0_REGNUM + 7)
105 return builtin_type_void_data_ptr;
107 return builtin_type_int32;
110 /* Function: m68k_register_name
111 Returns the name of the standard m68k register regnum. */
114 m68k_register_name (int regnum)
116 static char *register_names[] = {
117 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
118 "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp",
120 "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7",
121 "fpcontrol", "fpstatus", "fpiaddr", "fpcode", "fpflags"
125 regnum >= sizeof (register_names) / sizeof (register_names[0]))
126 internal_error (__FILE__, __LINE__,
127 "m68k_register_name: illegal register number %d", regnum);
129 return register_names[regnum];
132 /* Extract from an array REGBUF containing the (raw) register state, a
133 function return value of TYPE, and copy that, in virtual format,
137 m68k_extract_return_value (struct type *type, struct regcache *regcache,
140 int len = TYPE_LENGTH (type);
141 char buf[M68K_MAX_REGISTER_SIZE];
143 if (TYPE_CODE (type) == TYPE_CODE_STRUCT
144 && TYPE_NFIELDS (type) == 1)
146 m68k_extract_return_value (TYPE_FIELD_TYPE (type, 0), regcache, valbuf);
152 regcache_raw_read (regcache, M68K_D0_REGNUM, buf);
153 memcpy (valbuf, buf + (4 - len), len);
157 regcache_raw_read (regcache, M68K_D0_REGNUM, buf);
158 memcpy (valbuf, buf + (8 - len), len - 4);
159 regcache_raw_read (regcache, M68K_D1_REGNUM,
160 (char *) valbuf + (len - 4));
163 internal_error (__FILE__, __LINE__,
164 "Cannot extract return value of %d bytes long.", len);
167 /* Write into the appropriate registers a function return value stored
168 in VALBUF of type TYPE, given in virtual format. */
171 m68k_store_return_value (struct type *type, struct regcache *regcache,
174 int len = TYPE_LENGTH (type);
176 if (TYPE_CODE (type) == TYPE_CODE_STRUCT
177 && TYPE_NFIELDS (type) == 1)
179 m68k_store_return_value (TYPE_FIELD_TYPE (type, 0), regcache, valbuf);
184 regcache_raw_write_part (regcache, M68K_D0_REGNUM, 4 - len, len, valbuf);
187 regcache_raw_write_part (regcache, M68K_D1_REGNUM, 8 - len,
189 regcache_raw_write (regcache, M68K_D0_REGNUM,
190 (char *) valbuf + (len - 4));
193 internal_error (__FILE__, __LINE__,
194 "Cannot store return value of %d bytes long.", len);
197 /* Extract from REGCACHE, which contains the (raw) register state, the
198 address in which a function should return its structure value, as a
202 m68k_extract_struct_value_address (struct regcache *regcache)
206 regcache_cooked_read (regcache, M68K_D0_REGNUM, buf);
207 return extract_unsigned_integer (buf, 4);
211 m68k_use_struct_convention (int gcc_p, struct type *type)
213 enum struct_return struct_return;
215 struct_return = gdbarch_tdep (current_gdbarch)->struct_return;
216 return generic_use_struct_convention (struct_return == reg_struct_return,
220 /* A function that tells us whether the function invocation represented
221 by fi does not have a frame on the stack associated with it. If it
222 does not, FRAMELESS is set to 1, else 0. */
225 m68k_frameless_function_invocation (struct frame_info *fi)
227 if (get_frame_type (fi) == SIGTRAMP_FRAME)
230 return legacy_frameless_look_for_prologue (fi);
234 delta68_in_sigtramp (CORE_ADDR pc, char *name)
237 return strcmp (name, "_sigcode") == 0;
243 delta68_frame_args_address (struct frame_info *frame_info)
245 /* we assume here that the only frameless functions are the system calls
246 or other functions who do not put anything on the stack. */
247 if (get_frame_type (frame_info) == SIGTRAMP_FRAME)
248 return get_frame_base (frame_info) + 12;
249 else if (legacy_frameless_look_for_prologue (frame_info))
251 /* Check for an interrupted system call */
252 if (get_next_frame (frame_info) && (get_frame_type (get_next_frame (frame_info)) == SIGTRAMP_FRAME))
253 return get_frame_base (get_next_frame (frame_info)) + 16;
255 return get_frame_base (frame_info) + 4;
258 return get_frame_base (frame_info);
262 delta68_frame_saved_pc (struct frame_info *frame_info)
264 return read_memory_unsigned_integer (delta68_frame_args_address (frame_info)
269 delta68_frame_num_args (struct frame_info *fi)
272 CORE_ADDR pc = DEPRECATED_FRAME_SAVED_PC (fi);
273 int insn = read_memory_unsigned_integer (pc, 2);
275 if (insn == 0047757 || insn == 0157374) /* lea W(sp),sp or addaw #W,sp */
276 val = read_memory_integer (pc + 2, 2);
277 else if ((insn & 0170777) == 0050217 /* addql #N, sp */
278 || (insn & 0170777) == 0050117) /* addqw */
280 val = (insn >> 9) & 7;
284 else if (insn == 0157774) /* addal #WW, sp */
285 val = read_memory_integer (pc + 2, 4);
291 m68k_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr,
292 struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
293 struct value **args, CORE_ADDR sp, int struct_return,
294 CORE_ADDR struct_addr)
299 /* Push arguments in reverse order. */
300 for (i = nargs - 1; i >= 0; i--)
302 struct type *value_type = VALUE_ENCLOSING_TYPE (args[i]);
303 int len = TYPE_LENGTH (value_type);
304 int container_len = (len + 3) & ~3;
307 /* Non-scalars bigger than 4 bytes are left aligned, others are
309 if ((TYPE_CODE (value_type) == TYPE_CODE_STRUCT
310 || TYPE_CODE (value_type) == TYPE_CODE_UNION
311 || TYPE_CODE (value_type) == TYPE_CODE_ARRAY)
315 offset = container_len - len;
317 write_memory (sp + offset, VALUE_CONTENTS_ALL (args[i]), len);
320 /* Store struct value address. */
323 store_unsigned_integer (buf, 4, struct_addr);
324 regcache_cooked_write (regcache, M68K_A1_REGNUM, buf);
327 /* Store return address. */
329 store_unsigned_integer (buf, 4, bp_addr);
330 write_memory (sp, buf, 4);
332 /* Finally, update the stack pointer... */
333 store_unsigned_integer (buf, 4, sp);
334 regcache_cooked_write (regcache, M68K_SP_REGNUM, buf);
336 /* ...and fake a frame pointer. */
337 regcache_cooked_write (regcache, M68K_FP_REGNUM, buf);
339 /* DWARF2/GCC uses the stack address *before* the function call as a
344 struct m68k_frame_cache
351 /* Saved registers. */
352 CORE_ADDR saved_regs[M68K_NUM_REGS];
355 /* Stack space reserved for local variables. */
359 /* Allocate and initialize a frame cache. */
361 static struct m68k_frame_cache *
362 m68k_alloc_frame_cache (void)
364 struct m68k_frame_cache *cache;
367 cache = FRAME_OBSTACK_ZALLOC (struct m68k_frame_cache);
371 cache->sp_offset = -4;
374 /* Saved registers. We initialize these to -1 since zero is a valid
375 offset (that's where %fp is supposed to be stored). */
376 for (i = 0; i < M68K_NUM_REGS; i++)
377 cache->saved_regs[i] = -1;
379 /* Frameless until proven otherwise. */
385 /* Check whether PC points at a code that sets up a new stack frame.
386 If so, it updates CACHE and returns the address of the first
387 instruction after the sequence that sets removes the "hidden"
388 argument from the stack or CURRENT_PC, whichever is smaller.
389 Otherwise, return PC. */
392 m68k_analyze_frame_setup (CORE_ADDR pc, CORE_ADDR current_pc,
393 struct m68k_frame_cache *cache)
397 if (pc >= current_pc)
400 op = read_memory_unsigned_integer (pc, 2);
402 if (op == P_LINKW_FP || op == P_LINKL_FP || op == P_PEA_FP)
404 cache->saved_regs[M68K_FP_REGNUM] = 0;
405 cache->sp_offset += 4;
406 if (op == P_LINKW_FP)
408 /* link.w %fp, #-N */
409 /* link.w %fp, #0; adda.l #-N, %sp */
410 cache->locals = -read_memory_integer (pc + 2, 2);
412 if (pc + 4 < current_pc && cache->locals == 0)
414 op = read_memory_unsigned_integer (pc + 4, 2);
415 if (op == P_ADDAL_SP)
417 cache->locals = read_memory_integer (pc + 6, 4);
424 else if (op == P_LINKL_FP)
426 /* link.l %fp, #-N */
427 cache->locals = -read_memory_integer (pc + 2, 4);
432 /* pea (%fp); movea.l %sp, %fp */
435 if (pc + 2 < current_pc)
437 op = read_memory_unsigned_integer (pc + 2, 2);
439 if (op == P_MOVEAL_SP_FP)
441 /* move.l %sp, %fp */
449 else if ((op & 0170777) == P_SUBQW_SP || (op & 0170777) == P_SUBQL_SP)
451 /* subq.[wl] #N,%sp */
452 /* subq.[wl] #8,%sp; subq.[wl] #N,%sp */
453 cache->locals = (op & 07000) == 0 ? 8 : (op & 07000) >> 9;
454 if (pc + 2 < current_pc)
456 op = read_memory_unsigned_integer (pc + 2, 2);
457 if ((op & 0170777) == P_SUBQW_SP || (op & 0170777) == P_SUBQL_SP)
459 cache->locals += (op & 07000) == 0 ? 8 : (op & 07000) >> 9;
465 else if (op == P_ADDAW_SP || op == P_LEA_SP_SP)
468 /* lea (-N,%sp),%sp */
469 cache->locals = -read_memory_integer (pc + 2, 2);
472 else if (op == P_ADDAL_SP)
475 cache->locals = -read_memory_integer (pc + 2, 4);
482 /* Check whether PC points at code that saves registers on the stack.
483 If so, it updates CACHE and returns the address of the first
484 instruction after the register saves or CURRENT_PC, whichever is
485 smaller. Otherwise, return PC. */
488 m68k_analyze_register_saves (CORE_ADDR pc, CORE_ADDR current_pc,
489 struct m68k_frame_cache *cache)
491 if (cache->locals >= 0)
497 offset = -4 - cache->locals;
498 while (pc < current_pc)
500 op = read_memory_unsigned_integer (pc, 2);
501 if (op == P_FMOVEMX_SP)
503 /* fmovem.x REGS,-(%sp) */
504 op = read_memory_unsigned_integer (pc + 2, 2);
505 if ((op & 0xff00) == 0xe000)
508 for (i = 0; i < 16; i++, mask >>= 1)
512 cache->saved_regs[i + M68K_FP0_REGNUM] = offset;
521 else if ((op & 0170677) == P_MOVEL_SP)
523 /* move.l %R,-(%sp) */
524 regno = ((op & 07000) >> 9) | ((op & 0100) >> 3);
525 cache->saved_regs[regno] = offset;
529 else if (op == P_MOVEML_SP)
531 /* movem.l REGS,-(%sp) */
532 mask = read_memory_unsigned_integer (pc + 2, 2);
533 for (i = 0; i < 16; i++, mask >>= 1)
537 cache->saved_regs[15 - i] = offset;
552 /* Do a full analysis of the prologue at PC and update CACHE
553 accordingly. Bail out early if CURRENT_PC is reached. Return the
554 address where the analysis stopped.
556 We handle all cases that can be generated by gcc.
558 For allocating a stack frame:
562 pea (%fp); move.l %sp,%fp
563 link.w %a6,#0; add.l #-N,%sp
566 subq.w #8,%sp; subq.w #N-8,%sp
571 For saving registers:
575 move.l R1,-(%sp); move.l R2,-(%sp)
578 For setting up the PIC register:
585 m68k_analyze_prologue (CORE_ADDR pc, CORE_ADDR current_pc,
586 struct m68k_frame_cache *cache)
590 pc = m68k_analyze_frame_setup (pc, current_pc, cache);
591 pc = m68k_analyze_register_saves (pc, current_pc, cache);
592 if (pc >= current_pc)
595 /* Check for GOT setup. */
596 op = read_memory_unsigned_integer (pc, 4);
597 if (op == P_LEA_PC_A5)
599 /* lea (%pc,N),%a5 */
606 /* Return PC of first real instruction. */
609 m68k_skip_prologue (CORE_ADDR start_pc)
611 struct m68k_frame_cache cache;
616 pc = m68k_analyze_prologue (start_pc, (CORE_ADDR) -1, &cache);
617 if (cache.locals < 0)
623 m68k_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
627 frame_unwind_register (next_frame, PC_REGNUM, buf);
628 return extract_typed_address (buf, builtin_type_void_func_ptr);
633 static struct m68k_frame_cache *
634 m68k_frame_cache (struct frame_info *next_frame, void **this_cache)
636 struct m68k_frame_cache *cache;
643 cache = m68k_alloc_frame_cache ();
646 /* In principle, for normal frames, %fp holds the frame pointer,
647 which holds the base address for the current stack frame.
648 However, for functions that don't need it, the frame pointer is
649 optional. For these "frameless" functions the frame pointer is
650 actually the frame pointer of the calling frame. Signal
651 trampolines are just a special case of a "frameless" function.
652 They (usually) share their frame pointer with the frame that was
653 in progress when the signal occurred. */
655 frame_unwind_register (next_frame, M68K_FP_REGNUM, buf);
656 cache->base = extract_unsigned_integer (buf, 4);
657 if (cache->base == 0)
660 /* For normal frames, %pc is stored at 4(%fp). */
661 cache->saved_regs[M68K_PC_REGNUM] = 4;
663 cache->pc = frame_func_unwind (next_frame);
665 m68k_analyze_prologue (cache->pc, frame_pc_unwind (next_frame), cache);
667 if (cache->locals < 0)
669 /* We didn't find a valid frame, which means that CACHE->base
670 currently holds the frame pointer for our calling frame. If
671 we're at the start of a function, or somewhere half-way its
672 prologue, the function's frame probably hasn't been fully
673 setup yet. Try to reconstruct the base address for the stack
674 frame by looking at the stack pointer. For truly "frameless"
675 functions this might work too. */
677 frame_unwind_register (next_frame, M68K_SP_REGNUM, buf);
678 cache->base = extract_unsigned_integer (buf, 4) + cache->sp_offset;
681 /* Now that we have the base address for the stack frame we can
682 calculate the value of %sp in the calling frame. */
683 cache->saved_sp = cache->base + 8;
685 /* Adjust all the saved registers such that they contain addresses
686 instead of offsets. */
687 for (i = 0; i < M68K_NUM_REGS; i++)
688 if (cache->saved_regs[i] != -1)
689 cache->saved_regs[i] += cache->base;
695 m68k_frame_this_id (struct frame_info *next_frame, void **this_cache,
696 struct frame_id *this_id)
698 struct m68k_frame_cache *cache = m68k_frame_cache (next_frame, this_cache);
700 /* This marks the outermost frame. */
701 if (cache->base == 0)
704 /* See the end of m68k_push_dummy_call. */
705 *this_id = frame_id_build (cache->base + 8, cache->pc);
709 m68k_frame_prev_register (struct frame_info *next_frame, void **this_cache,
710 int regnum, int *optimizedp,
711 enum lval_type *lvalp, CORE_ADDR *addrp,
712 int *realnump, void *valuep)
714 struct m68k_frame_cache *cache = m68k_frame_cache (next_frame, this_cache);
716 gdb_assert (regnum >= 0);
718 if (regnum == M68K_SP_REGNUM && cache->saved_sp)
726 /* Store the value. */
727 store_unsigned_integer (valuep, 4, cache->saved_sp);
732 if (regnum < M68K_NUM_REGS && cache->saved_regs[regnum] != -1)
735 *lvalp = lval_memory;
736 *addrp = cache->saved_regs[regnum];
740 /* Read the value in from memory. */
741 read_memory (*addrp, valuep,
742 register_size (current_gdbarch, regnum));
747 frame_register_unwind (next_frame, regnum,
748 optimizedp, lvalp, addrp, realnump, valuep);
751 static const struct frame_unwind m68k_frame_unwind =
755 m68k_frame_prev_register
758 static const struct frame_unwind *
759 m68k_frame_sniffer (struct frame_info *next_frame)
761 return &m68k_frame_unwind;
765 m68k_frame_base_address (struct frame_info *next_frame, void **this_cache)
767 struct m68k_frame_cache *cache = m68k_frame_cache (next_frame, this_cache);
772 static const struct frame_base m68k_frame_base =
775 m68k_frame_base_address,
776 m68k_frame_base_address,
777 m68k_frame_base_address
780 static struct frame_id
781 m68k_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
786 frame_unwind_register (next_frame, M68K_FP_REGNUM, buf);
787 fp = extract_unsigned_integer (buf, 4);
789 /* See the end of m68k_push_dummy_call. */
790 return frame_id_build (fp + 8, frame_pc_unwind (next_frame));
793 #ifdef USE_PROC_FS /* Target dependent support for /proc */
795 #include <sys/procfs.h>
797 /* Prototypes for supply_gregset etc. */
800 /* The /proc interface divides the target machine's register set up into
801 two different sets, the general register set (gregset) and the floating
802 point register set (fpregset). For each set, there is an ioctl to get
803 the current register set and another ioctl to set the current values.
805 The actual structure passed through the ioctl interface is, of course,
806 naturally machine dependent, and is different for each set of registers.
807 For the m68k for example, the general register set is typically defined
810 typedef int gregset_t[18];
816 and the floating point set by:
818 typedef struct fpregset {
822 int f_fpregs[8][3]; (8 regs, 96 bits each)
825 These routines provide the packing and unpacking of gregset_t and
826 fpregset_t formatted data.
830 /* Atari SVR4 has R_SR but not R_PS */
832 #if !defined (R_PS) && defined (R_SR)
836 /* Given a pointer to a general register set in /proc format (gregset_t *),
837 unpack the register contents and supply them as gdb's idea of the current
841 supply_gregset (gregset_t *gregsetp)
844 greg_t *regp = (greg_t *) gregsetp;
846 for (regi = 0; regi < R_PC; regi++)
848 supply_register (regi, (char *) (regp + regi));
850 supply_register (PS_REGNUM, (char *) (regp + R_PS));
851 supply_register (PC_REGNUM, (char *) (regp + R_PC));
855 fill_gregset (gregset_t *gregsetp, int regno)
858 greg_t *regp = (greg_t *) gregsetp;
860 for (regi = 0; regi < R_PC; regi++)
862 if (regno == -1 || regno == regi)
863 regcache_collect (regi, regp + regi);
865 if (regno == -1 || regno == PS_REGNUM)
866 regcache_collect (PS_REGNUM, regp + R_PS);
867 if (regno == -1 || regno == PC_REGNUM)
868 regcache_collect (PC_REGNUM, regp + R_PC);
871 #if defined (FP0_REGNUM)
873 /* Given a pointer to a floating point register set in /proc format
874 (fpregset_t *), unpack the register contents and supply them as gdb's
875 idea of the current floating point register values. */
878 supply_fpregset (fpregset_t *fpregsetp)
883 for (regi = FP0_REGNUM; regi < M68K_FPC_REGNUM; regi++)
885 from = (char *) &(fpregsetp->f_fpregs[regi - FP0_REGNUM][0]);
886 supply_register (regi, from);
888 supply_register (M68K_FPC_REGNUM, (char *) &(fpregsetp->f_pcr));
889 supply_register (M68K_FPS_REGNUM, (char *) &(fpregsetp->f_psr));
890 supply_register (M68K_FPI_REGNUM, (char *) &(fpregsetp->f_fpiaddr));
893 /* Given a pointer to a floating point register set in /proc format
894 (fpregset_t *), update the register specified by REGNO from gdb's idea
895 of the current floating point register set. If REGNO is -1, update
899 fill_fpregset (fpregset_t *fpregsetp, int regno)
903 for (regi = FP0_REGNUM; regi < M68K_FPC_REGNUM; regi++)
905 if (regno == -1 || regno == regi)
906 regcache_collect (regi, &fpregsetp->f_fpregs[regi - FP0_REGNUM][0]);
908 if (regno == -1 || regno == M68K_FPC_REGNUM)
909 regcache_collect (M68K_FPC_REGNUM, &fpregsetp->f_pcr);
910 if (regno == -1 || regno == M68K_FPS_REGNUM)
911 regcache_collect (M68K_FPS_REGNUM, &fpregsetp->f_psr);
912 if (regno == -1 || regno == M68K_FPI_REGNUM)
913 regcache_collect (M68K_FPI_REGNUM, &fpregsetp->f_fpiaddr);
916 #endif /* defined (FP0_REGNUM) */
918 #endif /* USE_PROC_FS */
920 /* Figure out where the longjmp will land. Slurp the args out of the stack.
921 We expect the first arg to be a pointer to the jmp_buf structure from which
922 we extract the pc (JB_PC) that we will land at. The pc is copied into PC.
923 This routine returns true on success. */
926 m68k_get_longjmp_target (CORE_ADDR *pc)
929 CORE_ADDR sp, jb_addr;
930 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
934 internal_error (__FILE__, __LINE__,
935 "m68k_get_longjmp_target: not implemented");
939 buf = alloca (TARGET_PTR_BIT / TARGET_CHAR_BIT);
940 sp = read_register (SP_REGNUM);
942 if (target_read_memory (sp + SP_ARG0, /* Offset of first arg on stack */
943 buf, TARGET_PTR_BIT / TARGET_CHAR_BIT))
946 jb_addr = extract_unsigned_integer (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);
948 if (target_read_memory (jb_addr + tdep->jb_pc * tdep->jb_elt_size, buf,
949 TARGET_PTR_BIT / TARGET_CHAR_BIT))
952 *pc = extract_unsigned_integer (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);
956 /* Function: m68k_gdbarch_init
957 Initializer function for the m68k gdbarch vector.
958 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
960 static struct gdbarch *
961 m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
963 struct gdbarch_tdep *tdep = NULL;
964 struct gdbarch *gdbarch;
966 /* find a candidate among the list of pre-declared architectures. */
967 arches = gdbarch_list_lookup_by_info (arches, &info);
969 return (arches->gdbarch);
971 tdep = xmalloc (sizeof (struct gdbarch_tdep));
972 gdbarch = gdbarch_alloc (&info, tdep);
974 set_gdbarch_long_double_format (gdbarch, &floatformat_m68881_ext);
975 set_gdbarch_long_double_bit (gdbarch, 96);
977 set_gdbarch_skip_prologue (gdbarch, m68k_skip_prologue);
978 set_gdbarch_breakpoint_from_pc (gdbarch, m68k_local_breakpoint_from_pc);
980 /* Stack grows down. */
981 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
982 set_gdbarch_parm_boundary (gdbarch, 32);
984 set_gdbarch_believe_pcc_promotion (gdbarch, 1);
985 set_gdbarch_decr_pc_after_break (gdbarch, 2);
987 set_gdbarch_extract_return_value (gdbarch, m68k_extract_return_value);
988 set_gdbarch_store_return_value (gdbarch, m68k_store_return_value);
989 set_gdbarch_deprecated_extract_struct_value_address (gdbarch, m68k_extract_struct_value_address);
990 set_gdbarch_use_struct_convention (gdbarch, m68k_use_struct_convention);
992 set_gdbarch_deprecated_frameless_function_invocation (gdbarch, m68k_frameless_function_invocation);
993 set_gdbarch_frame_args_skip (gdbarch, 8);
995 set_gdbarch_register_type (gdbarch, m68k_register_type);
996 set_gdbarch_register_name (gdbarch, m68k_register_name);
997 set_gdbarch_num_regs (gdbarch, 29);
998 set_gdbarch_register_bytes_ok (gdbarch, m68k_register_bytes_ok);
999 set_gdbarch_sp_regnum (gdbarch, M68K_SP_REGNUM);
1000 set_gdbarch_pc_regnum (gdbarch, M68K_PC_REGNUM);
1001 set_gdbarch_ps_regnum (gdbarch, M68K_PS_REGNUM);
1002 set_gdbarch_fp0_regnum (gdbarch, M68K_FP0_REGNUM);
1004 set_gdbarch_push_dummy_call (gdbarch, m68k_push_dummy_call);
1007 set_gdbarch_print_insn (gdbarch, print_insn_m68k);
1009 #if defined JB_PC && defined JB_ELEMENT_SIZE
1010 tdep->jb_pc = JB_PC;
1011 tdep->jb_elt_size = JB_ELEMENT_SIZE;
1015 tdep->struct_return = pcc_struct_return;
1017 /* Frame unwinder. */
1018 set_gdbarch_unwind_dummy_id (gdbarch, m68k_unwind_dummy_id);
1019 set_gdbarch_unwind_pc (gdbarch, m68k_unwind_pc);
1021 /* Hook in the DWARF CFI frame unwinder. */
1022 frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
1024 frame_base_set_default (gdbarch, &m68k_frame_base);
1026 /* Hook in ABI-specific overrides, if they have been registered. */
1027 gdbarch_init_osabi (info, gdbarch);
1029 /* Now we have tuned the configuration, set a few final things,
1030 based on what the OS ABI has told us. */
1032 if (tdep->jb_pc >= 0)
1033 set_gdbarch_get_longjmp_target (gdbarch, m68k_get_longjmp_target);
1035 frame_unwind_append_sniffer (gdbarch, m68k_frame_sniffer);
1042 m68k_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
1044 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1050 extern initialize_file_ftype _initialize_m68k_tdep; /* -Wmissing-prototypes */
1053 _initialize_m68k_tdep (void)
1055 gdbarch_register (bfd_arch_m68k, m68k_gdbarch_init, m68k_dump_tdep);