1 /* Target-dependent code for Hitachi H8/500, for GDB.
2 Copyright 1993, 1994, 1995 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21 Contributed by Steve Chamberlain
35 #define UNSIGNED_SHORT(X) ((X) & 0xffff)
37 static int code_size
= 2;
39 static int data_size
= 2;
41 /* Shape of an H8/500 frame :
47 return address <2 or 4 bytes>
56 /* an easy to debug H8 stack frame looks like:
60 0x7905 nnnn mov.w #n,r5 or 0x1b87 subs #2,sp
65 #define IS_PUSH(x) (((x) & 0xff00)==0x6d00)
66 #define IS_LINK_8(x) ((x) == 0x17)
67 #define IS_LINK_16(x) ((x) == 0x1f)
68 #define IS_MOVE_FP(x) ((x) == 0x0d76)
69 #define IS_MOV_SP_FP(x) ((x) == 0x0d76)
70 #define IS_SUB2_SP(x) ((x) == 0x1b87)
71 #define IS_MOVK_R5(x) ((x) == 0x7905)
72 #define IS_SUB_R5SP(x) ((x) == 0x1957)
80 h8500_skip_prologue (start_pc
)
85 w
= read_memory_integer (start_pc
, 1);
89 w
= read_memory_integer (start_pc
, 1);
95 w
= read_memory_integer (start_pc
, 2);
102 h8500_addr_bits_remove (addr
)
105 return ((addr
) & 0xffffff);
108 /* Given a GDB frame, determine the address of the calling function's frame.
109 This will be used to create a new GDB frame struct, and then
110 INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
112 For us, the frame address is its stack pointer value, so we look up
113 the function prologue to determine the caller's sp value, and return it. */
116 h8500_frame_chain (thisframe
)
117 struct frame_info
*thisframe
;
119 if (!inside_entry_file (thisframe
->pc
))
120 return (read_memory_integer (FRAME_FP (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 (addr
, lim
, pword1
)
138 read_memory (addr
, pword1
, 1);
139 read_memory (addr
, pword1
+ 1, 1);
145 /* Examine the prologue of a function. `ip' points to the first
146 instruction. `limit' is the limit of the prologue (e.g. the addr
147 of the first linenumber, or perhaps the program counter if we're
148 stepping through). `frame_sp' is the stack pointer value in use in
149 this frame. `fsr' is a pointer to a frame_saved_regs structure
150 into which we put info about the registers saved by this frame.
151 `fi' is a struct frame_info pointer; we fill in various fields in
152 it to reflect the offsets of the arg pointer and the locals
155 /* Return the saved PC from this frame. */
158 frame_saved_pc (frame
)
159 struct frame_info
*frame
;
161 return read_memory_integer (FRAME_FP (frame
) + 2, PTR_SIZE
);
168 struct frame_saved_regs fsr
;
169 struct frame_info
*frame
= get_current_frame ();
171 get_frame_saved_regs (frame
, &fsr
);
173 for (regnum
= 0; regnum
< 8; regnum
++)
175 if (fsr
.regs
[regnum
])
176 write_register (regnum
, read_memory_short (fsr
.regs
[regnum
]));
178 flush_cached_frames ();
183 print_register_hook (regno
)
186 if (regno
== CCR_REGNUM
)
194 read_relative_register_raw_bytes (regno
, b
);
196 printf_unfiltered ("\t");
197 printf_unfiltered ("I-%d - ", (l
& 0x80) != 0);
202 printf_unfiltered ("N-%d ", N
);
203 printf_unfiltered ("Z-%d ", Z
);
204 printf_unfiltered ("V-%d ", V
);
205 printf_unfiltered ("C-%d ", C
);
207 printf_unfiltered ("u> ");
209 printf_unfiltered ("u<= ");
211 printf_unfiltered ("u>= ");
213 printf_unfiltered ("u< ");
215 printf_unfiltered ("!= ");
217 printf_unfiltered ("== ");
219 printf_unfiltered (">= ");
221 printf_unfiltered ("< ");
222 if ((Z
| (N
^ V
)) == 0)
223 printf_unfiltered ("> ");
224 if ((Z
| (N
^ V
)) == 1)
225 printf_unfiltered ("<= ");
230 h8500_register_size (regno
)
267 h8500_register_virtual_type (regno
)
276 return builtin_type_unsigned_char
;
286 return builtin_type_unsigned_short
;
296 return builtin_type_unsigned_long
;
302 /* Put here the code to store, into a struct frame_saved_regs,
303 the addresses of the saved registers of frame described by FRAME_INFO.
304 This includes special registers such as pc and fp saved in special
305 ways in the stack frame. sp is even more special:
306 the address we return for it IS the sp for the next frame. */
309 frame_find_saved_regs (frame_info
, frame_saved_regs
)
310 struct frame_info
*frame_info
;
311 struct frame_saved_regs
*frame_saved_regs
;
314 register int regmask
;
315 register CORE_ADDR next_addr
;
316 register CORE_ADDR pc
;
317 unsigned char thebyte
;
319 memset (frame_saved_regs
, '\0', sizeof *frame_saved_regs
);
321 if ((frame_info
)->pc
>= (frame_info
)->frame
- CALL_DUMMY_LENGTH
- FP_REGNUM
* 4 - 4
322 && (frame_info
)->pc
<= (frame_info
)->frame
)
324 next_addr
= (frame_info
)->frame
;
325 pc
= (frame_info
)->frame
- CALL_DUMMY_LENGTH
- FP_REGNUM
* 4 - 4;
329 pc
= get_pc_function_start ((frame_info
)->pc
);
330 /* Verify we have a link a6 instruction next;
331 if not we lose. If we win, find the address above the saved
332 regs using the amount of storage from the link instruction.
335 thebyte
= read_memory_integer (pc
, 1);
337 next_addr
= (frame_info
)->frame
+ read_memory_integer (pc
+= 1, 2), pc
+= 2;
338 else if (0x17 == thebyte
)
339 next_addr
= (frame_info
)->frame
+ read_memory_integer (pc
+= 1, 1), pc
+= 1;
344 /* If have an add:g.waddal #-n, sp next, adjust next_addr. */
345 if ((0x0c0177777 & read_memory_integer (pc
, 2)) == 0157774)
346 next_addr
+= read_memory_integer (pc
+= 2, 4), pc
+= 4;
350 thebyte
= read_memory_integer (pc
, 1);
355 regmask
= read_memory_integer (pc
, 1);
357 for (regnum
= 0; regnum
< 8; regnum
++, regmask
>>= 1)
361 (frame_saved_regs
)->regs
[regnum
] = (next_addr
+= 2) - 2;
364 thebyte
= read_memory_integer (pc
, 1);
366 /* Maybe got a load of pushes */
367 while (thebyte
== 0xbf)
370 regnum
= read_memory_integer (pc
, 1) & 0x7;
372 (frame_saved_regs
)->regs
[regnum
] = (next_addr
+= 2) - 2;
373 thebyte
= read_memory_integer (pc
, 1);
378 /* Remember the address of the frame pointer */
379 (frame_saved_regs
)->regs
[FP_REGNUM
] = (frame_info
)->frame
;
381 /* This is where the old sp is hidden */
382 (frame_saved_regs
)->regs
[SP_REGNUM
] = (frame_info
)->frame
;
384 /* And the PC - remember the pushed FP is always two bytes long */
385 (frame_saved_regs
)->regs
[PC_REGNUM
] = (frame_info
)->frame
+ 2;
389 saved_pc_after_call ()
392 int a
= read_register (SP_REGNUM
);
394 x
= read_memory_integer (a
, code_size
);
397 /* Stick current code segement onto top */
399 x
|= read_register (SEG_C_REGNUM
) << 16;
406 h8500_set_pointer_size (newsize
)
409 static int oldsize
= 0;
411 if (oldsize
!= newsize
)
413 printf_unfiltered ("pointer size set to %d bits\n", newsize
);
423 _initialize_gdbtypes ();
430 h8500_set_pointer_size (32);
438 h8500_set_pointer_size (32);
446 h8500_set_pointer_size (32);
454 h8500_set_pointer_size (16);
459 static struct cmd_list_element
*setmemorylist
;
462 set_memory (args
, from_tty
)
466 printf_unfiltered ("\"set memory\" must be followed by the name of a memory subcommand.\n");
467 help_list (setmemorylist
, "set memory ", -1, gdb_stdout
);
470 /* See if variable name is ppc or pr[0-7] */
473 h8500_is_trapped_internalvar (name
)
479 if (strcmp (name
+ 1, "pc") == 0)
485 && name
[3] == '\000')
492 h8500_value_of_trapped_internalvar (var
)
493 struct internalvar
*var
;
496 unsigned char regbuf
[4];
497 int page_regnum
, regnum
;
499 regnum
= var
->name
[2] == 'c' ? PC_REGNUM
: var
->name
[2] - '0';
501 switch (var
->name
[2])
504 page_regnum
= SEG_C_REGNUM
;
510 page_regnum
= SEG_D_REGNUM
;
514 page_regnum
= SEG_E_REGNUM
;
518 page_regnum
= SEG_T_REGNUM
;
522 get_saved_register (regbuf
, NULL
, NULL
, selected_frame
, page_regnum
, NULL
);
523 regval
= regbuf
[0] << 16;
525 get_saved_register (regbuf
, NULL
, NULL
, selected_frame
, regnum
, NULL
);
526 regval
|= regbuf
[0] << 8 | regbuf
[1]; /* XXX host/target byte order */
528 free (var
->value
); /* Free up old value */
530 var
->value
= value_from_longest (builtin_type_unsigned_long
, regval
);
531 release_value (var
->value
); /* Unchain new value */
533 VALUE_LVAL (var
->value
) = lval_internalvar
;
534 VALUE_INTERNALVAR (var
->value
) = var
;
539 h8500_set_trapped_internalvar (var
, newval
, bitpos
, bitsize
, offset
)
540 struct internalvar
*var
;
541 int offset
, bitpos
, bitsize
;
544 char *page_regnum
, *regnum
;
545 char expression
[100];
548 enum type_code newval_type_code
;
550 type
= check_typedef (VALUE_TYPE (newval
));
551 newval_type_code
= TYPE_CODE (type
);
553 if ((newval_type_code
!= TYPE_CODE_INT
554 && newval_type_code
!= TYPE_CODE_PTR
)
555 || TYPE_LENGTH (type
) != sizeof (new_regval
))
556 error ("Illegal type (%s) for assignment to $%s\n",
557 TYPE_NAME (VALUE_TYPE (newval
)), var
->name
);
559 new_regval
= *(long *) VALUE_CONTENTS_RAW (newval
);
561 regnum
= var
->name
+ 1;
563 switch (var
->name
[2])
584 sprintf (expression
, "$%s=%d", page_regnum
, new_regval
>> 16);
585 parse_and_eval (expression
);
587 sprintf (expression
, "$%s=%d", regnum
, new_regval
& 0xffff);
588 parse_and_eval (expression
);
594 return read_register (PR7_REGNUM
);
601 write_register (PR7_REGNUM
, v
);
608 return read_register (PC_REGNUM
);
612 h8500_write_pc (v
, pid
)
616 write_register (PC_REGNUM
, v
);
622 return read_register (PR6_REGNUM
);
629 write_register (PR6_REGNUM
, v
);
633 _initialize_h8500_tdep ()
635 tm_print_insn
= print_insn_h8500
;
637 add_prefix_cmd ("memory", no_class
, set_memory
,
638 "set the memory model", &setmemorylist
, "set memory ", 0,
641 add_cmd ("small", class_support
, small_command
,
642 "Set small memory model. (16 bit code, 16 bit data)", &setmemorylist
);
644 add_cmd ("big", class_support
, big_command
,
645 "Set big memory model. (32 bit code, 32 bit data)", &setmemorylist
);
647 add_cmd ("medium", class_support
, medium_command
,
648 "Set medium memory model. (32 bit code, 16 bit data)", &setmemorylist
);
650 add_cmd ("compact", class_support
, compact_command
,
651 "Set compact memory model. (16 bit code, 32 bit data)", &setmemorylist
);