1 /* Target-machine dependent code for Hitachi H8/300, for GDB.
2 Copyright 1988, 1990, 1991, 2001 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,
19 Boston, MA 02111-1307, USA. */
22 Contributed by Steve Chamberlain
34 #include "gdb_string.h"
38 extern int h8300hmode
, h8300smode
;
43 #define UNSIGNED_SHORT(X) ((X) & 0xffff)
45 #define IS_PUSH(x) ((x & 0xfff0)==0x6df0)
46 #define IS_PUSH_FP(x) (x == 0x6df6)
47 #define IS_MOVE_FP(x) (x == 0x0d76 || x == 0x0ff6)
48 #define IS_MOV_SP_FP(x) (x == 0x0d76 || x == 0x0ff6)
49 #define IS_SUB2_SP(x) (x==0x1b87)
50 #define IS_SUB4_SP(x) (x==0x1b97)
51 #define IS_SUBL_SP(x) (x==0x7a37)
52 #define IS_MOVK_R5(x) (x==0x7905)
53 #define IS_SUB_R5SP(x) (x==0x1957)
56 /* The register names change depending on whether the h8300h processor
59 static char *original_register_names
[] = REGISTER_NAMES
;
61 static char *h8300h_register_names
[] =
62 {"er0", "er1", "er2", "er3", "er4", "er5", "er6",
63 "sp", "ccr", "pc", "cycles", "tick", "inst"};
65 char **h8300_register_names
= original_register_names
;
68 /* Local function declarations. */
70 static CORE_ADDR
examine_prologue ();
71 static void set_machine_hook (char *filename
);
73 void h8300_frame_find_saved_regs ();
76 h8300_skip_prologue (CORE_ADDR start_pc
)
81 /* Skip past all push and stm insns. */
84 w
= read_memory_unsigned_integer (start_pc
, 2);
85 /* First look for push insns. */
86 if (w
== 0x0100 || w
== 0x0110 || w
== 0x0120 || w
== 0x0130)
88 w
= read_memory_unsigned_integer (start_pc
+ 2, 2);
94 start_pc
+= 2 + adjust
;
95 w
= read_memory_unsigned_integer (start_pc
, 2);
102 /* Skip past a move to FP, either word or long sized */
103 w
= read_memory_unsigned_integer (start_pc
, 2);
106 w
= read_memory_unsigned_integer (start_pc
+ 2, 2);
112 start_pc
+= 2 + adjust
;
113 w
= read_memory_unsigned_integer (start_pc
, 2);
116 /* Check for loading either a word constant into r5;
117 long versions are handled by the SUBL_SP below. */
121 w
= read_memory_unsigned_integer (start_pc
, 2);
124 /* Now check for subtracting r5 from sp, word sized only. */
127 start_pc
+= 2 + adjust
;
128 w
= read_memory_unsigned_integer (start_pc
, 2);
131 /* Check for subs #2 and subs #4. */
132 while (IS_SUB2_SP (w
) || IS_SUB4_SP (w
))
134 start_pc
+= 2 + adjust
;
135 w
= read_memory_unsigned_integer (start_pc
, 2);
138 /* Check for a 32bit subtract. */
140 start_pc
+= 6 + adjust
;
146 gdb_print_insn_h8300 (bfd_vma memaddr
, disassemble_info
*info
)
149 return print_insn_h8300s (memaddr
, info
);
151 return print_insn_h8300h (memaddr
, info
);
153 return print_insn_h8300 (memaddr
, info
);
156 /* Given a GDB frame, determine the address of the calling function's frame.
157 This will be used to create a new GDB frame struct, and then
158 INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
160 For us, the frame address is its stack pointer value, so we look up
161 the function prologue to determine the caller's sp value, and return it. */
164 h8300_frame_chain (struct frame_info
*thisframe
)
166 if (PC_IN_CALL_DUMMY (thisframe
->pc
, thisframe
->frame
, thisframe
->frame
))
167 { /* initialize the from_pc now */
168 thisframe
->from_pc
= generic_read_register_dummy (thisframe
->pc
,
171 return thisframe
->frame
;
173 h8300_frame_find_saved_regs (thisframe
, (struct frame_saved_regs
*) 0);
174 return thisframe
->fsr
->regs
[SP_REGNUM
];
177 /* Put here the code to store, into a struct frame_saved_regs,
178 the addresses of the saved registers of frame described by FRAME_INFO.
179 This includes special registers such as pc and fp saved in special
180 ways in the stack frame. sp is even more special:
181 the address we return for it IS the sp for the next frame.
183 We cache the result of doing this in the frame_obstack, since it is
187 h8300_frame_find_saved_regs (struct frame_info
*fi
,
188 struct frame_saved_regs
*fsr
)
190 register struct frame_saved_regs
*cache_fsr
;
192 struct symtab_and_line sal
;
197 cache_fsr
= (struct frame_saved_regs
*)
198 frame_obstack_alloc (sizeof (struct frame_saved_regs
));
199 memset (cache_fsr
, '\0', sizeof (struct frame_saved_regs
));
203 if (PC_IN_CALL_DUMMY (fi
->pc
, fi
->frame
, fi
->frame
))
204 { /* no more to do. */
209 /* Find the start and end of the function prologue. If the PC
210 is in the function prologue, we only consider the part that
211 has executed already. */
213 ip
= get_pc_function_start (fi
->pc
);
214 sal
= find_pc_line (ip
, 0);
215 limit
= (sal
.end
&& sal
.end
< fi
->pc
) ? sal
.end
: fi
->pc
;
217 /* This will fill in fields in *fi as well as in cache_fsr. */
218 examine_prologue (ip
, limit
, fi
->frame
, cache_fsr
, fi
);
225 /* Fetch the instruction at ADDR, returning 0 if ADDR is beyond LIM or
226 is not the address of a valid instruction, the address of the next
227 instruction beyond ADDR otherwise. *PWORD1 receives the first word
228 of the instruction. */
231 NEXT_PROLOGUE_INSN (CORE_ADDR addr
, CORE_ADDR lim
, INSN_WORD
*pword1
)
236 read_memory (addr
, buf
, 2);
237 *pword1
= extract_signed_integer (buf
, 2);
244 /* Examine the prologue of a function. `ip' points to the first instruction.
245 `limit' is the limit of the prologue (e.g. the addr of the first
246 linenumber, or perhaps the program counter if we're stepping through).
247 `frame_sp' is the stack pointer value in use in this frame.
248 `fsr' is a pointer to a frame_saved_regs structure into which we put
249 info about the registers saved by this frame.
250 `fi' is a struct frame_info pointer; we fill in various fields in it
251 to reflect the offsets of the arg pointer and the locals pointer. */
254 examine_prologue (register CORE_ADDR ip
, register CORE_ADDR limit
,
255 CORE_ADDR after_prolog_fp
, struct frame_saved_regs
*fsr
,
256 struct frame_info
*fi
)
258 register CORE_ADDR next_ip
;
262 /* Number of things pushed onto stack, starts at 2/4, 'cause the
263 PC is already there */
264 unsigned int reg_save_depth
= h8300hmode
? 4 : 2;
266 unsigned int auto_depth
= 0; /* Number of bytes of autos */
268 char in_frame
[11]; /* One for each reg */
272 memset (in_frame
, 1, 11);
273 for (r
= 0; r
< 8; r
++)
277 if (after_prolog_fp
== 0)
279 after_prolog_fp
= read_register (SP_REGNUM
);
282 /* If the PC isn't valid, quit now. */
283 if (ip
== 0 || ip
& (h8300hmode
? ~0xffffff : ~0xffff))
286 next_ip
= NEXT_PROLOGUE_INSN (ip
, limit
, &insn_word
);
288 if (insn_word
== 0x0100)
290 insn_word
= read_memory_unsigned_integer (ip
+ 2, 2);
294 /* Skip over any fp push instructions */
295 fsr
->regs
[6] = after_prolog_fp
;
296 while (next_ip
&& IS_PUSH_FP (insn_word
))
298 ip
= next_ip
+ adjust
;
300 in_frame
[insn_word
& 0x7] = reg_save_depth
;
301 next_ip
= NEXT_PROLOGUE_INSN (ip
, limit
, &insn_word
);
302 reg_save_depth
+= 2 + adjust
;
305 /* Is this a move into the fp */
306 if (next_ip
&& IS_MOV_SP_FP (insn_word
))
309 next_ip
= NEXT_PROLOGUE_INSN (ip
, limit
, &insn_word
);
313 /* Skip over any stack adjustment, happens either with a number of
314 sub#2,sp or a mov #x,r5 sub r5,sp */
316 if (next_ip
&& (IS_SUB2_SP (insn_word
) || IS_SUB4_SP (insn_word
)))
318 while (next_ip
&& (IS_SUB2_SP (insn_word
) || IS_SUB4_SP (insn_word
)))
320 auto_depth
+= IS_SUB2_SP (insn_word
) ? 2 : 4;
322 next_ip
= NEXT_PROLOGUE_INSN (ip
, limit
, &insn_word
);
327 if (next_ip
&& IS_MOVK_R5 (insn_word
))
330 next_ip
= NEXT_PROLOGUE_INSN (ip
, limit
, &insn_word
);
331 auto_depth
+= insn_word
;
333 next_ip
= NEXT_PROLOGUE_INSN (next_ip
, limit
, &insn_word
);
334 auto_depth
+= insn_word
;
336 if (next_ip
&& IS_SUBL_SP (insn_word
))
339 auto_depth
+= read_memory_unsigned_integer (ip
, 4);
342 next_ip
= NEXT_PROLOGUE_INSN (ip
, limit
, &insn_word
);
346 /* Now examine the push insns to determine where everything lives
354 if (insn_word
== 0x0100)
357 next_ip
= NEXT_PROLOGUE_INSN (ip
, limit
, &insn_word
);
361 if (IS_PUSH (insn_word
))
364 next_ip
= NEXT_PROLOGUE_INSN (ip
, limit
, &insn_word
);
365 fsr
->regs
[r
] = after_prolog_fp
+ auto_depth
;
366 auto_depth
+= 2 + adjust
;
370 /* Now check for push multiple insns. */
371 if (insn_word
== 0x0110 || insn_word
== 0x0120 || insn_word
== 0x0130)
373 int count
= ((insn_word
>> 4) & 0xf) + 1;
377 next_ip
= NEXT_PROLOGUE_INSN (ip
, limit
, &insn_word
);
378 start
= insn_word
& 0x7;
380 for (i
= start
; i
<= start
+ count
; i
++)
382 fsr
->regs
[i
] = after_prolog_fp
+ auto_depth
;
389 /* The args are always reffed based from the stack pointer */
390 fi
->args_pointer
= after_prolog_fp
;
391 /* Locals are always reffed based from the fp */
392 fi
->locals_pointer
= after_prolog_fp
;
393 /* The PC is at a known place */
394 fi
->from_pc
= read_memory_unsigned_integer (after_prolog_fp
+ BINWORD
, BINWORD
);
396 /* Rememeber any others too */
397 in_frame
[PC_REGNUM
] = 0;
400 /* We keep the old FP in the SP spot */
401 fsr
->regs
[SP_REGNUM
] = read_memory_unsigned_integer (fsr
->regs
[6], BINWORD
);
403 fsr
->regs
[SP_REGNUM
] = after_prolog_fp
+ auto_depth
;
409 h8300_init_extra_frame_info (int fromleaf
, struct frame_info
*fi
)
411 fi
->fsr
= 0; /* Not yet allocated */
412 fi
->args_pointer
= 0; /* Unknown */
413 fi
->locals_pointer
= 0; /* Unknown */
415 if (PC_IN_CALL_DUMMY (fi
->pc
, fi
->frame
, fi
->frame
))
416 { /* anything special to do? */
421 /* Return the saved PC from this frame.
423 If the frame has a memory copy of SRP_REGNUM, use that. If not,
424 just use the register SRP_REGNUM itself. */
427 h8300_frame_saved_pc (struct frame_info
*frame
)
429 if (PC_IN_CALL_DUMMY (frame
->pc
, frame
->frame
, frame
->frame
))
430 return generic_read_register_dummy (frame
->pc
, frame
->frame
, PC_REGNUM
);
432 return frame
->from_pc
;
436 frame_locals_address (struct frame_info
*fi
)
438 if (PC_IN_CALL_DUMMY (fi
->pc
, fi
->frame
, fi
->frame
))
439 return (CORE_ADDR
) 0; /* Not sure what else to do... */
440 if (!fi
->locals_pointer
)
442 struct frame_saved_regs ignore
;
444 get_frame_saved_regs (fi
, &ignore
);
447 return fi
->locals_pointer
;
450 /* Return the address of the argument block for the frame
451 described by FI. Returns 0 if the address is unknown. */
454 frame_args_address (struct frame_info
*fi
)
456 if (PC_IN_CALL_DUMMY (fi
->pc
, fi
->frame
, fi
->frame
))
457 return (CORE_ADDR
) 0; /* Not sure what else to do... */
458 if (!fi
->args_pointer
)
460 struct frame_saved_regs ignore
;
462 get_frame_saved_regs (fi
, &ignore
);
466 return fi
->args_pointer
;
469 /* Function: push_arguments
470 Setup the function arguments for calling a function in the inferior.
472 On the Hitachi H8/300 architecture, there are three registers (R0 to R2)
473 which are dedicated for passing function arguments. Up to the first
474 three arguments (depending on size) may go into these registers.
475 The rest go on the stack.
477 Arguments that are smaller than WORDSIZE bytes will still take up a
478 whole register or a whole WORDSIZE word on the stack, and will be
479 right-justified in the register or the stack word. This includes
480 chars and small aggregate types. Note that WORDSIZE depends on the
483 Arguments that are larger than WORDSIZE bytes will be split between
484 two or more registers as available, but will NOT be split between a
485 register and the stack.
487 An exceptional case exists for struct arguments (and possibly other
488 aggregates such as arrays) -- if the size is larger than WORDSIZE
489 bytes but not a multiple of WORDSIZE bytes. In this case the
490 argument is never split between the registers and the stack, but
491 instead is copied in its entirety onto the stack, AND also copied
492 into as many registers as there is room for. In other words, space
493 in registers permitting, two copies of the same argument are passed
494 in. As far as I can tell, only the one on the stack is used,
495 although that may be a function of the level of compiler
496 optimization. I suspect this is a compiler bug. Arguments of
497 these odd sizes are left-justified within the word (as opposed to
498 arguments smaller than WORDSIZE bytes, which are right-justified).
500 If the function is to return an aggregate type such as a struct,
501 the caller must allocate space into which the callee will copy the
502 return value. In this case, a pointer to the return value location
503 is passed into the callee in register R0, which displaces one of
504 the other arguments passed in via registers R0 to R2. */
507 h8300_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
508 unsigned char struct_return
, CORE_ADDR struct_addr
)
510 int stack_align
, stack_alloc
, stack_offset
;
520 if (h8300hmode
|| h8300smode
)
531 /* first force sp to a n-byte alignment */
532 sp
= sp
& ~stack_align
;
534 /* Now make sure there's space on the stack */
535 for (argnum
= 0, stack_alloc
= 0;
536 argnum
< nargs
; argnum
++)
537 stack_alloc
+= ((TYPE_LENGTH (VALUE_TYPE (args
[argnum
])) + stack_align
)
539 sp
-= stack_alloc
; /* make room on stack for args */
540 /* we may over-allocate a little here, but that won't hurt anything */
542 argreg
= ARG0_REGNUM
;
543 if (struct_return
) /* "struct return" pointer takes up one argreg */
545 write_register (argreg
++, struct_addr
);
548 /* Now load as many as possible of the first arguments into
549 registers, and push the rest onto the stack. There are 3N bytes
550 in three registers available. Loop thru args from first to last. */
552 for (argnum
= 0, stack_offset
= 0; argnum
< nargs
; argnum
++)
554 type
= VALUE_TYPE (args
[argnum
]);
555 len
= TYPE_LENGTH (type
);
556 memset (valbuf
, 0, sizeof (valbuf
));
559 /* the purpose of this is to right-justify the value within the word */
560 memcpy (valbuf
+ (wordsize
- len
),
561 (char *) VALUE_CONTENTS (args
[argnum
]), len
);
565 val
= (char *) VALUE_CONTENTS (args
[argnum
]);
567 if (len
> (ARGLAST_REGNUM
+ 1 - argreg
) * REGISTER_RAW_SIZE (ARG0_REGNUM
) ||
568 (len
> wordsize
&& (len
& stack_align
) != 0))
569 { /* passed on the stack */
570 write_memory (sp
+ stack_offset
, val
,
571 len
< wordsize
? wordsize
: len
);
572 stack_offset
+= (len
+ stack_align
) & ~stack_align
;
574 /* NOTE WELL!!!!! This is not an "else if" clause!!!
575 That's because some *&^%$ things get passed on the stack
576 AND in the registers! */
577 if (len
<= (ARGLAST_REGNUM
+ 1 - argreg
) * REGISTER_RAW_SIZE (ARG0_REGNUM
))
579 { /* there's room in registers */
580 regval
= extract_address (val
, wordsize
);
581 write_register (argreg
, regval
);
590 /* Function: push_return_address
591 Setup the return address for a dummy frame, as called by
592 call_function_by_hand. Only necessary when you are using an
593 empty CALL_DUMMY, ie. the target will not actually be executing
594 a JSR/BSR instruction. */
597 h8300_push_return_address (CORE_ADDR pc
, CORE_ADDR sp
)
599 unsigned char buf
[4];
602 if (h8300hmode
|| h8300smode
)
608 store_unsigned_integer (buf
, wordsize
, CALL_DUMMY_ADDRESS ());
609 write_memory (sp
, buf
, wordsize
);
613 /* Function: pop_frame
614 Restore the machine to the state it had before the current frame
615 was created. Usually used either by the "RETURN" command, or by
616 call_function_by_hand after the dummy_frame is finished. */
619 h8300_pop_frame (void)
622 struct frame_saved_regs fsr
;
623 struct frame_info
*frame
= get_current_frame ();
625 if (PC_IN_CALL_DUMMY (frame
->pc
, frame
->frame
, frame
->frame
))
627 generic_pop_dummy_frame ();
631 get_frame_saved_regs (frame
, &fsr
);
633 for (regnum
= 0; regnum
< 8; regnum
++)
635 /* Don't forget SP_REGNUM is a frame_saved_regs struct is the
636 actual value we want, not the address of the value we want. */
637 if (fsr
.regs
[regnum
] && regnum
!= SP_REGNUM
)
638 write_register (regnum
,
639 read_memory_integer (fsr
.regs
[regnum
], BINWORD
));
640 else if (fsr
.regs
[regnum
] && regnum
== SP_REGNUM
)
641 write_register (regnum
, frame
->frame
+ 2 * BINWORD
);
644 /* Don't forget the update the PC too! */
645 write_pc (frame
->from_pc
);
647 flush_cached_frames ();
650 /* Function: extract_return_value
651 Figure out where in REGBUF the called function has left its return value.
652 Copy that into VALBUF. Be sure to account for CPU type. */
655 h8300_extract_return_value (struct type
*type
, char *regbuf
, char *valbuf
)
659 if (h8300smode
|| h8300hmode
)
664 len
= TYPE_LENGTH (type
);
669 case 2: /* (short), (int) */
670 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (0) + (wordsize
- len
), len
);
672 case 4: /* (long), (float) */
673 if (h8300smode
|| h8300hmode
)
675 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (0), 4);
679 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (0), 2);
680 memcpy (valbuf
+ 2, regbuf
+ REGISTER_BYTE (1), 2);
683 case 8: /* (double) (doesn't seem to happen, which is good,
684 because this almost certainly isn't right. */
685 error ("I don't know how a double is returned.");
690 /* Function: store_return_value
691 Place the appropriate value in the appropriate registers.
692 Primarily used by the RETURN command. */
695 h8300_store_return_value (struct type
*type
, char *valbuf
)
697 int wordsize
, len
, regval
;
699 if (h8300hmode
|| h8300smode
)
704 len
= TYPE_LENGTH (type
);
708 case 2: /* short, int */
709 regval
= extract_address (valbuf
, len
);
710 write_register (0, regval
);
712 case 4: /* long, float */
713 regval
= extract_address (valbuf
, len
);
714 if (h8300smode
|| h8300hmode
)
716 write_register (0, regval
);
720 write_register (0, regval
>> 16);
721 write_register (1, regval
& 0xffff);
724 case 8: /* presumeably double, but doesn't seem to happen */
725 error ("I don't know how to return a double.");
730 struct cmd_list_element
*setmemorylist
;
733 set_register_names (void)
736 h8300_register_names
= h8300h_register_names
;
738 h8300_register_names
= original_register_names
;
742 h8300_command (char *args
, int from_tty
)
744 extern int h8300hmode
;
747 set_register_names ();
751 h8300h_command (char *args
, int from_tty
)
753 extern int h8300hmode
;
756 set_register_names ();
760 h8300s_command (char *args
, int from_tty
)
762 extern int h8300smode
;
763 extern int h8300hmode
;
766 set_register_names ();
771 set_machine (char *args
, int from_tty
)
773 printf_unfiltered ("\"set machine\" must be followed by h8300, h8300h");
774 printf_unfiltered ("or h8300s");
775 help_list (setmemorylist
, "set memory ", -1, gdb_stdout
);
778 /* set_machine_hook is called as the exec file is being opened, but
779 before the symbol file is opened. This allows us to set the
780 h8300hmode flag based on the machine type specified in the exec
781 file. This in turn will cause subsequently defined pointer types
782 to be 16 or 32 bits as appropriate for the machine. */
785 set_machine_hook (char *filename
)
787 if (bfd_get_mach (exec_bfd
) == bfd_mach_h8300s
)
792 else if (bfd_get_mach (exec_bfd
) == bfd_mach_h8300h
)
802 set_register_names ();
806 _initialize_h8300m (void)
808 add_prefix_cmd ("machine", no_class
, set_machine
,
809 "set the machine type",
810 &setmemorylist
, "set machine ", 0,
813 add_cmd ("h8300", class_support
, h8300_command
,
814 "Set machine to be H8/300.", &setmemorylist
);
816 add_cmd ("h8300h", class_support
, h8300h_command
,
817 "Set machine to be H8/300H.", &setmemorylist
);
819 add_cmd ("h8300s", class_support
, h8300s_command
,
820 "Set machine to be H8/300S.", &setmemorylist
);
822 /* Add a hook to set the machine type when we're loading a file. */
824 specify_exec_file_hook (set_machine_hook
);
830 print_register_hook (int regno
)
838 read_relative_register_raw_bytes (regno
, b
);
839 l
= b
[REGISTER_VIRTUAL_SIZE (8) - 1];
840 printf_unfiltered ("\t");
841 printf_unfiltered ("I-%d - ", (l
& 0x80) != 0);
842 printf_unfiltered ("H-%d - ", (l
& 0x20) != 0);
847 printf_unfiltered ("N-%d ", N
);
848 printf_unfiltered ("Z-%d ", Z
);
849 printf_unfiltered ("V-%d ", V
);
850 printf_unfiltered ("C-%d ", C
);
852 printf_unfiltered ("u> ");
854 printf_unfiltered ("u<= ");
856 printf_unfiltered ("u>= ");
858 printf_unfiltered ("u< ");
860 printf_unfiltered ("!= ");
862 printf_unfiltered ("== ");
864 printf_unfiltered (">= ");
866 printf_unfiltered ("< ");
867 if ((Z
| (N
^ V
)) == 0)
868 printf_unfiltered ("> ");
869 if ((Z
| (N
^ V
)) == 1)
870 printf_unfiltered ("<= ");
875 _initialize_h8300_tdep (void)
877 tm_print_insn
= gdb_print_insn_h8300
;