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 */
86 struct frame_extra_info
95 /* Table of registers for 68HC11. This includes the hard registers
96 and the soft registers used by GCC. */
98 m68hc11_register_names
[] =
100 "x", "d", "y", "sp", "pc", "a", "b",
101 "ccr", "z", "frame","tmp", "zs", "xy",
102 "d1", "d2", "d3", "d4", "d5", "d6", "d7",
103 "d8", "d9", "d10", "d11", "d12", "d13", "d14",
104 "d15", "d16", "d17", "d18", "d19", "d20", "d21",
105 "d22", "d23", "d24", "d25", "d26", "d27", "d28",
106 "d29", "d30", "d31", "d32"
109 struct m68hc11_soft_reg
115 static struct m68hc11_soft_reg soft_regs
[M68HC11_ALL_REGS
];
117 #define M68HC11_FP_ADDR soft_regs[SOFT_FP_REGNUM].addr
119 static int soft_min_addr
;
120 static int soft_max_addr
;
121 static int soft_reg_initialized
= 0;
123 /* Stack pointer correction value. For 68hc11, the stack pointer points
124 to the next push location. An offset of 1 must be applied to obtain
125 the address where the last value is saved. For 68hc12, the stack
126 pointer points to the last value pushed. No offset is necessary. */
127 static int stack_correction
= 1;
129 /* Look in the symbol table for the address of a pseudo register
130 in memory. If we don't find it, pretend the register is not used
131 and not available. */
133 m68hc11_get_register_info (struct m68hc11_soft_reg
*reg
, const char *name
)
135 struct minimal_symbol
*msymbol
;
137 msymbol
= lookup_minimal_symbol (name
, NULL
, NULL
);
140 reg
->addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
141 reg
->name
= xstrdup (name
);
143 /* Keep track of the address range for soft registers. */
144 if (reg
->addr
< (CORE_ADDR
) soft_min_addr
)
145 soft_min_addr
= reg
->addr
;
146 if (reg
->addr
> (CORE_ADDR
) soft_max_addr
)
147 soft_max_addr
= reg
->addr
;
156 /* Initialize the table of soft register addresses according
157 to the symbol table. */
159 m68hc11_initialize_register_info (void)
163 if (soft_reg_initialized
)
166 soft_min_addr
= INT_MAX
;
168 for (i
= 0; i
< M68HC11_ALL_REGS
; i
++)
170 soft_regs
[i
].name
= 0;
173 m68hc11_get_register_info (&soft_regs
[SOFT_FP_REGNUM
], "_.frame");
174 m68hc11_get_register_info (&soft_regs
[SOFT_TMP_REGNUM
], "_.tmp");
175 m68hc11_get_register_info (&soft_regs
[SOFT_ZS_REGNUM
], "_.z");
176 soft_regs
[SOFT_Z_REGNUM
] = soft_regs
[SOFT_ZS_REGNUM
];
177 m68hc11_get_register_info (&soft_regs
[SOFT_XY_REGNUM
], "_.xy");
179 for (i
= SOFT_D1_REGNUM
; i
< M68HC11_MAX_SOFT_REGS
; i
++)
183 sprintf (buf
, "_.d%d", i
- SOFT_D1_REGNUM
+ 1);
184 m68hc11_get_register_info (&soft_regs
[i
], buf
);
187 if (soft_regs
[SOFT_FP_REGNUM
].name
== 0)
189 warning ("No frame soft register found in the symbol table.\n");
190 warning ("Stack backtrace will not work.\n");
192 soft_reg_initialized
= 1;
195 /* Given an address in memory, return the soft register number if
196 that address corresponds to a soft register. Returns -1 if not. */
198 m68hc11_which_soft_register (CORE_ADDR addr
)
202 if (addr
< soft_min_addr
|| addr
> soft_max_addr
)
205 for (i
= SOFT_FP_REGNUM
; i
< M68HC11_ALL_REGS
; i
++)
207 if (soft_regs
[i
].name
&& soft_regs
[i
].addr
== addr
)
213 /* Fetch a pseudo register. The 68hc11 soft registers are treated like
214 pseudo registers. They are located in memory. Translate the register
215 fetch into a memory read. */
217 m68hc11_fetch_pseudo_register (int regno
)
219 char buf
[MAX_REGISTER_RAW_SIZE
];
221 m68hc11_initialize_register_info ();
223 /* Fetch a soft register: translate into a memory read. */
224 if (soft_regs
[regno
].name
)
226 target_read_memory (soft_regs
[regno
].addr
, buf
, 2);
232 supply_register (regno
, buf
);
235 /* Store a pseudo register. Translate the register store
236 into a memory write. */
238 m68hc11_store_pseudo_register (int regno
)
240 m68hc11_initialize_register_info ();
242 /* Store a soft register: translate into a memory write. */
243 if (soft_regs
[regno
].name
)
245 char buf
[MAX_REGISTER_RAW_SIZE
];
247 read_register_gen (regno
, buf
);
248 target_write_memory (soft_regs
[regno
].addr
, buf
, 2);
253 m68hc11_register_name (int reg_nr
)
257 if (reg_nr
>= M68HC11_ALL_REGS
)
260 /* If we don't know the address of a soft register, pretend it
262 if (reg_nr
> M68HC11_LAST_HARD_REG
&& soft_regs
[reg_nr
].name
== 0)
264 return m68hc11_register_names
[reg_nr
];
267 static unsigned char *
268 m68hc11_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
270 static unsigned char breakpoint
[] = {0x0};
272 *lenptr
= sizeof (breakpoint
);
276 /* Immediately after a function call, return the saved pc before the frame
280 m68hc11_saved_pc_after_call (struct frame_info
*frame
)
284 addr
= read_register (HARD_SP_REGNUM
) + stack_correction
;
286 return read_memory_integer (addr
, 2) & 0x0FFFF;
290 m68hc11_frame_saved_pc (struct frame_info
*frame
)
292 return frame
->extra_info
->return_pc
;
296 m68hc11_frame_args_address (struct frame_info
*frame
)
302 m68hc11_frame_locals_address (struct frame_info
*frame
)
307 /* Discard from the stack the innermost frame, restoring all saved
311 m68hc11_pop_frame (void)
313 register struct frame_info
*frame
= get_current_frame ();
314 register CORE_ADDR fp
, sp
;
317 if (PC_IN_CALL_DUMMY (frame
->pc
, frame
->frame
, frame
->frame
))
318 generic_pop_dummy_frame ();
321 fp
= FRAME_FP (frame
);
322 FRAME_INIT_SAVED_REGS (frame
);
324 /* Copy regs from where they were saved in the frame. */
325 for (regnum
= 0; regnum
< M68HC11_ALL_REGS
; regnum
++)
326 if (frame
->saved_regs
[regnum
])
327 write_register (regnum
,
328 read_memory_integer (frame
->saved_regs
[regnum
], 2));
330 write_register (HARD_PC_REGNUM
, frame
->extra_info
->return_pc
);
331 sp
= fp
+ frame
->extra_info
->size
;
332 write_register (HARD_SP_REGNUM
, sp
);
334 flush_cached_frames ();
337 /* Analyze the function prologue to find some information
339 - the PC of the first line (for m68hc11_skip_prologue)
340 - the offset of the previous frame saved address (from current frame)
341 - the soft registers which are pushed. */
343 m68hc11_guess_from_prologue (CORE_ADDR pc
, CORE_ADDR fp
,
344 CORE_ADDR
*first_line
,
345 int *frame_offset
, CORE_ADDR
*pushed_regs
)
349 unsigned char op0
, op1
, op2
;
353 int found_frame_point
;
357 first_pc
= get_pc_function_start (pc
);
360 m68hc11_initialize_register_info ();
368 #define OP_PAGE2 (0x18)
369 #define OP_LDX (0xde)
370 #define OP_LDY (0xde)
371 #define OP_PSHX (0x3c)
372 #define OP_PSHY (0x3c)
373 #define OP_STS (0x9f)
374 #define OP_TSX (0x30)
375 #define OP_TSY (0x30)
376 #define OP_XGDX (0x8f)
377 #define OP_XGDY (0x8f)
378 #define OP_ADDD (0xc3)
379 #define OP_TXS (0x35)
380 #define OP_TYS (0x35)
381 #define OP_DES (0x34)
383 /* The 68hc11 stack is as follows:
399 +-----------+ <--- current frame
402 With most processors (like 68K) the previous frame can be computed
403 easily because it is always at a fixed offset (see link/unlink).
404 That is, locals are accessed with negative offsets, arguments are
405 accessed with positive ones. Since 68hc11 only supports offsets
406 in the range [0..255], the frame is defined at the bottom of
407 locals (see picture).
409 The purpose of the analysis made here is to find out the size
410 of locals in this function. An alternative to this is to use
411 DWARF2 info. This would be better but I don't know how to
412 access dwarf2 debug from this function.
414 Walk from the function entry point to the point where we save
415 the frame. While walking instructions, compute the size of bytes
416 which are pushed. This gives us the index to access the previous
419 We limit the search to 128 bytes so that the algorithm is bounded
420 in case of random and wrong code. We also stop and abort if
421 we find an instruction which is not supposed to appear in the
422 prologue (as generated by gcc 2.95, 2.96).
427 found_frame_point
= 0;
428 while (pc
+ 2 < func_end
)
430 op0
= read_memory_unsigned_integer (pc
, 1);
431 op1
= read_memory_unsigned_integer (pc
+ 1, 1);
432 op2
= read_memory_unsigned_integer (pc
+ 2, 1);
435 if (op0
== OP_LDX
&& op1
== M68HC11_FP_ADDR
)
441 else if (op0
== OP_PAGE2
&& op1
== OP_LDY
442 && op2
== M68HC11_FP_ADDR
)
448 else if (op0
== OP_PSHX
)
455 else if (op0
== OP_PAGE2
&& op1
== OP_PSHX
)
462 else if (op0
== OP_STS
&& op1
== M68HC11_FP_ADDR
)
464 found_frame_point
= 1;
468 else if (op0
== OP_TSX
&& op1
== OP_XGDX
)
473 /* des to allocate 1 byte on the stack */
474 else if (op0
== OP_DES
)
479 else if (op0
== OP_PAGE2
&& op1
== OP_TSY
&& op2
== OP_PAGE2
)
481 op0
= read_memory_unsigned_integer (pc
+ 3, 1);
488 else if (add_sp_mode
&& op0
== OP_ADDD
)
490 sp_adjust
= read_memory_unsigned_integer (pc
+ 1, 2);
491 if (sp_adjust
& 0x8000)
492 sp_adjust
|= 0xffff0000L
;
494 sp_adjust
= -sp_adjust
;
498 else if (add_sp_mode
== (1 | 4) && op0
== OP_XGDX
505 else if (add_sp_mode
== (2 | 4) && op0
== OP_PAGE2
506 && op1
== OP_XGDY
&& op2
== OP_PAGE2
)
508 op0
= read_memory_unsigned_integer (pc
+ 3, 1);
522 if (found_frame_point
== 0)
528 *frame_offset
= size
;
531 /* Now, look forward to see how many registers are pushed on the stack.
532 We look only for soft registers so there must be a first LDX *REG
536 while (pc
+ 2 < func_end
)
538 op0
= read_memory_unsigned_integer (pc
, 1);
539 op1
= read_memory_unsigned_integer (pc
+ 1, 1);
540 op2
= read_memory_unsigned_integer (pc
+ 2, 1);
543 saved_reg
= m68hc11_which_soft_register (op1
);
544 if (saved_reg
< 0 || saved_reg
== SOFT_FP_REGNUM
)
549 else if (op0
== OP_PAGE2
&& op1
== OP_LDY
)
551 saved_reg
= m68hc11_which_soft_register (op2
);
552 if (saved_reg
< 0 || saved_reg
== SOFT_FP_REGNUM
)
557 else if (op0
== OP_PSHX
)
559 /* If there was no load, this is a push for a function call. */
560 if (saved_reg
< 0 || saved_reg
>= M68HC11_ALL_REGS
)
563 /* Keep track of the address where that register is saved
567 pushed_regs
[saved_reg
] = save_addr
;
572 else if (op0
== OP_PAGE2
&& op1
== OP_PSHY
)
574 if (saved_reg
< 0 || saved_reg
>= M68HC11_ALL_REGS
)
577 /* Keep track of the address where that register is saved
581 pushed_regs
[saved_reg
] = save_addr
;
595 m68hc11_skip_prologue (CORE_ADDR pc
)
597 CORE_ADDR func_addr
, func_end
;
598 struct symtab_and_line sal
;
601 /* If we have line debugging information, then the end of the
602 prologue should be the first assembly instruction of the
603 first source line. */
604 if (find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
606 sal
= find_pc_line (func_addr
, 0);
607 if (sal
.end
&& sal
.end
< func_end
)
611 m68hc11_guess_from_prologue (pc
, 0, &pc
, &frame_offset
, 0);
615 /* Given a GDB frame, determine the address of the calling function's frame.
616 This will be used to create a new GDB frame struct, and then
617 INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
621 m68hc11_frame_chain (struct frame_info
*frame
)
625 if (PC_IN_CALL_DUMMY (frame
->pc
, frame
->frame
, frame
->frame
))
626 return frame
->frame
; /* dummy frame same as caller's frame */
628 if (frame
->extra_info
->return_pc
== 0
629 || inside_entry_file (frame
->extra_info
->return_pc
))
630 return (CORE_ADDR
) 0;
632 if (frame
->frame
== 0)
634 return (CORE_ADDR
) 0;
637 addr
= frame
->frame
+ frame
->extra_info
->size
+ stack_correction
- 2;
638 addr
= read_memory_unsigned_integer (addr
, 2) & 0x0FFFF;
641 return (CORE_ADDR
) 0;
647 /* Put here the code to store, into a struct frame_saved_regs, the
648 addresses of the saved registers of frame described by FRAME_INFO.
649 This includes special registers such as pc and fp saved in special
650 ways in the stack frame. sp is even more special: the address we
651 return for it IS the sp for the next frame. */
653 m68hc11_frame_init_saved_regs (struct frame_info
*fi
)
658 if (fi
->saved_regs
== NULL
)
659 frame_saved_regs_zalloc (fi
);
661 memset (fi
->saved_regs
, 0, sizeof (fi
->saved_regs
));
664 m68hc11_guess_from_prologue (pc
, fi
->frame
, &pc
, &fi
->extra_info
->size
,
667 addr
= fi
->frame
+ fi
->extra_info
->size
+ stack_correction
;
668 fi
->saved_regs
[SOFT_FP_REGNUM
] = addr
- 2;
669 fi
->saved_regs
[HARD_SP_REGNUM
] = addr
;
670 fi
->saved_regs
[HARD_PC_REGNUM
] = fi
->saved_regs
[HARD_SP_REGNUM
];
674 m68hc11_init_extra_frame_info (int fromleaf
, struct frame_info
*fi
)
678 fi
->extra_info
= (struct frame_extra_info
*)
679 frame_obstack_alloc (sizeof (struct frame_extra_info
));
682 fi
->pc
= FRAME_SAVED_PC (fi
->next
);
684 m68hc11_frame_init_saved_regs (fi
);
688 fi
->extra_info
->return_pc
= m68hc11_saved_pc_after_call (fi
);
692 addr
= fi
->frame
+ fi
->extra_info
->size
+ stack_correction
;
693 addr
= read_memory_unsigned_integer (addr
, 2) & 0x0ffff;
694 fi
->extra_info
->return_pc
= addr
;
696 printf ("Pc@0x%04x, FR 0x%04x, size %d, read ret @0x%04x -> 0x%04x\n",
705 /* Same as 'info reg' but prints the registers in a different way. */
707 show_regs (char *args
, int from_tty
)
709 int ccr
= read_register (HARD_CCR_REGNUM
);
713 printf_filtered ("PC=%04x SP=%04x FP=%04x CCR=%02x %c%c%c%c%c%c%c%c\n",
714 (int) read_register (HARD_PC_REGNUM
),
715 (int) read_register (HARD_SP_REGNUM
),
716 (int) read_register (SOFT_FP_REGNUM
),
718 ccr
& M6811_S_BIT
? 'S' : '-',
719 ccr
& M6811_X_BIT
? 'X' : '-',
720 ccr
& M6811_H_BIT
? 'H' : '-',
721 ccr
& M6811_I_BIT
? 'I' : '-',
722 ccr
& M6811_N_BIT
? 'N' : '-',
723 ccr
& M6811_Z_BIT
? 'Z' : '-',
724 ccr
& M6811_V_BIT
? 'V' : '-',
725 ccr
& M6811_C_BIT
? 'C' : '-');
727 printf_filtered ("D=%04x IX=%04x IY=%04x\n",
728 (int) read_register (HARD_D_REGNUM
),
729 (int) read_register (HARD_X_REGNUM
),
730 (int) read_register (HARD_Y_REGNUM
));
733 for (i
= SOFT_D1_REGNUM
; i
< M68HC11_ALL_REGS
; i
++)
735 /* Skip registers which are not defined in the symbol table. */
736 if (soft_regs
[i
].name
== 0)
739 printf_filtered ("D%d=%04x",
740 i
- SOFT_D1_REGNUM
+ 1,
741 (int) read_register (i
));
744 printf_filtered ("\n");
746 printf_filtered (" ");
748 if (nr
&& (nr
% 8) != 7)
749 printf_filtered ("\n");
753 m68hc11_stack_align (CORE_ADDR addr
)
755 return ((addr
+ 1) & -2);
759 m68hc11_push_arguments (int nargs
,
763 CORE_ADDR struct_addr
)
767 int first_stack_argnum
;
774 first_stack_argnum
= 0;
777 /* The struct is allocated on the stack and gdb used the stack
778 pointer for the address of that struct. We must apply the
779 stack offset on the address. */
780 write_register (HARD_D_REGNUM
, struct_addr
+ stack_correction
);
784 type
= VALUE_TYPE (args
[0]);
785 len
= TYPE_LENGTH (type
);
787 /* First argument is passed in D and X registers. */
790 LONGEST v
= extract_unsigned_integer (VALUE_CONTENTS (args
[0]), len
);
791 first_stack_argnum
= 1;
792 write_register (HARD_D_REGNUM
, v
);
796 write_register (HARD_X_REGNUM
, v
);
800 for (argnum
= first_stack_argnum
; argnum
< nargs
; argnum
++)
802 type
= VALUE_TYPE (args
[argnum
]);
803 stack_alloc
+= (TYPE_LENGTH (type
) + 1) & -2;
807 stack_offset
= stack_correction
;
808 for (argnum
= first_stack_argnum
; argnum
< nargs
; argnum
++)
810 type
= VALUE_TYPE (args
[argnum
]);
811 len
= TYPE_LENGTH (type
);
813 val
= (char*) VALUE_CONTENTS (args
[argnum
]);
814 write_memory (sp
+ stack_offset
, val
, len
);
818 static char zero
= 0;
820 write_memory (sp
+ stack_offset
, &zero
, 1);
828 /* Return a location where we can set a breakpoint that will be hit
829 when an inferior function call returns. */
831 m68hc11_call_dummy_address (void)
833 return entry_point_address ();
837 m68hc11_register_virtual_type (int reg_nr
)
839 return builtin_type_uint16
;
843 m68hc11_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
845 /* The struct address computed by gdb is on the stack.
846 It uses the stack pointer so we must apply the stack
847 correction offset. */
848 write_register (HARD_D_REGNUM
, addr
+ stack_correction
);
852 m68hc11_store_return_value (struct type
*type
, char *valbuf
)
856 len
= TYPE_LENGTH (type
);
858 /* First argument is passed in D and X registers. */
861 LONGEST v
= extract_unsigned_integer (valbuf
, len
);
863 write_register (HARD_D_REGNUM
, v
);
867 write_register (HARD_X_REGNUM
, v
);
871 error ("return of value > 4 is not supported.");
875 /* Given a return value in `regbuf' with a type `type',
876 extract and copy its value into `valbuf'. */
879 m68hc11_extract_return_value (struct type
*type
,
883 int len
= TYPE_LENGTH (type
);
888 memcpy (valbuf
, ®buf
[HARD_D_REGNUM
* 2 + 1], len
);
892 memcpy (valbuf
, ®buf
[HARD_D_REGNUM
* 2], len
);
896 memcpy (&valbuf
[0], ®buf
[HARD_X_REGNUM
* 2 + 1], 1);
897 memcpy (&valbuf
[1], ®buf
[HARD_D_REGNUM
* 2], 2);
901 memcpy (&valbuf
[0], ®buf
[HARD_X_REGNUM
* 2], 2);
902 memcpy (&valbuf
[2], ®buf
[HARD_D_REGNUM
* 2], 2);
906 error ("bad size for return value");
910 /* Should call_function allocate stack space for a struct return? */
912 m68hc11_use_struct_convention (int gcc_p
, struct type
*type
)
914 return (TYPE_CODE (type
) == TYPE_CODE_STRUCT
915 || TYPE_CODE (type
) == TYPE_CODE_UNION
916 || TYPE_LENGTH (type
) > 4);
920 m68hc11_return_value_on_stack (struct type
*type
)
922 return TYPE_LENGTH (type
) > 4;
925 /* Extract from an array REGBUF containing the (raw) register state
926 the address in which a function should return its structure value,
927 as a CORE_ADDR (or an expression that can be used as one). */
929 m68hc11_extract_struct_value_address (char *regbuf
)
931 return extract_address (®buf
[HARD_D_REGNUM
* 2],
932 REGISTER_RAW_SIZE (HARD_D_REGNUM
));
935 /* Function: push_return_address (pc)
936 Set up the return address for the inferior function call.
937 Needed for targets where we don't actually execute a JSR/BSR instruction */
940 m68hc11_push_return_address (CORE_ADDR pc
, CORE_ADDR sp
)
944 pc
= CALL_DUMMY_ADDRESS ();
946 store_unsigned_integer (valbuf
, 2, pc
);
947 write_memory (sp
+ stack_correction
, valbuf
, 2);
951 /* Index within `registers' of the first byte of the space for
954 m68hc11_register_byte (int reg_nr
)
956 return (reg_nr
* M68HC11_REG_SIZE
);
960 m68hc11_register_raw_size (int reg_nr
)
962 return M68HC11_REG_SIZE
;
965 static struct gdbarch
*
966 m68hc11_gdbarch_init (struct gdbarch_info info
,
967 struct gdbarch_list
*arches
)
969 static LONGEST m68hc11_call_dummy_words
[] =
971 struct gdbarch
*gdbarch
;
972 struct gdbarch_tdep
*tdep
;
975 /* Extract the elf_flags if available */
978 soft_reg_initialized
= 0;
980 /* try to find a pre-existing architecture */
981 for (arches
= gdbarch_list_lookup_by_info (arches
, &info
);
983 arches
= gdbarch_list_lookup_by_info (arches
->next
, &info
))
985 /* MIPS needs to be pedantic about which ABI the object is
987 if (gdbarch_tdep (current_gdbarch
)->elf_flags
!= elf_flags
)
989 return arches
->gdbarch
;
992 /* Need a new architecture. Fill in a target specific vector. */
993 tdep
= (struct gdbarch_tdep
*) xmalloc (sizeof (struct gdbarch_tdep
));
994 gdbarch
= gdbarch_alloc (&info
, tdep
);
995 tdep
->elf_flags
= elf_flags
;
997 /* Initially set everything according to the ABI. */
998 set_gdbarch_short_bit (gdbarch
, 16);
999 set_gdbarch_int_bit (gdbarch
, 32);
1000 set_gdbarch_float_bit (gdbarch
, 32);
1001 set_gdbarch_double_bit (gdbarch
, 64);
1002 set_gdbarch_long_double_bit (gdbarch
, 64);
1003 set_gdbarch_long_bit (gdbarch
, 32);
1004 set_gdbarch_ptr_bit (gdbarch
, 16);
1005 set_gdbarch_long_long_bit (gdbarch
, 64);
1007 /* Set register info. */
1008 set_gdbarch_fp0_regnum (gdbarch
, -1);
1009 set_gdbarch_max_register_raw_size (gdbarch
, 2);
1010 set_gdbarch_max_register_virtual_size (gdbarch
, 2);
1011 set_gdbarch_register_raw_size (gdbarch
, m68hc11_register_raw_size
);
1012 set_gdbarch_register_virtual_size (gdbarch
, m68hc11_register_raw_size
);
1013 set_gdbarch_register_byte (gdbarch
, m68hc11_register_byte
);
1014 set_gdbarch_frame_init_saved_regs (gdbarch
, m68hc11_frame_init_saved_regs
);
1015 set_gdbarch_frame_args_skip (gdbarch
, 0);
1017 set_gdbarch_read_pc (gdbarch
, generic_target_read_pc
);
1018 set_gdbarch_write_pc (gdbarch
, generic_target_write_pc
);
1019 set_gdbarch_read_fp (gdbarch
, generic_target_read_fp
);
1020 set_gdbarch_write_fp (gdbarch
, generic_target_write_fp
);
1021 set_gdbarch_read_sp (gdbarch
, generic_target_read_sp
);
1022 set_gdbarch_write_sp (gdbarch
, generic_target_write_sp
);
1024 set_gdbarch_num_regs (gdbarch
, M68HC11_NUM_REGS
);
1025 set_gdbarch_num_pseudo_regs (gdbarch
, M68HC11_NUM_PSEUDO_REGS
);
1026 set_gdbarch_sp_regnum (gdbarch
, HARD_SP_REGNUM
);
1027 set_gdbarch_fp_regnum (gdbarch
, SOFT_FP_REGNUM
);
1028 set_gdbarch_pc_regnum (gdbarch
, HARD_PC_REGNUM
);
1029 set_gdbarch_register_name (gdbarch
, m68hc11_register_name
);
1030 set_gdbarch_register_size (gdbarch
, 2);
1031 set_gdbarch_register_bytes (gdbarch
, M68HC11_ALL_REGS
* 2);
1032 set_gdbarch_register_virtual_type (gdbarch
, m68hc11_register_virtual_type
);
1033 set_gdbarch_fetch_pseudo_register (gdbarch
, m68hc11_fetch_pseudo_register
);
1034 set_gdbarch_store_pseudo_register (gdbarch
, m68hc11_store_pseudo_register
);
1036 set_gdbarch_use_generic_dummy_frames (gdbarch
, 1);
1037 set_gdbarch_call_dummy_length (gdbarch
, 0);
1038 set_gdbarch_call_dummy_location (gdbarch
, AT_ENTRY_POINT
);
1039 set_gdbarch_call_dummy_address (gdbarch
, m68hc11_call_dummy_address
);
1040 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch
, 1); /*???*/
1041 set_gdbarch_call_dummy_breakpoint_offset (gdbarch
, 0);
1042 set_gdbarch_call_dummy_start_offset (gdbarch
, 0);
1043 set_gdbarch_pc_in_call_dummy (gdbarch
, generic_pc_in_call_dummy
);
1044 set_gdbarch_call_dummy_words (gdbarch
, m68hc11_call_dummy_words
);
1045 set_gdbarch_sizeof_call_dummy_words (gdbarch
,
1046 sizeof (m68hc11_call_dummy_words
));
1047 set_gdbarch_call_dummy_p (gdbarch
, 1);
1048 set_gdbarch_call_dummy_stack_adjust_p (gdbarch
, 0);
1049 set_gdbarch_get_saved_register (gdbarch
, generic_get_saved_register
);
1050 set_gdbarch_fix_call_dummy (gdbarch
, generic_fix_call_dummy
);
1051 set_gdbarch_extract_return_value (gdbarch
, m68hc11_extract_return_value
);
1052 set_gdbarch_push_arguments (gdbarch
, m68hc11_push_arguments
);
1053 set_gdbarch_push_dummy_frame (gdbarch
, generic_push_dummy_frame
);
1054 set_gdbarch_push_return_address (gdbarch
, m68hc11_push_return_address
);
1055 set_gdbarch_return_value_on_stack (gdbarch
, m68hc11_return_value_on_stack
);
1057 set_gdbarch_store_struct_return (gdbarch
, m68hc11_store_struct_return
);
1058 set_gdbarch_store_return_value (gdbarch
, m68hc11_store_return_value
);
1059 set_gdbarch_extract_struct_value_address (gdbarch
,
1060 m68hc11_extract_struct_value_address
);
1061 set_gdbarch_register_convertible (gdbarch
, generic_register_convertible_not
);
1064 set_gdbarch_frame_chain (gdbarch
, m68hc11_frame_chain
);
1065 set_gdbarch_frame_chain_valid (gdbarch
, generic_file_frame_chain_valid
);
1066 set_gdbarch_frame_saved_pc (gdbarch
, m68hc11_frame_saved_pc
);
1067 set_gdbarch_frame_args_address (gdbarch
, m68hc11_frame_args_address
);
1068 set_gdbarch_frame_locals_address (gdbarch
, m68hc11_frame_locals_address
);
1069 set_gdbarch_saved_pc_after_call (gdbarch
, m68hc11_saved_pc_after_call
);
1070 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
1072 set_gdbarch_frame_chain_valid (gdbarch
, func_frame_chain_valid
);
1073 set_gdbarch_get_saved_register (gdbarch
, generic_get_saved_register
);
1075 set_gdbarch_store_struct_return (gdbarch
, m68hc11_store_struct_return
);
1076 set_gdbarch_store_return_value (gdbarch
, m68hc11_store_return_value
);
1077 set_gdbarch_extract_struct_value_address
1078 (gdbarch
, m68hc11_extract_struct_value_address
);
1079 set_gdbarch_use_struct_convention (gdbarch
, m68hc11_use_struct_convention
);
1080 set_gdbarch_init_extra_frame_info (gdbarch
, m68hc11_init_extra_frame_info
);
1081 set_gdbarch_pop_frame (gdbarch
, m68hc11_pop_frame
);
1082 set_gdbarch_skip_prologue (gdbarch
, m68hc11_skip_prologue
);
1083 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1084 set_gdbarch_decr_pc_after_break (gdbarch
, 0);
1085 set_gdbarch_function_start_offset (gdbarch
, 0);
1086 set_gdbarch_breakpoint_from_pc (gdbarch
, m68hc11_breakpoint_from_pc
);
1087 set_gdbarch_stack_align (gdbarch
, m68hc11_stack_align
);
1089 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
1090 set_gdbarch_ieee_float (gdbarch
, 1);
1096 _initialize_m68hc11_tdep (void)
1098 register_gdbarch_init (bfd_arch_m68hc11
, m68hc11_gdbarch_init
);
1099 if (!tm_print_insn
) /* Someone may have already set it */
1100 tm_print_insn
= print_insn_m68hc11
;
1102 add_com ("regs", class_vars
, show_regs
, "Print all registers");