1 /* Target-dependent code for Hitachi H8/500, for GDB.
3 Copyright 1993, 1994, 1995, 1998, 2000, 2001, 2002 Free Software
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 Contributed by Steve Chamberlain
38 #define UNSIGNED_SHORT(X) ((X) & 0xffff)
40 static int code_size
= 2;
42 static int data_size
= 2;
44 /* Shape of an H8/500 frame :
50 return address <2 or 4 bytes>
59 /* an easy to debug H8 stack frame looks like:
63 0x7905 nnnn mov.w #n,r5 or 0x1b87 subs #2,sp
68 #define IS_PUSH(x) (((x) & 0xff00)==0x6d00)
69 #define IS_LINK_8(x) ((x) == 0x17)
70 #define IS_LINK_16(x) ((x) == 0x1f)
71 #define IS_MOVE_FP(x) ((x) == 0x0d76)
72 #define IS_MOV_SP_FP(x) ((x) == 0x0d76)
73 #define IS_SUB2_SP(x) ((x) == 0x1b87)
74 #define IS_MOVK_R5(x) ((x) == 0x7905)
75 #define IS_SUB_R5SP(x) ((x) == 0x1957)
83 h8500_skip_prologue (CORE_ADDR start_pc
)
87 w
= read_memory_integer (start_pc
, 1);
91 w
= read_memory_integer (start_pc
, 1);
97 w
= read_memory_integer (start_pc
, 2);
104 h8500_addr_bits_remove (CORE_ADDR addr
)
106 return ((addr
) & 0xffffff);
109 /* Given a GDB frame, determine the address of the calling function's frame.
110 This will be used to create a new GDB frame struct, and then
111 INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
113 For us, the frame address is its stack pointer value, so we look up
114 the function prologue to determine the caller's sp value, and return it. */
117 h8500_frame_chain (struct frame_info
*thisframe
)
119 if (!inside_entry_file (thisframe
->pc
))
120 return (read_memory_integer (get_frame_base (thisframe
), PTR_SIZE
));
125 /* Fetch the instruction at ADDR, returning 0 if ADDR is beyond LIM or
126 is not the address of a valid instruction, the address of the next
127 instruction beyond ADDR otherwise. *PWORD1 receives the first word
128 of the instruction. */
131 NEXT_PROLOGUE_INSN (CORE_ADDR addr
, CORE_ADDR lim
, char *pword1
)
135 read_memory (addr
, pword1
, 1);
136 read_memory (addr
, pword1
+ 1, 1);
142 /* Examine the prologue of a function. `ip' points to the first
143 instruction. `limit' is the limit of the prologue (e.g. the addr
144 of the first linenumber, or perhaps the program counter if we're
145 stepping through). `frame_sp' is the stack pointer value in use in
146 this frame. `fsr' is a pointer to a frame_saved_regs structure
147 into which we put info about the registers saved by this frame.
148 `fi' is a struct frame_info pointer; we fill in various fields in
149 it to reflect the offsets of the arg pointer and the locals
152 /* Return the saved PC from this frame. */
155 frame_saved_pc (struct frame_info
*frame
)
157 return read_memory_integer (get_frame_base (frame
) + 2, PTR_SIZE
);
161 h8500_pop_frame (void)
164 struct frame_saved_regs fsr
;
165 struct frame_info
*frame
= get_current_frame ();
167 get_frame_saved_regs (frame
, &fsr
);
169 for (regnum
= 0; regnum
< 8; regnum
++)
171 if (fsr
.regs
[regnum
])
172 write_register (regnum
, read_memory_short (fsr
.regs
[regnum
]));
174 flush_cached_frames ();
179 h8500_print_register_hook (int regno
)
181 if (regno
== CCR_REGNUM
)
189 frame_register_read (deprecated_selected_frame
, regno
, b
);
191 printf_unfiltered ("\t");
192 printf_unfiltered ("I-%d - ", (l
& 0x80) != 0);
197 printf_unfiltered ("N-%d ", N
);
198 printf_unfiltered ("Z-%d ", Z
);
199 printf_unfiltered ("V-%d ", V
);
200 printf_unfiltered ("C-%d ", C
);
202 printf_unfiltered ("u> ");
204 printf_unfiltered ("u<= ");
206 printf_unfiltered ("u>= ");
208 printf_unfiltered ("u< ");
210 printf_unfiltered ("!= ");
212 printf_unfiltered ("== ");
214 printf_unfiltered (">= ");
216 printf_unfiltered ("< ");
217 if ((Z
| (N
^ V
)) == 0)
218 printf_unfiltered ("> ");
219 if ((Z
| (N
^ V
)) == 1)
220 printf_unfiltered ("<= ");
225 h8500_print_registers_info (struct gdbarch
*gdbarch
,
226 struct ui_file
*file
,
227 struct frame_info
*frame
,
228 int regnum
, int print_all
)
231 const int numregs
= NUM_REGS
+ NUM_PSEUDO_REGS
;
232 char *raw_buffer
= alloca (MAX_REGISTER_RAW_SIZE
);
233 char *virtual_buffer
= alloca (MAX_REGISTER_VIRTUAL_SIZE
);
235 for (i
= 0; i
< numregs
; i
++)
237 /* Decide between printing all regs, non-float / vector regs, or
243 if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i
)) == TYPE_CODE_FLT
)
245 if (TYPE_VECTOR (REGISTER_VIRTUAL_TYPE (i
)))
255 /* If the register name is empty, it is undefined for this
256 processor, so don't display anything. */
257 if (REGISTER_NAME (i
) == NULL
|| *(REGISTER_NAME (i
)) == '\0')
260 fputs_filtered (REGISTER_NAME (i
), file
);
261 print_spaces_filtered (15 - strlen (REGISTER_NAME (i
)), file
);
263 /* Get the data in raw format. */
264 if (! frame_register_read (frame
, i
, raw_buffer
))
266 fprintf_filtered (file
, "*value not available*\n");
270 /* FIXME: cagney/2002-08-03: This code shouldn't be necessary.
271 The function frame_register_read() should have returned the
272 pre-cooked register so no conversion is necessary. */
273 /* Convert raw data to virtual format if necessary. */
274 if (REGISTER_CONVERTIBLE (i
))
276 REGISTER_CONVERT_TO_VIRTUAL (i
, REGISTER_VIRTUAL_TYPE (i
),
277 raw_buffer
, virtual_buffer
);
281 memcpy (virtual_buffer
, raw_buffer
,
282 REGISTER_VIRTUAL_SIZE (i
));
285 /* If virtual format is floating, print it that way, and in raw
287 if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i
)) == TYPE_CODE_FLT
)
291 val_print (REGISTER_VIRTUAL_TYPE (i
), virtual_buffer
, 0, 0,
292 file
, 0, 1, 0, Val_pretty_default
);
294 fprintf_filtered (file
, "\t(raw 0x");
295 for (j
= 0; j
< REGISTER_RAW_SIZE (i
); j
++)
298 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
301 idx
= REGISTER_RAW_SIZE (i
) - 1 - j
;
302 fprintf_filtered (file
, "%02x", (unsigned char) raw_buffer
[idx
]);
304 fprintf_filtered (file
, ")");
308 /* Print the register in hex. */
309 val_print (REGISTER_VIRTUAL_TYPE (i
), virtual_buffer
, 0, 0,
310 file
, 'x', 1, 0, Val_pretty_default
);
311 /* If not a vector register, print it also according to its
313 if (TYPE_VECTOR (REGISTER_VIRTUAL_TYPE (i
)) == 0)
315 fprintf_filtered (file
, "\t");
316 val_print (REGISTER_VIRTUAL_TYPE (i
), virtual_buffer
, 0, 0,
317 file
, 0, 1, 0, Val_pretty_default
);
321 /* Some h8500 specific info. */
322 h8500_print_register_hook (i
);
324 fprintf_filtered (file
, "\n");
329 h8500_do_registers_info (int regnum
, int all
)
331 h8500_print_registers_info (current_gdbarch
, gdb_stdout
, deprecated_selected_frame
,
336 h8500_register_size (int regno
)
367 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
372 h8500_register_virtual_type (int regno
)
380 return builtin_type_unsigned_char
;
390 return builtin_type_unsigned_short
;
400 return builtin_type_unsigned_long
;
402 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
406 /* Put here the code to store, into a struct frame_saved_regs,
407 the addresses of the saved registers of frame described by FRAME_INFO.
408 This includes special registers such as pc and fp saved in special
409 ways in the stack frame. sp is even more special:
410 the address we return for it IS the sp for the next frame. */
413 frame_find_saved_regs (struct frame_info
*frame_info
,
414 struct frame_saved_regs
*frame_saved_regs
)
417 register int regmask
;
418 register CORE_ADDR next_addr
;
419 register CORE_ADDR pc
;
420 unsigned char thebyte
;
422 memset (frame_saved_regs
, '\0', sizeof *frame_saved_regs
);
424 if ((frame_info
)->pc
>= (frame_info
)->frame
- CALL_DUMMY_LENGTH
- FP_REGNUM
* 4 - 4
425 && (frame_info
)->pc
<= (frame_info
)->frame
)
427 next_addr
= (frame_info
)->frame
;
428 pc
= (frame_info
)->frame
- CALL_DUMMY_LENGTH
- FP_REGNUM
* 4 - 4;
432 pc
= get_pc_function_start ((frame_info
)->pc
);
433 /* Verify we have a link a6 instruction next;
434 if not we lose. If we win, find the address above the saved
435 regs using the amount of storage from the link instruction.
438 thebyte
= read_memory_integer (pc
, 1);
440 next_addr
= (frame_info
)->frame
+ read_memory_integer (pc
+= 1, 2), pc
+= 2;
441 else if (0x17 == thebyte
)
442 next_addr
= (frame_info
)->frame
+ read_memory_integer (pc
+= 1, 1), pc
+= 1;
447 /* If have an add:g.waddal #-n, sp next, adjust next_addr. */
448 if ((0x0c0177777 & read_memory_integer (pc
, 2)) == 0157774)
449 next_addr
+= read_memory_integer (pc
+= 2, 4), pc
+= 4;
453 thebyte
= read_memory_integer (pc
, 1);
458 regmask
= read_memory_integer (pc
, 1);
460 for (regnum
= 0; regnum
< 8; regnum
++, regmask
>>= 1)
464 (frame_saved_regs
)->regs
[regnum
] = (next_addr
+= 2) - 2;
467 thebyte
= read_memory_integer (pc
, 1);
469 /* Maybe got a load of pushes */
470 while (thebyte
== 0xbf)
473 regnum
= read_memory_integer (pc
, 1) & 0x7;
475 (frame_saved_regs
)->regs
[regnum
] = (next_addr
+= 2) - 2;
476 thebyte
= read_memory_integer (pc
, 1);
481 /* Remember the address of the frame pointer */
482 (frame_saved_regs
)->regs
[FP_REGNUM
] = (frame_info
)->frame
;
484 /* This is where the old sp is hidden */
485 (frame_saved_regs
)->regs
[SP_REGNUM
] = (frame_info
)->frame
;
487 /* And the PC - remember the pushed FP is always two bytes long */
488 (frame_saved_regs
)->regs
[PC_REGNUM
] = (frame_info
)->frame
+ 2;
492 saved_pc_after_call (void)
495 int a
= read_register (SP_REGNUM
);
497 x
= read_memory_integer (a
, code_size
);
500 /* Stick current code segement onto top */
502 x
|= read_register (SEG_C_REGNUM
) << 16;
509 h8500_set_pointer_size (int newsize
)
511 static int oldsize
= 0;
513 if (oldsize
!= newsize
)
515 printf_unfiltered ("pointer size set to %d bits\n", newsize
);
525 _initialize_gdbtypes ();
530 big_command (char *arg
, int from_tty
)
532 h8500_set_pointer_size (32);
538 medium_command (char *arg
, int from_tty
)
540 h8500_set_pointer_size (32);
546 compact_command (char *arg
, int from_tty
)
548 h8500_set_pointer_size (32);
554 small_command (char *arg
, int from_tty
)
556 h8500_set_pointer_size (16);
561 static struct cmd_list_element
*setmemorylist
;
564 set_memory (char *args
, int from_tty
)
566 printf_unfiltered ("\"set memory\" must be followed by the name of a memory subcommand.\n");
567 help_list (setmemorylist
, "set memory ", -1, gdb_stdout
);
570 /* See if variable name is ppc or pr[0-7] */
573 h8500_is_trapped_internalvar (char *name
)
578 if (strcmp (name
+ 1, "pc") == 0)
584 && name
[3] == '\000')
591 h8500_value_of_trapped_internalvar (struct internalvar
*var
)
594 unsigned char regbuf
[4];
595 int page_regnum
, regnum
;
597 regnum
= var
->name
[2] == 'c' ? PC_REGNUM
: var
->name
[2] - '0';
599 switch (var
->name
[2])
602 page_regnum
= SEG_C_REGNUM
;
608 page_regnum
= SEG_D_REGNUM
;
612 page_regnum
= SEG_E_REGNUM
;
616 page_regnum
= SEG_T_REGNUM
;
620 get_saved_register (regbuf
, NULL
, NULL
, deprecated_selected_frame
, page_regnum
, NULL
);
621 regval
= regbuf
[0] << 16;
623 get_saved_register (regbuf
, NULL
, NULL
, deprecated_selected_frame
, regnum
, NULL
);
624 regval
|= regbuf
[0] << 8 | regbuf
[1]; /* XXX host/target byte order */
626 xfree (var
->value
); /* Free up old value */
628 var
->value
= value_from_longest (builtin_type_unsigned_long
, regval
);
629 release_value (var
->value
); /* Unchain new value */
631 VALUE_LVAL (var
->value
) = lval_internalvar
;
632 VALUE_INTERNALVAR (var
->value
) = var
;
637 h8500_set_trapped_internalvar (struct internalvar
*var
, struct value
*newval
,
638 int bitpos
, int bitsize
, int offset
)
640 char *page_regnum
, *regnum
;
641 char expression
[100];
644 enum type_code newval_type_code
;
646 type
= check_typedef (VALUE_TYPE (newval
));
647 newval_type_code
= TYPE_CODE (type
);
649 if ((newval_type_code
!= TYPE_CODE_INT
650 && newval_type_code
!= TYPE_CODE_PTR
)
651 || TYPE_LENGTH (type
) != sizeof (new_regval
))
652 error ("Illegal type (%s) for assignment to $%s\n",
653 TYPE_NAME (VALUE_TYPE (newval
)), var
->name
);
655 new_regval
= *(long *) VALUE_CONTENTS_RAW (newval
);
657 regnum
= var
->name
+ 1;
659 switch (var
->name
[2])
680 sprintf (expression
, "$%s=%d", page_regnum
, new_regval
>> 16);
681 parse_and_eval (expression
);
683 sprintf (expression
, "$%s=%d", regnum
, new_regval
& 0xffff);
684 parse_and_eval (expression
);
690 return read_register (PR7_REGNUM
);
694 h8500_write_sp (CORE_ADDR v
)
696 write_register (PR7_REGNUM
, v
);
700 h8500_read_pc (ptid_t ptid
)
702 return read_register (PC_REGNUM
);
706 h8500_write_pc (CORE_ADDR v
, ptid_t ptid
)
708 write_register (PC_REGNUM
, v
);
714 return read_register (PR6_REGNUM
);
718 _initialize_h8500_tdep (void)
720 tm_print_insn
= print_insn_h8500
;
722 add_prefix_cmd ("memory", no_class
, set_memory
,
723 "set the memory model", &setmemorylist
, "set memory ", 0,
726 add_cmd ("small", class_support
, small_command
,
727 "Set small memory model. (16 bit code, 16 bit data)", &setmemorylist
);
729 add_cmd ("big", class_support
, big_command
,
730 "Set big memory model. (32 bit code, 32 bit data)", &setmemorylist
);
732 add_cmd ("medium", class_support
, medium_command
,
733 "Set medium memory model. (32 bit code, 16 bit data)", &setmemorylist
);
735 add_cmd ("compact", class_support
, compact_command
,
736 "Set compact memory model. (16 bit code, 32 bit data)", &setmemorylist
);