1 /* Target-dependent code for Motorola 68HC11
2 Copyright (C) 1999, 2000 Free Software Foundation, Inc.
3 Contributed by Stephane Carrez, stcarrez@worldnet.fr
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 2 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, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
29 #include "gdb_string.h"
35 #include "arch-utils.h"
38 #include "opcode/m68hc11.h"
40 /* Register numbers of various important registers.
41 Note that some of these values are "real" register numbers,
42 and correspond to the general registers of the machine,
43 and some are "phony" register numbers which are too large
44 to be actual register numbers as far as the user is concerned
45 but do serve to get the desired values when passed to read_register. */
47 #define HARD_X_REGNUM 0
48 #define HARD_D_REGNUM 1
49 #define HARD_Y_REGNUM 2
50 #define HARD_SP_REGNUM 3
51 #define HARD_PC_REGNUM 4
53 #define HARD_A_REGNUM 5
54 #define HARD_B_REGNUM 6
55 #define HARD_CCR_REGNUM 7
56 #define M68HC11_LAST_HARD_REG (HARD_CCR_REGNUM)
58 /* Z is replaced by X or Y by gcc during machine reorg.
59 ??? There is no way to get it and even know whether
60 it's in X or Y or in ZS. */
61 #define SOFT_Z_REGNUM 8
63 /* Soft registers. These registers are special. There are treated
64 like normal hard registers by gcc and gdb (ie, within dwarf2 info).
65 They are physically located in memory. */
66 #define SOFT_FP_REGNUM 9
67 #define SOFT_TMP_REGNUM 10
68 #define SOFT_ZS_REGNUM 11
69 #define SOFT_XY_REGNUM 12
70 #define SOFT_D1_REGNUM 13
71 #define SOFT_D32_REGNUM (SOFT_D1_REGNUM+31)
72 #define M68HC11_MAX_SOFT_REGS 32
74 #define M68HC11_NUM_REGS (8)
75 #define M68HC11_NUM_PSEUDO_REGS (M68HC11_MAX_SOFT_REGS+5)
76 #define M68HC11_ALL_REGS (M68HC11_NUM_REGS+M68HC11_NUM_PSEUDO_REGS)
78 #define M68HC11_REG_SIZE (2)
82 /* from the elf header */
85 /* Stack pointer correction value. For 68hc11, the stack pointer points
86 to the next push location. An offset of 1 must be applied to obtain
87 the address where the last value is saved. For 68hc12, the stack
88 pointer points to the last value pushed. No offset is necessary. */
92 #define M6811_TDEP gdbarch_tdep (current_gdbarch)
93 #define STACK_CORRECTION (M6811_TDEP->stack_correction)
95 struct frame_extra_info
104 /* Table of registers for 68HC11. This includes the hard registers
105 and the soft registers used by GCC. */
107 m68hc11_register_names
[] =
109 "x", "d", "y", "sp", "pc", "a", "b",
110 "ccr", "z", "frame","tmp", "zs", "xy",
111 "d1", "d2", "d3", "d4", "d5", "d6", "d7",
112 "d8", "d9", "d10", "d11", "d12", "d13", "d14",
113 "d15", "d16", "d17", "d18", "d19", "d20", "d21",
114 "d22", "d23", "d24", "d25", "d26", "d27", "d28",
115 "d29", "d30", "d31", "d32"
118 struct m68hc11_soft_reg
124 static struct m68hc11_soft_reg soft_regs
[M68HC11_ALL_REGS
];
126 #define M68HC11_FP_ADDR soft_regs[SOFT_FP_REGNUM].addr
128 static int soft_min_addr
;
129 static int soft_max_addr
;
130 static int soft_reg_initialized
= 0;
132 /* Look in the symbol table for the address of a pseudo register
133 in memory. If we don't find it, pretend the register is not used
134 and not available. */
136 m68hc11_get_register_info (struct m68hc11_soft_reg
*reg
, const char *name
)
138 struct minimal_symbol
*msymbol
;
140 msymbol
= lookup_minimal_symbol (name
, NULL
, NULL
);
143 reg
->addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
144 reg
->name
= xstrdup (name
);
146 /* Keep track of the address range for soft registers. */
147 if (reg
->addr
< (CORE_ADDR
) soft_min_addr
)
148 soft_min_addr
= reg
->addr
;
149 if (reg
->addr
> (CORE_ADDR
) soft_max_addr
)
150 soft_max_addr
= reg
->addr
;
159 /* Initialize the table of soft register addresses according
160 to the symbol table. */
162 m68hc11_initialize_register_info (void)
166 if (soft_reg_initialized
)
169 soft_min_addr
= INT_MAX
;
171 for (i
= 0; i
< M68HC11_ALL_REGS
; i
++)
173 soft_regs
[i
].name
= 0;
176 m68hc11_get_register_info (&soft_regs
[SOFT_FP_REGNUM
], "_.frame");
177 m68hc11_get_register_info (&soft_regs
[SOFT_TMP_REGNUM
], "_.tmp");
178 m68hc11_get_register_info (&soft_regs
[SOFT_ZS_REGNUM
], "_.z");
179 soft_regs
[SOFT_Z_REGNUM
] = soft_regs
[SOFT_ZS_REGNUM
];
180 m68hc11_get_register_info (&soft_regs
[SOFT_XY_REGNUM
], "_.xy");
182 for (i
= SOFT_D1_REGNUM
; i
< M68HC11_MAX_SOFT_REGS
; i
++)
186 sprintf (buf
, "_.d%d", i
- SOFT_D1_REGNUM
+ 1);
187 m68hc11_get_register_info (&soft_regs
[i
], buf
);
190 if (soft_regs
[SOFT_FP_REGNUM
].name
== 0)
192 warning ("No frame soft register found in the symbol table.\n");
193 warning ("Stack backtrace will not work.\n");
195 soft_reg_initialized
= 1;
198 /* Given an address in memory, return the soft register number if
199 that address corresponds to a soft register. Returns -1 if not. */
201 m68hc11_which_soft_register (CORE_ADDR addr
)
205 if (addr
< soft_min_addr
|| addr
> soft_max_addr
)
208 for (i
= SOFT_FP_REGNUM
; i
< M68HC11_ALL_REGS
; i
++)
210 if (soft_regs
[i
].name
&& soft_regs
[i
].addr
== addr
)
216 /* Fetch a pseudo register. The 68hc11 soft registers are treated like
217 pseudo registers. They are located in memory. Translate the register
218 fetch into a memory read. */
220 m68hc11_fetch_pseudo_register (int regno
)
222 char buf
[MAX_REGISTER_RAW_SIZE
];
224 m68hc11_initialize_register_info ();
226 /* Fetch a soft register: translate into a memory read. */
227 if (soft_regs
[regno
].name
)
229 target_read_memory (soft_regs
[regno
].addr
, buf
, 2);
235 supply_register (regno
, buf
);
238 /* Store a pseudo register. Translate the register store
239 into a memory write. */
241 m68hc11_store_pseudo_register (int regno
)
243 m68hc11_initialize_register_info ();
245 /* Store a soft register: translate into a memory write. */
246 if (soft_regs
[regno
].name
)
248 char buf
[MAX_REGISTER_RAW_SIZE
];
250 read_register_gen (regno
, buf
);
251 target_write_memory (soft_regs
[regno
].addr
, buf
, 2);
256 m68hc11_register_name (int reg_nr
)
260 if (reg_nr
>= M68HC11_ALL_REGS
)
263 /* If we don't know the address of a soft register, pretend it
265 if (reg_nr
> M68HC11_LAST_HARD_REG
&& soft_regs
[reg_nr
].name
== 0)
267 return m68hc11_register_names
[reg_nr
];
270 static unsigned char *
271 m68hc11_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
273 static unsigned char breakpoint
[] = {0x0};
275 *lenptr
= sizeof (breakpoint
);
279 /* Immediately after a function call, return the saved pc before the frame
283 m68hc11_saved_pc_after_call (struct frame_info
*frame
)
287 addr
= read_register (HARD_SP_REGNUM
) + STACK_CORRECTION
;
289 return read_memory_integer (addr
, 2) & 0x0FFFF;
293 m68hc11_frame_saved_pc (struct frame_info
*frame
)
295 return frame
->extra_info
->return_pc
;
299 m68hc11_frame_args_address (struct frame_info
*frame
)
305 m68hc11_frame_locals_address (struct frame_info
*frame
)
310 /* Discard from the stack the innermost frame, restoring all saved
314 m68hc11_pop_frame (void)
316 register struct frame_info
*frame
= get_current_frame ();
317 register CORE_ADDR fp
, sp
;
320 if (PC_IN_CALL_DUMMY (frame
->pc
, frame
->frame
, frame
->frame
))
321 generic_pop_dummy_frame ();
324 fp
= FRAME_FP (frame
);
325 FRAME_INIT_SAVED_REGS (frame
);
327 /* Copy regs from where they were saved in the frame. */
328 for (regnum
= 0; regnum
< M68HC11_ALL_REGS
; regnum
++)
329 if (frame
->saved_regs
[regnum
])
330 write_register (regnum
,
331 read_memory_integer (frame
->saved_regs
[regnum
], 2));
333 write_register (HARD_PC_REGNUM
, frame
->extra_info
->return_pc
);
334 sp
= fp
+ frame
->extra_info
->size
;
335 write_register (HARD_SP_REGNUM
, sp
);
337 flush_cached_frames ();
340 /* Analyze the function prologue to find some information
342 - the PC of the first line (for m68hc11_skip_prologue)
343 - the offset of the previous frame saved address (from current frame)
344 - the soft registers which are pushed. */
346 m68hc11_guess_from_prologue (CORE_ADDR pc
, CORE_ADDR fp
,
347 CORE_ADDR
*first_line
,
348 int *frame_offset
, CORE_ADDR
*pushed_regs
)
352 unsigned char op0
, op1
, op2
;
356 int found_frame_point
;
360 first_pc
= get_pc_function_start (pc
);
363 m68hc11_initialize_register_info ();
371 #define OP_PAGE2 (0x18)
372 #define OP_LDX (0xde)
373 #define OP_LDY (0xde)
374 #define OP_PSHX (0x3c)
375 #define OP_PSHY (0x3c)
376 #define OP_STS (0x9f)
377 #define OP_TSX (0x30)
378 #define OP_TSY (0x30)
379 #define OP_XGDX (0x8f)
380 #define OP_XGDY (0x8f)
381 #define OP_ADDD (0xc3)
382 #define OP_TXS (0x35)
383 #define OP_TYS (0x35)
384 #define OP_DES (0x34)
386 /* The 68hc11 stack is as follows:
402 +-----------+ <--- current frame
405 With most processors (like 68K) the previous frame can be computed
406 easily because it is always at a fixed offset (see link/unlink).
407 That is, locals are accessed with negative offsets, arguments are
408 accessed with positive ones. Since 68hc11 only supports offsets
409 in the range [0..255], the frame is defined at the bottom of
410 locals (see picture).
412 The purpose of the analysis made here is to find out the size
413 of locals in this function. An alternative to this is to use
414 DWARF2 info. This would be better but I don't know how to
415 access dwarf2 debug from this function.
417 Walk from the function entry point to the point where we save
418 the frame. While walking instructions, compute the size of bytes
419 which are pushed. This gives us the index to access the previous
422 We limit the search to 128 bytes so that the algorithm is bounded
423 in case of random and wrong code. We also stop and abort if
424 we find an instruction which is not supposed to appear in the
425 prologue (as generated by gcc 2.95, 2.96).
430 found_frame_point
= 0;
431 while (pc
+ 2 < func_end
)
433 op0
= read_memory_unsigned_integer (pc
, 1);
434 op1
= read_memory_unsigned_integer (pc
+ 1, 1);
435 op2
= read_memory_unsigned_integer (pc
+ 2, 1);
438 if (op0
== OP_LDX
&& op1
== M68HC11_FP_ADDR
)
444 else if (op0
== OP_PAGE2
&& op1
== OP_LDY
445 && op2
== M68HC11_FP_ADDR
)
451 else if (op0
== OP_PSHX
)
458 else if (op0
== OP_PAGE2
&& op1
== OP_PSHX
)
465 else if (op0
== OP_STS
&& op1
== M68HC11_FP_ADDR
)
467 found_frame_point
= 1;
471 else if (op0
== OP_TSX
&& op1
== OP_XGDX
)
476 /* des to allocate 1 byte on the stack */
477 else if (op0
== OP_DES
)
482 else if (op0
== OP_PAGE2
&& op1
== OP_TSY
&& op2
== OP_PAGE2
)
484 op0
= read_memory_unsigned_integer (pc
+ 3, 1);
491 else if (add_sp_mode
&& op0
== OP_ADDD
)
493 sp_adjust
= read_memory_unsigned_integer (pc
+ 1, 2);
494 if (sp_adjust
& 0x8000)
495 sp_adjust
|= 0xffff0000L
;
497 sp_adjust
= -sp_adjust
;
501 else if (add_sp_mode
== (1 | 4) && op0
== OP_XGDX
508 else if (add_sp_mode
== (2 | 4) && op0
== OP_PAGE2
509 && op1
== OP_XGDY
&& op2
== OP_PAGE2
)
511 op0
= read_memory_unsigned_integer (pc
+ 3, 1);
525 if (found_frame_point
== 0)
531 *frame_offset
= size
;
534 /* Now, look forward to see how many registers are pushed on the stack.
535 We look only for soft registers so there must be a first LDX *REG
539 while (pc
+ 2 < func_end
)
541 op0
= read_memory_unsigned_integer (pc
, 1);
542 op1
= read_memory_unsigned_integer (pc
+ 1, 1);
543 op2
= read_memory_unsigned_integer (pc
+ 2, 1);
546 saved_reg
= m68hc11_which_soft_register (op1
);
547 if (saved_reg
< 0 || saved_reg
== SOFT_FP_REGNUM
)
552 else if (op0
== OP_PAGE2
&& op1
== OP_LDY
)
554 saved_reg
= m68hc11_which_soft_register (op2
);
555 if (saved_reg
< 0 || saved_reg
== SOFT_FP_REGNUM
)
560 else if (op0
== OP_PSHX
)
562 /* If there was no load, this is a push for a function call. */
563 if (saved_reg
< 0 || saved_reg
>= M68HC11_ALL_REGS
)
566 /* Keep track of the address where that register is saved
570 pushed_regs
[saved_reg
] = save_addr
;
575 else if (op0
== OP_PAGE2
&& op1
== OP_PSHY
)
577 if (saved_reg
< 0 || saved_reg
>= M68HC11_ALL_REGS
)
580 /* Keep track of the address where that register is saved
584 pushed_regs
[saved_reg
] = save_addr
;
598 m68hc11_skip_prologue (CORE_ADDR pc
)
600 CORE_ADDR func_addr
, func_end
;
601 struct symtab_and_line sal
;
604 /* If we have line debugging information, then the end of the
605 prologue should be the first assembly instruction of the
606 first source line. */
607 if (find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
609 sal
= find_pc_line (func_addr
, 0);
610 if (sal
.end
&& sal
.end
< func_end
)
614 m68hc11_guess_from_prologue (pc
, 0, &pc
, &frame_offset
, 0);
618 /* Given a GDB frame, determine the address of the calling function's frame.
619 This will be used to create a new GDB frame struct, and then
620 INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
624 m68hc11_frame_chain (struct frame_info
*frame
)
628 if (PC_IN_CALL_DUMMY (frame
->pc
, frame
->frame
, frame
->frame
))
629 return frame
->frame
; /* dummy frame same as caller's frame */
631 if (frame
->extra_info
->return_pc
== 0
632 || inside_entry_file (frame
->extra_info
->return_pc
))
633 return (CORE_ADDR
) 0;
635 if (frame
->frame
== 0)
637 return (CORE_ADDR
) 0;
640 addr
= frame
->frame
+ frame
->extra_info
->size
+ STACK_CORRECTION
- 2;
641 addr
= read_memory_unsigned_integer (addr
, 2) & 0x0FFFF;
644 return (CORE_ADDR
) 0;
650 /* Put here the code to store, into a struct frame_saved_regs, the
651 addresses of the saved registers of frame described by FRAME_INFO.
652 This includes special registers such as pc and fp saved in special
653 ways in the stack frame. sp is even more special: the address we
654 return for it IS the sp for the next frame. */
656 m68hc11_frame_init_saved_regs (struct frame_info
*fi
)
661 if (fi
->saved_regs
== NULL
)
662 frame_saved_regs_zalloc (fi
);
664 memset (fi
->saved_regs
, 0, sizeof (fi
->saved_regs
));
667 m68hc11_guess_from_prologue (pc
, fi
->frame
, &pc
, &fi
->extra_info
->size
,
670 addr
= fi
->frame
+ fi
->extra_info
->size
+ STACK_CORRECTION
;
671 fi
->saved_regs
[SOFT_FP_REGNUM
] = addr
- 2;
672 fi
->saved_regs
[HARD_SP_REGNUM
] = addr
;
673 fi
->saved_regs
[HARD_PC_REGNUM
] = fi
->saved_regs
[HARD_SP_REGNUM
];
677 m68hc11_init_extra_frame_info (int fromleaf
, struct frame_info
*fi
)
681 fi
->extra_info
= (struct frame_extra_info
*)
682 frame_obstack_alloc (sizeof (struct frame_extra_info
));
685 fi
->pc
= FRAME_SAVED_PC (fi
->next
);
687 m68hc11_frame_init_saved_regs (fi
);
691 fi
->extra_info
->return_pc
= m68hc11_saved_pc_after_call (fi
);
695 addr
= fi
->frame
+ fi
->extra_info
->size
+ STACK_CORRECTION
;
696 addr
= read_memory_unsigned_integer (addr
, 2) & 0x0ffff;
697 fi
->extra_info
->return_pc
= addr
;
699 printf ("Pc@0x%04x, FR 0x%04x, size %d, read ret @0x%04x -> 0x%04x\n",
708 /* Same as 'info reg' but prints the registers in a different way. */
710 show_regs (char *args
, int from_tty
)
712 int ccr
= read_register (HARD_CCR_REGNUM
);
716 printf_filtered ("PC=%04x SP=%04x FP=%04x CCR=%02x %c%c%c%c%c%c%c%c\n",
717 (int) read_register (HARD_PC_REGNUM
),
718 (int) read_register (HARD_SP_REGNUM
),
719 (int) read_register (SOFT_FP_REGNUM
),
721 ccr
& M6811_S_BIT
? 'S' : '-',
722 ccr
& M6811_X_BIT
? 'X' : '-',
723 ccr
& M6811_H_BIT
? 'H' : '-',
724 ccr
& M6811_I_BIT
? 'I' : '-',
725 ccr
& M6811_N_BIT
? 'N' : '-',
726 ccr
& M6811_Z_BIT
? 'Z' : '-',
727 ccr
& M6811_V_BIT
? 'V' : '-',
728 ccr
& M6811_C_BIT
? 'C' : '-');
730 printf_filtered ("D=%04x IX=%04x IY=%04x\n",
731 (int) read_register (HARD_D_REGNUM
),
732 (int) read_register (HARD_X_REGNUM
),
733 (int) read_register (HARD_Y_REGNUM
));
736 for (i
= SOFT_D1_REGNUM
; i
< M68HC11_ALL_REGS
; i
++)
738 /* Skip registers which are not defined in the symbol table. */
739 if (soft_regs
[i
].name
== 0)
742 printf_filtered ("D%d=%04x",
743 i
- SOFT_D1_REGNUM
+ 1,
744 (int) read_register (i
));
747 printf_filtered ("\n");
749 printf_filtered (" ");
751 if (nr
&& (nr
% 8) != 7)
752 printf_filtered ("\n");
756 m68hc11_stack_align (CORE_ADDR addr
)
758 return ((addr
+ 1) & -2);
762 m68hc11_push_arguments (int nargs
,
766 CORE_ADDR struct_addr
)
770 int first_stack_argnum
;
777 first_stack_argnum
= 0;
780 /* The struct is allocated on the stack and gdb used the stack
781 pointer for the address of that struct. We must apply the
782 stack offset on the address. */
783 write_register (HARD_D_REGNUM
, struct_addr
+ STACK_CORRECTION
);
787 type
= VALUE_TYPE (args
[0]);
788 len
= TYPE_LENGTH (type
);
790 /* First argument is passed in D and X registers. */
793 LONGEST v
= extract_unsigned_integer (VALUE_CONTENTS (args
[0]), len
);
794 first_stack_argnum
= 1;
795 write_register (HARD_D_REGNUM
, v
);
799 write_register (HARD_X_REGNUM
, v
);
803 for (argnum
= first_stack_argnum
; argnum
< nargs
; argnum
++)
805 type
= VALUE_TYPE (args
[argnum
]);
806 stack_alloc
+= (TYPE_LENGTH (type
) + 1) & -2;
810 stack_offset
= STACK_CORRECTION
;
811 for (argnum
= first_stack_argnum
; argnum
< nargs
; argnum
++)
813 type
= VALUE_TYPE (args
[argnum
]);
814 len
= TYPE_LENGTH (type
);
816 val
= (char*) VALUE_CONTENTS (args
[argnum
]);
817 write_memory (sp
+ stack_offset
, val
, len
);
821 static char zero
= 0;
823 write_memory (sp
+ stack_offset
, &zero
, 1);
831 /* Return a location where we can set a breakpoint that will be hit
832 when an inferior function call returns. */
834 m68hc11_call_dummy_address (void)
836 return entry_point_address ();
840 m68hc11_register_virtual_type (int reg_nr
)
842 return builtin_type_uint16
;
846 m68hc11_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
848 /* The struct address computed by gdb is on the stack.
849 It uses the stack pointer so we must apply the stack
850 correction offset. */
851 write_register (HARD_D_REGNUM
, addr
+ STACK_CORRECTION
);
855 m68hc11_store_return_value (struct type
*type
, char *valbuf
)
859 len
= TYPE_LENGTH (type
);
861 /* First argument is passed in D and X registers. */
864 LONGEST v
= extract_unsigned_integer (valbuf
, len
);
866 write_register (HARD_D_REGNUM
, v
);
870 write_register (HARD_X_REGNUM
, v
);
874 error ("return of value > 4 is not supported.");
878 /* Given a return value in `regbuf' with a type `type',
879 extract and copy its value into `valbuf'. */
882 m68hc11_extract_return_value (struct type
*type
,
886 int len
= TYPE_LENGTH (type
);
891 memcpy (valbuf
, ®buf
[HARD_D_REGNUM
* 2 + 1], len
);
895 memcpy (valbuf
, ®buf
[HARD_D_REGNUM
* 2], len
);
899 memcpy (&valbuf
[0], ®buf
[HARD_X_REGNUM
* 2 + 1], 1);
900 memcpy (&valbuf
[1], ®buf
[HARD_D_REGNUM
* 2], 2);
904 memcpy (&valbuf
[0], ®buf
[HARD_X_REGNUM
* 2], 2);
905 memcpy (&valbuf
[2], ®buf
[HARD_D_REGNUM
* 2], 2);
909 error ("bad size for return value");
913 /* Should call_function allocate stack space for a struct return? */
915 m68hc11_use_struct_convention (int gcc_p
, struct type
*type
)
917 return (TYPE_CODE (type
) == TYPE_CODE_STRUCT
918 || TYPE_CODE (type
) == TYPE_CODE_UNION
919 || TYPE_LENGTH (type
) > 4);
923 m68hc11_return_value_on_stack (struct type
*type
)
925 return TYPE_LENGTH (type
) > 4;
928 /* Extract from an array REGBUF containing the (raw) register state
929 the address in which a function should return its structure value,
930 as a CORE_ADDR (or an expression that can be used as one). */
932 m68hc11_extract_struct_value_address (char *regbuf
)
934 return extract_address (®buf
[HARD_D_REGNUM
* 2],
935 REGISTER_RAW_SIZE (HARD_D_REGNUM
));
938 /* Function: push_return_address (pc)
939 Set up the return address for the inferior function call.
940 Needed for targets where we don't actually execute a JSR/BSR instruction */
943 m68hc11_push_return_address (CORE_ADDR pc
, CORE_ADDR sp
)
947 pc
= CALL_DUMMY_ADDRESS ();
949 store_unsigned_integer (valbuf
, 2, pc
);
950 write_memory (sp
+ STACK_CORRECTION
, valbuf
, 2);
954 /* Index within `registers' of the first byte of the space for
957 m68hc11_register_byte (int reg_nr
)
959 return (reg_nr
* M68HC11_REG_SIZE
);
963 m68hc11_register_raw_size (int reg_nr
)
965 return M68HC11_REG_SIZE
;
969 gdb_print_insn_m68hc11 (bfd_vma memaddr
, disassemble_info
*info
)
971 if (TARGET_ARCHITECTURE
->arch
== bfd_arch_m68hc11
)
972 return print_insn_m68hc11 (memaddr
, info
);
974 return print_insn_m68hc12 (memaddr
, info
);
977 static struct gdbarch
*
978 m68hc11_gdbarch_init (struct gdbarch_info info
,
979 struct gdbarch_list
*arches
)
981 static LONGEST m68hc11_call_dummy_words
[] =
983 struct gdbarch
*gdbarch
;
984 struct gdbarch_tdep
*tdep
;
987 /* Extract the elf_flags if available */
990 soft_reg_initialized
= 0;
992 /* try to find a pre-existing architecture */
993 for (arches
= gdbarch_list_lookup_by_info (arches
, &info
);
995 arches
= gdbarch_list_lookup_by_info (arches
->next
, &info
))
997 /* MIPS needs to be pedantic about which ABI the object is
999 if (gdbarch_tdep (current_gdbarch
)->elf_flags
!= elf_flags
)
1001 return arches
->gdbarch
;
1004 /* Need a new architecture. Fill in a target specific vector. */
1005 tdep
= (struct gdbarch_tdep
*) xmalloc (sizeof (struct gdbarch_tdep
));
1006 gdbarch
= gdbarch_alloc (&info
, tdep
);
1007 tdep
->elf_flags
= elf_flags
;
1008 switch (info
.bfd_arch_info
->arch
)
1010 case bfd_arch_m68hc11
:
1011 tdep
->stack_correction
= 1;
1014 case bfd_arch_m68hc12
:
1015 tdep
->stack_correction
= 0;
1022 /* Initially set everything according to the ABI. */
1023 set_gdbarch_short_bit (gdbarch
, 16);
1024 set_gdbarch_int_bit (gdbarch
, 32);
1025 set_gdbarch_float_bit (gdbarch
, 32);
1026 set_gdbarch_double_bit (gdbarch
, 64);
1027 set_gdbarch_long_double_bit (gdbarch
, 64);
1028 set_gdbarch_long_bit (gdbarch
, 32);
1029 set_gdbarch_ptr_bit (gdbarch
, 16);
1030 set_gdbarch_long_long_bit (gdbarch
, 64);
1032 /* Set register info. */
1033 set_gdbarch_fp0_regnum (gdbarch
, -1);
1034 set_gdbarch_max_register_raw_size (gdbarch
, 2);
1035 set_gdbarch_max_register_virtual_size (gdbarch
, 2);
1036 set_gdbarch_register_raw_size (gdbarch
, m68hc11_register_raw_size
);
1037 set_gdbarch_register_virtual_size (gdbarch
, m68hc11_register_raw_size
);
1038 set_gdbarch_register_byte (gdbarch
, m68hc11_register_byte
);
1039 set_gdbarch_frame_init_saved_regs (gdbarch
, m68hc11_frame_init_saved_regs
);
1040 set_gdbarch_frame_args_skip (gdbarch
, 0);
1042 set_gdbarch_read_pc (gdbarch
, generic_target_read_pc
);
1043 set_gdbarch_write_pc (gdbarch
, generic_target_write_pc
);
1044 set_gdbarch_read_fp (gdbarch
, generic_target_read_fp
);
1045 set_gdbarch_write_fp (gdbarch
, generic_target_write_fp
);
1046 set_gdbarch_read_sp (gdbarch
, generic_target_read_sp
);
1047 set_gdbarch_write_sp (gdbarch
, generic_target_write_sp
);
1049 set_gdbarch_num_regs (gdbarch
, M68HC11_NUM_REGS
);
1050 set_gdbarch_num_pseudo_regs (gdbarch
, M68HC11_NUM_PSEUDO_REGS
);
1051 set_gdbarch_sp_regnum (gdbarch
, HARD_SP_REGNUM
);
1052 set_gdbarch_fp_regnum (gdbarch
, SOFT_FP_REGNUM
);
1053 set_gdbarch_pc_regnum (gdbarch
, HARD_PC_REGNUM
);
1054 set_gdbarch_register_name (gdbarch
, m68hc11_register_name
);
1055 set_gdbarch_register_size (gdbarch
, 2);
1056 set_gdbarch_register_bytes (gdbarch
, M68HC11_ALL_REGS
* 2);
1057 set_gdbarch_register_virtual_type (gdbarch
, m68hc11_register_virtual_type
);
1058 set_gdbarch_fetch_pseudo_register (gdbarch
, m68hc11_fetch_pseudo_register
);
1059 set_gdbarch_store_pseudo_register (gdbarch
, m68hc11_store_pseudo_register
);
1061 set_gdbarch_use_generic_dummy_frames (gdbarch
, 1);
1062 set_gdbarch_call_dummy_length (gdbarch
, 0);
1063 set_gdbarch_call_dummy_location (gdbarch
, AT_ENTRY_POINT
);
1064 set_gdbarch_call_dummy_address (gdbarch
, m68hc11_call_dummy_address
);
1065 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch
, 1); /*???*/
1066 set_gdbarch_call_dummy_breakpoint_offset (gdbarch
, 0);
1067 set_gdbarch_call_dummy_start_offset (gdbarch
, 0);
1068 set_gdbarch_pc_in_call_dummy (gdbarch
, generic_pc_in_call_dummy
);
1069 set_gdbarch_call_dummy_words (gdbarch
, m68hc11_call_dummy_words
);
1070 set_gdbarch_sizeof_call_dummy_words (gdbarch
,
1071 sizeof (m68hc11_call_dummy_words
));
1072 set_gdbarch_call_dummy_p (gdbarch
, 1);
1073 set_gdbarch_call_dummy_stack_adjust_p (gdbarch
, 0);
1074 set_gdbarch_get_saved_register (gdbarch
, generic_get_saved_register
);
1075 set_gdbarch_fix_call_dummy (gdbarch
, generic_fix_call_dummy
);
1076 set_gdbarch_extract_return_value (gdbarch
, m68hc11_extract_return_value
);
1077 set_gdbarch_push_arguments (gdbarch
, m68hc11_push_arguments
);
1078 set_gdbarch_push_dummy_frame (gdbarch
, generic_push_dummy_frame
);
1079 set_gdbarch_push_return_address (gdbarch
, m68hc11_push_return_address
);
1080 set_gdbarch_return_value_on_stack (gdbarch
, m68hc11_return_value_on_stack
);
1082 set_gdbarch_store_struct_return (gdbarch
, m68hc11_store_struct_return
);
1083 set_gdbarch_store_return_value (gdbarch
, m68hc11_store_return_value
);
1084 set_gdbarch_extract_struct_value_address (gdbarch
,
1085 m68hc11_extract_struct_value_address
);
1086 set_gdbarch_register_convertible (gdbarch
, generic_register_convertible_not
);
1089 set_gdbarch_frame_chain (gdbarch
, m68hc11_frame_chain
);
1090 set_gdbarch_frame_chain_valid (gdbarch
, generic_file_frame_chain_valid
);
1091 set_gdbarch_frame_saved_pc (gdbarch
, m68hc11_frame_saved_pc
);
1092 set_gdbarch_frame_args_address (gdbarch
, m68hc11_frame_args_address
);
1093 set_gdbarch_frame_locals_address (gdbarch
, m68hc11_frame_locals_address
);
1094 set_gdbarch_saved_pc_after_call (gdbarch
, m68hc11_saved_pc_after_call
);
1095 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
1097 set_gdbarch_frame_chain_valid (gdbarch
, func_frame_chain_valid
);
1098 set_gdbarch_get_saved_register (gdbarch
, generic_get_saved_register
);
1100 set_gdbarch_store_struct_return (gdbarch
, m68hc11_store_struct_return
);
1101 set_gdbarch_store_return_value (gdbarch
, m68hc11_store_return_value
);
1102 set_gdbarch_extract_struct_value_address
1103 (gdbarch
, m68hc11_extract_struct_value_address
);
1104 set_gdbarch_use_struct_convention (gdbarch
, m68hc11_use_struct_convention
);
1105 set_gdbarch_init_extra_frame_info (gdbarch
, m68hc11_init_extra_frame_info
);
1106 set_gdbarch_pop_frame (gdbarch
, m68hc11_pop_frame
);
1107 set_gdbarch_skip_prologue (gdbarch
, m68hc11_skip_prologue
);
1108 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1109 set_gdbarch_decr_pc_after_break (gdbarch
, 0);
1110 set_gdbarch_function_start_offset (gdbarch
, 0);
1111 set_gdbarch_breakpoint_from_pc (gdbarch
, m68hc11_breakpoint_from_pc
);
1112 set_gdbarch_stack_align (gdbarch
, m68hc11_stack_align
);
1114 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
1115 set_gdbarch_ieee_float (gdbarch
, 1);
1121 _initialize_m68hc11_tdep (void)
1123 register_gdbarch_init (bfd_arch_m68hc11
, m68hc11_gdbarch_init
);
1124 register_gdbarch_init (bfd_arch_m68hc12
, m68hc11_gdbarch_init
);
1125 if (!tm_print_insn
) /* Someone may have already set it */
1126 tm_print_insn
= gdb_print_insn_m68hc11
;
1128 add_com ("regs", class_vars
, show_regs
, "Print all registers");