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
39 #define UNSIGNED_SHORT(X) ((X) & 0xffff)
41 static int code_size
= 2;
43 static int data_size
= 2;
45 /* Shape of an H8/500 frame :
51 return address <2 or 4 bytes>
60 /* an easy to debug H8 stack frame looks like:
64 0x7905 nnnn mov.w #n,r5 or 0x1b87 subs #2,sp
69 #define IS_PUSH(x) (((x) & 0xff00)==0x6d00)
70 #define IS_LINK_8(x) ((x) == 0x17)
71 #define IS_LINK_16(x) ((x) == 0x1f)
72 #define IS_MOVE_FP(x) ((x) == 0x0d76)
73 #define IS_MOV_SP_FP(x) ((x) == 0x0d76)
74 #define IS_SUB2_SP(x) ((x) == 0x1b87)
75 #define IS_MOVK_R5(x) ((x) == 0x7905)
76 #define IS_SUB_R5SP(x) ((x) == 0x1957)
84 h8500_skip_prologue (CORE_ADDR start_pc
)
88 w
= read_memory_integer (start_pc
, 1);
92 w
= read_memory_integer (start_pc
, 1);
98 w
= read_memory_integer (start_pc
, 2);
105 h8500_addr_bits_remove (CORE_ADDR addr
)
107 return ((addr
) & 0xffffff);
110 /* Given a GDB frame, determine the address of the calling function's frame.
111 This will be used to create a new GDB frame struct, and then
112 INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
114 For us, the frame address is its stack pointer value, so we look up
115 the function prologue to determine the caller's sp value, and return it. */
118 h8500_frame_chain (struct frame_info
*thisframe
)
120 if (!inside_entry_file (thisframe
->pc
))
121 return (read_memory_integer (FRAME_FP (thisframe
), PTR_SIZE
));
126 /* Fetch the instruction at ADDR, returning 0 if ADDR is beyond LIM or
127 is not the address of a valid instruction, the address of the next
128 instruction beyond ADDR otherwise. *PWORD1 receives the first word
129 of the instruction. */
132 NEXT_PROLOGUE_INSN (CORE_ADDR addr
, CORE_ADDR lim
, char *pword1
)
136 read_memory (addr
, pword1
, 1);
137 read_memory (addr
, pword1
+ 1, 1);
143 /* Examine the prologue of a function. `ip' points to the first
144 instruction. `limit' is the limit of the prologue (e.g. the addr
145 of the first linenumber, or perhaps the program counter if we're
146 stepping through). `frame_sp' is the stack pointer value in use in
147 this frame. `fsr' is a pointer to a frame_saved_regs structure
148 into which we put info about the registers saved by this frame.
149 `fi' is a struct frame_info pointer; we fill in various fields in
150 it to reflect the offsets of the arg pointer and the locals
153 /* Return the saved PC from this frame. */
156 frame_saved_pc (struct frame_info
*frame
)
158 return read_memory_integer (FRAME_FP (frame
) + 2, PTR_SIZE
);
162 h8500_pop_frame (void)
165 struct frame_saved_regs fsr
;
166 struct frame_info
*frame
= get_current_frame ();
168 get_frame_saved_regs (frame
, &fsr
);
170 for (regnum
= 0; regnum
< 8; regnum
++)
172 if (fsr
.regs
[regnum
])
173 write_register (regnum
, read_memory_short (fsr
.regs
[regnum
]));
175 flush_cached_frames ();
180 print_register_hook (int regno
)
182 if (regno
== CCR_REGNUM
)
190 frame_register_read (selected_frame
, regno
, b
);
192 printf_unfiltered ("\t");
193 printf_unfiltered ("I-%d - ", (l
& 0x80) != 0);
198 printf_unfiltered ("N-%d ", N
);
199 printf_unfiltered ("Z-%d ", Z
);
200 printf_unfiltered ("V-%d ", V
);
201 printf_unfiltered ("C-%d ", C
);
203 printf_unfiltered ("u> ");
205 printf_unfiltered ("u<= ");
207 printf_unfiltered ("u>= ");
209 printf_unfiltered ("u< ");
211 printf_unfiltered ("!= ");
213 printf_unfiltered ("== ");
215 printf_unfiltered (">= ");
217 printf_unfiltered ("< ");
218 if ((Z
| (N
^ V
)) == 0)
219 printf_unfiltered ("> ");
220 if ((Z
| (N
^ V
)) == 1)
221 printf_unfiltered ("<= ");
226 h8500_register_size (int regno
)
257 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
262 h8500_register_virtual_type (int regno
)
270 return builtin_type_unsigned_char
;
280 return builtin_type_unsigned_short
;
290 return builtin_type_unsigned_long
;
292 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
296 /* Put here the code to store, into a struct frame_saved_regs,
297 the addresses of the saved registers of frame described by FRAME_INFO.
298 This includes special registers such as pc and fp saved in special
299 ways in the stack frame. sp is even more special:
300 the address we return for it IS the sp for the next frame. */
303 frame_find_saved_regs (struct frame_info
*frame_info
,
304 struct frame_saved_regs
*frame_saved_regs
)
307 register int regmask
;
308 register CORE_ADDR next_addr
;
309 register CORE_ADDR pc
;
310 unsigned char thebyte
;
312 memset (frame_saved_regs
, '\0', sizeof *frame_saved_regs
);
314 if ((frame_info
)->pc
>= (frame_info
)->frame
- CALL_DUMMY_LENGTH
- FP_REGNUM
* 4 - 4
315 && (frame_info
)->pc
<= (frame_info
)->frame
)
317 next_addr
= (frame_info
)->frame
;
318 pc
= (frame_info
)->frame
- CALL_DUMMY_LENGTH
- FP_REGNUM
* 4 - 4;
322 pc
= get_pc_function_start ((frame_info
)->pc
);
323 /* Verify we have a link a6 instruction next;
324 if not we lose. If we win, find the address above the saved
325 regs using the amount of storage from the link instruction.
328 thebyte
= read_memory_integer (pc
, 1);
330 next_addr
= (frame_info
)->frame
+ read_memory_integer (pc
+= 1, 2), pc
+= 2;
331 else if (0x17 == thebyte
)
332 next_addr
= (frame_info
)->frame
+ read_memory_integer (pc
+= 1, 1), pc
+= 1;
337 /* If have an add:g.waddal #-n, sp next, adjust next_addr. */
338 if ((0x0c0177777 & read_memory_integer (pc
, 2)) == 0157774)
339 next_addr
+= read_memory_integer (pc
+= 2, 4), pc
+= 4;
343 thebyte
= read_memory_integer (pc
, 1);
348 regmask
= read_memory_integer (pc
, 1);
350 for (regnum
= 0; regnum
< 8; regnum
++, regmask
>>= 1)
354 (frame_saved_regs
)->regs
[regnum
] = (next_addr
+= 2) - 2;
357 thebyte
= read_memory_integer (pc
, 1);
359 /* Maybe got a load of pushes */
360 while (thebyte
== 0xbf)
363 regnum
= read_memory_integer (pc
, 1) & 0x7;
365 (frame_saved_regs
)->regs
[regnum
] = (next_addr
+= 2) - 2;
366 thebyte
= read_memory_integer (pc
, 1);
371 /* Remember the address of the frame pointer */
372 (frame_saved_regs
)->regs
[FP_REGNUM
] = (frame_info
)->frame
;
374 /* This is where the old sp is hidden */
375 (frame_saved_regs
)->regs
[SP_REGNUM
] = (frame_info
)->frame
;
377 /* And the PC - remember the pushed FP is always two bytes long */
378 (frame_saved_regs
)->regs
[PC_REGNUM
] = (frame_info
)->frame
+ 2;
382 saved_pc_after_call (void)
385 int a
= read_register (SP_REGNUM
);
387 x
= read_memory_integer (a
, code_size
);
390 /* Stick current code segement onto top */
392 x
|= read_register (SEG_C_REGNUM
) << 16;
399 h8500_set_pointer_size (int newsize
)
401 static int oldsize
= 0;
403 if (oldsize
!= newsize
)
405 printf_unfiltered ("pointer size set to %d bits\n", newsize
);
415 _initialize_gdbtypes ();
420 big_command (char *arg
, int from_tty
)
422 h8500_set_pointer_size (32);
428 medium_command (char *arg
, int from_tty
)
430 h8500_set_pointer_size (32);
436 compact_command (char *arg
, int from_tty
)
438 h8500_set_pointer_size (32);
444 small_command (char *arg
, int from_tty
)
446 h8500_set_pointer_size (16);
451 static struct cmd_list_element
*setmemorylist
;
454 set_memory (char *args
, int from_tty
)
456 printf_unfiltered ("\"set memory\" must be followed by the name of a memory subcommand.\n");
457 help_list (setmemorylist
, "set memory ", -1, gdb_stdout
);
460 /* See if variable name is ppc or pr[0-7] */
463 h8500_is_trapped_internalvar (char *name
)
468 if (strcmp (name
+ 1, "pc") == 0)
474 && name
[3] == '\000')
481 h8500_value_of_trapped_internalvar (struct internalvar
*var
)
484 unsigned char regbuf
[4];
485 int page_regnum
, regnum
;
487 regnum
= var
->name
[2] == 'c' ? PC_REGNUM
: var
->name
[2] - '0';
489 switch (var
->name
[2])
492 page_regnum
= SEG_C_REGNUM
;
498 page_regnum
= SEG_D_REGNUM
;
502 page_regnum
= SEG_E_REGNUM
;
506 page_regnum
= SEG_T_REGNUM
;
510 get_saved_register (regbuf
, NULL
, NULL
, selected_frame
, page_regnum
, NULL
);
511 regval
= regbuf
[0] << 16;
513 get_saved_register (regbuf
, NULL
, NULL
, selected_frame
, regnum
, NULL
);
514 regval
|= regbuf
[0] << 8 | regbuf
[1]; /* XXX host/target byte order */
516 xfree (var
->value
); /* Free up old value */
518 var
->value
= value_from_longest (builtin_type_unsigned_long
, regval
);
519 release_value (var
->value
); /* Unchain new value */
521 VALUE_LVAL (var
->value
) = lval_internalvar
;
522 VALUE_INTERNALVAR (var
->value
) = var
;
527 h8500_set_trapped_internalvar (struct internalvar
*var
, struct value
*newval
,
528 int bitpos
, int bitsize
, int offset
)
530 char *page_regnum
, *regnum
;
531 char expression
[100];
534 enum type_code newval_type_code
;
536 type
= check_typedef (VALUE_TYPE (newval
));
537 newval_type_code
= TYPE_CODE (type
);
539 if ((newval_type_code
!= TYPE_CODE_INT
540 && newval_type_code
!= TYPE_CODE_PTR
)
541 || TYPE_LENGTH (type
) != sizeof (new_regval
))
542 error ("Illegal type (%s) for assignment to $%s\n",
543 TYPE_NAME (VALUE_TYPE (newval
)), var
->name
);
545 new_regval
= *(long *) VALUE_CONTENTS_RAW (newval
);
547 regnum
= var
->name
+ 1;
549 switch (var
->name
[2])
570 sprintf (expression
, "$%s=%d", page_regnum
, new_regval
>> 16);
571 parse_and_eval (expression
);
573 sprintf (expression
, "$%s=%d", regnum
, new_regval
& 0xffff);
574 parse_and_eval (expression
);
580 return read_register (PR7_REGNUM
);
584 h8500_write_sp (CORE_ADDR v
)
586 write_register (PR7_REGNUM
, v
);
590 h8500_read_pc (ptid_t ptid
)
592 return read_register (PC_REGNUM
);
596 h8500_write_pc (CORE_ADDR v
, ptid_t ptid
)
598 write_register (PC_REGNUM
, v
);
604 return read_register (PR6_REGNUM
);
608 _initialize_h8500_tdep (void)
610 tm_print_insn
= print_insn_h8500
;
612 add_prefix_cmd ("memory", no_class
, set_memory
,
613 "set the memory model", &setmemorylist
, "set memory ", 0,
616 add_cmd ("small", class_support
, small_command
,
617 "Set small memory model. (16 bit code, 16 bit data)", &setmemorylist
);
619 add_cmd ("big", class_support
, big_command
,
620 "Set big memory model. (32 bit code, 32 bit data)", &setmemorylist
);
622 add_cmd ("medium", class_support
, medium_command
,
623 "Set medium memory model. (32 bit code, 16 bit data)", &setmemorylist
);
625 add_cmd ("compact", class_support
, compact_command
,
626 "Set compact memory model. (16 bit code, 32 bit data)", &setmemorylist
);