1 /* Target-machine dependent code for Hitachi H8/300, for GDB.
2 Copyright 1988, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999,
3 2000, 2001 Free Software Foundation, Inc.
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,
20 Boston, MA 02111-1307, USA. */
23 Contributed by Steve Chamberlain
35 #include "gdb_string.h"
39 extern int h8300hmode
, h8300smode
;
44 #define UNSIGNED_SHORT(X) ((X) & 0xffff)
46 #define IS_PUSH(x) ((x & 0xfff0)==0x6df0)
47 #define IS_PUSH_FP(x) (x == 0x6df6)
48 #define IS_MOVE_FP(x) (x == 0x0d76 || x == 0x0ff6)
49 #define IS_MOV_SP_FP(x) (x == 0x0d76 || x == 0x0ff6)
50 #define IS_SUB2_SP(x) (x==0x1b87)
51 #define IS_SUB4_SP(x) (x==0x1b97)
52 #define IS_SUBL_SP(x) (x==0x7a37)
53 #define IS_MOVK_R5(x) (x==0x7905)
54 #define IS_SUB_R5SP(x) (x==0x1957)
57 /* The register names change depending on whether the h8300h processor
60 static char *original_register_names
[] = REGISTER_NAMES
;
62 static char *h8300h_register_names
[] =
63 {"er0", "er1", "er2", "er3", "er4", "er5", "er6",
64 "sp", "ccr", "pc", "cycles", "tick", "inst"};
66 char **h8300_register_names
= original_register_names
;
69 /* Local function declarations. */
71 static CORE_ADDR
examine_prologue ();
72 static void set_machine_hook (char *filename
);
74 void h8300_frame_find_saved_regs ();
77 h8300_skip_prologue (CORE_ADDR start_pc
)
82 /* Skip past all push and stm insns. */
85 w
= read_memory_unsigned_integer (start_pc
, 2);
86 /* First look for push insns. */
87 if (w
== 0x0100 || w
== 0x0110 || w
== 0x0120 || w
== 0x0130)
89 w
= read_memory_unsigned_integer (start_pc
+ 2, 2);
95 start_pc
+= 2 + adjust
;
96 w
= read_memory_unsigned_integer (start_pc
, 2);
103 /* Skip past a move to FP, either word or long sized */
104 w
= read_memory_unsigned_integer (start_pc
, 2);
107 w
= read_memory_unsigned_integer (start_pc
+ 2, 2);
113 start_pc
+= 2 + adjust
;
114 w
= read_memory_unsigned_integer (start_pc
, 2);
117 /* Check for loading either a word constant into r5;
118 long versions are handled by the SUBL_SP below. */
122 w
= read_memory_unsigned_integer (start_pc
, 2);
125 /* Now check for subtracting r5 from sp, word sized only. */
128 start_pc
+= 2 + adjust
;
129 w
= read_memory_unsigned_integer (start_pc
, 2);
132 /* Check for subs #2 and subs #4. */
133 while (IS_SUB2_SP (w
) || IS_SUB4_SP (w
))
135 start_pc
+= 2 + adjust
;
136 w
= read_memory_unsigned_integer (start_pc
, 2);
139 /* Check for a 32bit subtract. */
141 start_pc
+= 6 + adjust
;
147 gdb_print_insn_h8300 (bfd_vma memaddr
, disassemble_info
*info
)
150 return print_insn_h8300s (memaddr
, info
);
152 return print_insn_h8300h (memaddr
, info
);
154 return print_insn_h8300 (memaddr
, info
);
157 /* Given a GDB frame, determine the address of the calling function's frame.
158 This will be used to create a new GDB frame struct, and then
159 INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
161 For us, the frame address is its stack pointer value, so we look up
162 the function prologue to determine the caller's sp value, and return it. */
165 h8300_frame_chain (struct frame_info
*thisframe
)
167 if (PC_IN_CALL_DUMMY (thisframe
->pc
, thisframe
->frame
, thisframe
->frame
))
168 { /* initialize the from_pc now */
169 thisframe
->from_pc
= generic_read_register_dummy (thisframe
->pc
,
172 return thisframe
->frame
;
174 h8300_frame_find_saved_regs (thisframe
, (struct frame_saved_regs
*) 0);
175 return thisframe
->fsr
->regs
[SP_REGNUM
];
178 /* Put here the code to store, into a struct frame_saved_regs,
179 the addresses of the saved registers of frame described by FRAME_INFO.
180 This includes special registers such as pc and fp saved in special
181 ways in the stack frame. sp is even more special:
182 the address we return for it IS the sp for the next frame.
184 We cache the result of doing this in the frame_obstack, since it is
188 h8300_frame_find_saved_regs (struct frame_info
*fi
,
189 struct frame_saved_regs
*fsr
)
191 register struct frame_saved_regs
*cache_fsr
;
193 struct symtab_and_line sal
;
198 cache_fsr
= (struct frame_saved_regs
*)
199 frame_obstack_alloc (sizeof (struct frame_saved_regs
));
200 memset (cache_fsr
, '\0', sizeof (struct frame_saved_regs
));
204 if (PC_IN_CALL_DUMMY (fi
->pc
, fi
->frame
, fi
->frame
))
205 { /* no more to do. */
210 /* Find the start and end of the function prologue. If the PC
211 is in the function prologue, we only consider the part that
212 has executed already. */
214 ip
= get_pc_function_start (fi
->pc
);
215 sal
= find_pc_line (ip
, 0);
216 limit
= (sal
.end
&& sal
.end
< fi
->pc
) ? sal
.end
: fi
->pc
;
218 /* This will fill in fields in *fi as well as in cache_fsr. */
219 examine_prologue (ip
, limit
, fi
->frame
, cache_fsr
, fi
);
226 /* Fetch the instruction at ADDR, returning 0 if ADDR is beyond LIM or
227 is not the address of a valid instruction, the address of the next
228 instruction beyond ADDR otherwise. *PWORD1 receives the first word
229 of the instruction. */
232 NEXT_PROLOGUE_INSN (CORE_ADDR addr
, CORE_ADDR lim
, INSN_WORD
*pword1
)
237 read_memory (addr
, buf
, 2);
238 *pword1
= extract_signed_integer (buf
, 2);
245 /* Examine the prologue of a function. `ip' points to the first instruction.
246 `limit' is the limit of the prologue (e.g. the addr of the first
247 linenumber, or perhaps the program counter if we're stepping through).
248 `frame_sp' is the stack pointer value in use in this frame.
249 `fsr' is a pointer to a frame_saved_regs structure into which we put
250 info about the registers saved by this frame.
251 `fi' is a struct frame_info pointer; we fill in various fields in it
252 to reflect the offsets of the arg pointer and the locals pointer. */
255 examine_prologue (register CORE_ADDR ip
, register CORE_ADDR limit
,
256 CORE_ADDR after_prolog_fp
, struct frame_saved_regs
*fsr
,
257 struct frame_info
*fi
)
259 register CORE_ADDR next_ip
;
263 /* Number of things pushed onto stack, starts at 2/4, 'cause the
264 PC is already there */
265 unsigned int reg_save_depth
= h8300hmode
? 4 : 2;
267 unsigned int auto_depth
= 0; /* Number of bytes of autos */
269 char in_frame
[11]; /* One for each reg */
273 memset (in_frame
, 1, 11);
274 for (r
= 0; r
< 8; r
++)
278 if (after_prolog_fp
== 0)
280 after_prolog_fp
= read_register (SP_REGNUM
);
283 /* If the PC isn't valid, quit now. */
284 if (ip
== 0 || ip
& (h8300hmode
? ~0xffffff : ~0xffff))
287 next_ip
= NEXT_PROLOGUE_INSN (ip
, limit
, &insn_word
);
289 if (insn_word
== 0x0100)
291 insn_word
= read_memory_unsigned_integer (ip
+ 2, 2);
295 /* Skip over any fp push instructions */
296 fsr
->regs
[6] = after_prolog_fp
;
297 while (next_ip
&& IS_PUSH_FP (insn_word
))
299 ip
= next_ip
+ adjust
;
301 in_frame
[insn_word
& 0x7] = reg_save_depth
;
302 next_ip
= NEXT_PROLOGUE_INSN (ip
, limit
, &insn_word
);
303 reg_save_depth
+= 2 + adjust
;
306 /* Is this a move into the fp */
307 if (next_ip
&& IS_MOV_SP_FP (insn_word
))
310 next_ip
= NEXT_PROLOGUE_INSN (ip
, limit
, &insn_word
);
314 /* Skip over any stack adjustment, happens either with a number of
315 sub#2,sp or a mov #x,r5 sub r5,sp */
317 if (next_ip
&& (IS_SUB2_SP (insn_word
) || IS_SUB4_SP (insn_word
)))
319 while (next_ip
&& (IS_SUB2_SP (insn_word
) || IS_SUB4_SP (insn_word
)))
321 auto_depth
+= IS_SUB2_SP (insn_word
) ? 2 : 4;
323 next_ip
= NEXT_PROLOGUE_INSN (ip
, limit
, &insn_word
);
328 if (next_ip
&& IS_MOVK_R5 (insn_word
))
331 next_ip
= NEXT_PROLOGUE_INSN (ip
, limit
, &insn_word
);
332 auto_depth
+= insn_word
;
334 next_ip
= NEXT_PROLOGUE_INSN (next_ip
, limit
, &insn_word
);
335 auto_depth
+= insn_word
;
337 if (next_ip
&& IS_SUBL_SP (insn_word
))
340 auto_depth
+= read_memory_unsigned_integer (ip
, 4);
343 next_ip
= NEXT_PROLOGUE_INSN (ip
, limit
, &insn_word
);
347 /* Now examine the push insns to determine where everything lives
355 if (insn_word
== 0x0100)
358 next_ip
= NEXT_PROLOGUE_INSN (ip
, limit
, &insn_word
);
362 if (IS_PUSH (insn_word
))
365 next_ip
= NEXT_PROLOGUE_INSN (ip
, limit
, &insn_word
);
366 fsr
->regs
[r
] = after_prolog_fp
+ auto_depth
;
367 auto_depth
+= 2 + adjust
;
371 /* Now check for push multiple insns. */
372 if (insn_word
== 0x0110 || insn_word
== 0x0120 || insn_word
== 0x0130)
374 int count
= ((insn_word
>> 4) & 0xf) + 1;
378 next_ip
= NEXT_PROLOGUE_INSN (ip
, limit
, &insn_word
);
379 start
= insn_word
& 0x7;
381 for (i
= start
; i
<= start
+ count
; i
++)
383 fsr
->regs
[i
] = after_prolog_fp
+ auto_depth
;
390 /* The args are always reffed based from the stack pointer */
391 fi
->args_pointer
= after_prolog_fp
;
392 /* Locals are always reffed based from the fp */
393 fi
->locals_pointer
= after_prolog_fp
;
394 /* The PC is at a known place */
395 fi
->from_pc
= read_memory_unsigned_integer (after_prolog_fp
+ BINWORD
, BINWORD
);
397 /* Rememeber any others too */
398 in_frame
[PC_REGNUM
] = 0;
401 /* We keep the old FP in the SP spot */
402 fsr
->regs
[SP_REGNUM
] = read_memory_unsigned_integer (fsr
->regs
[6], BINWORD
);
404 fsr
->regs
[SP_REGNUM
] = after_prolog_fp
+ auto_depth
;
410 h8300_init_extra_frame_info (int fromleaf
, struct frame_info
*fi
)
412 fi
->fsr
= 0; /* Not yet allocated */
413 fi
->args_pointer
= 0; /* Unknown */
414 fi
->locals_pointer
= 0; /* Unknown */
416 if (PC_IN_CALL_DUMMY (fi
->pc
, fi
->frame
, fi
->frame
))
417 { /* anything special to do? */
422 /* Return the saved PC from this frame.
424 If the frame has a memory copy of SRP_REGNUM, use that. If not,
425 just use the register SRP_REGNUM itself. */
428 h8300_frame_saved_pc (struct frame_info
*frame
)
430 if (PC_IN_CALL_DUMMY (frame
->pc
, frame
->frame
, frame
->frame
))
431 return generic_read_register_dummy (frame
->pc
, frame
->frame
, PC_REGNUM
);
433 return frame
->from_pc
;
437 frame_locals_address (struct frame_info
*fi
)
439 if (PC_IN_CALL_DUMMY (fi
->pc
, fi
->frame
, fi
->frame
))
440 return (CORE_ADDR
) 0; /* Not sure what else to do... */
441 if (!fi
->locals_pointer
)
443 struct frame_saved_regs ignore
;
445 get_frame_saved_regs (fi
, &ignore
);
448 return fi
->locals_pointer
;
451 /* Return the address of the argument block for the frame
452 described by FI. Returns 0 if the address is unknown. */
455 frame_args_address (struct frame_info
*fi
)
457 if (PC_IN_CALL_DUMMY (fi
->pc
, fi
->frame
, fi
->frame
))
458 return (CORE_ADDR
) 0; /* Not sure what else to do... */
459 if (!fi
->args_pointer
)
461 struct frame_saved_regs ignore
;
463 get_frame_saved_regs (fi
, &ignore
);
467 return fi
->args_pointer
;
470 /* Function: push_arguments
471 Setup the function arguments for calling a function in the inferior.
473 On the Hitachi H8/300 architecture, there are three registers (R0 to R2)
474 which are dedicated for passing function arguments. Up to the first
475 three arguments (depending on size) may go into these registers.
476 The rest go on the stack.
478 Arguments that are smaller than WORDSIZE bytes will still take up a
479 whole register or a whole WORDSIZE word on the stack, and will be
480 right-justified in the register or the stack word. This includes
481 chars and small aggregate types. Note that WORDSIZE depends on the
484 Arguments that are larger than WORDSIZE bytes will be split between
485 two or more registers as available, but will NOT be split between a
486 register and the stack.
488 An exceptional case exists for struct arguments (and possibly other
489 aggregates such as arrays) -- if the size is larger than WORDSIZE
490 bytes but not a multiple of WORDSIZE bytes. In this case the
491 argument is never split between the registers and the stack, but
492 instead is copied in its entirety onto the stack, AND also copied
493 into as many registers as there is room for. In other words, space
494 in registers permitting, two copies of the same argument are passed
495 in. As far as I can tell, only the one on the stack is used,
496 although that may be a function of the level of compiler
497 optimization. I suspect this is a compiler bug. Arguments of
498 these odd sizes are left-justified within the word (as opposed to
499 arguments smaller than WORDSIZE bytes, which are right-justified).
501 If the function is to return an aggregate type such as a struct,
502 the caller must allocate space into which the callee will copy the
503 return value. In this case, a pointer to the return value location
504 is passed into the callee in register R0, which displaces one of
505 the other arguments passed in via registers R0 to R2. */
508 h8300_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
509 unsigned char struct_return
, CORE_ADDR struct_addr
)
511 int stack_align
, stack_alloc
, stack_offset
;
521 if (h8300hmode
|| h8300smode
)
532 /* first force sp to a n-byte alignment */
533 sp
= sp
& ~stack_align
;
535 /* Now make sure there's space on the stack */
536 for (argnum
= 0, stack_alloc
= 0;
537 argnum
< nargs
; argnum
++)
538 stack_alloc
+= ((TYPE_LENGTH (VALUE_TYPE (args
[argnum
])) + stack_align
)
540 sp
-= stack_alloc
; /* make room on stack for args */
541 /* we may over-allocate a little here, but that won't hurt anything */
543 argreg
= ARG0_REGNUM
;
544 if (struct_return
) /* "struct return" pointer takes up one argreg */
546 write_register (argreg
++, struct_addr
);
549 /* Now load as many as possible of the first arguments into
550 registers, and push the rest onto the stack. There are 3N bytes
551 in three registers available. Loop thru args from first to last. */
553 for (argnum
= 0, stack_offset
= 0; argnum
< nargs
; argnum
++)
555 type
= VALUE_TYPE (args
[argnum
]);
556 len
= TYPE_LENGTH (type
);
557 memset (valbuf
, 0, sizeof (valbuf
));
560 /* the purpose of this is to right-justify the value within the word */
561 memcpy (valbuf
+ (wordsize
- len
),
562 (char *) VALUE_CONTENTS (args
[argnum
]), len
);
566 val
= (char *) VALUE_CONTENTS (args
[argnum
]);
568 if (len
> (ARGLAST_REGNUM
+ 1 - argreg
) * REGISTER_RAW_SIZE (ARG0_REGNUM
) ||
569 (len
> wordsize
&& (len
& stack_align
) != 0))
570 { /* passed on the stack */
571 write_memory (sp
+ stack_offset
, val
,
572 len
< wordsize
? wordsize
: len
);
573 stack_offset
+= (len
+ stack_align
) & ~stack_align
;
575 /* NOTE WELL!!!!! This is not an "else if" clause!!!
576 That's because some *&^%$ things get passed on the stack
577 AND in the registers! */
578 if (len
<= (ARGLAST_REGNUM
+ 1 - argreg
) * REGISTER_RAW_SIZE (ARG0_REGNUM
))
580 { /* there's room in registers */
581 regval
= extract_address (val
, wordsize
);
582 write_register (argreg
, regval
);
591 /* Function: push_return_address
592 Setup the return address for a dummy frame, as called by
593 call_function_by_hand. Only necessary when you are using an
594 empty CALL_DUMMY, ie. the target will not actually be executing
595 a JSR/BSR instruction. */
598 h8300_push_return_address (CORE_ADDR pc
, CORE_ADDR sp
)
600 unsigned char buf
[4];
603 if (h8300hmode
|| h8300smode
)
609 store_unsigned_integer (buf
, wordsize
, CALL_DUMMY_ADDRESS ());
610 write_memory (sp
, buf
, wordsize
);
614 /* Function: pop_frame
615 Restore the machine to the state it had before the current frame
616 was created. Usually used either by the "RETURN" command, or by
617 call_function_by_hand after the dummy_frame is finished. */
620 h8300_pop_frame (void)
623 struct frame_saved_regs fsr
;
624 struct frame_info
*frame
= get_current_frame ();
626 if (PC_IN_CALL_DUMMY (frame
->pc
, frame
->frame
, frame
->frame
))
628 generic_pop_dummy_frame ();
632 get_frame_saved_regs (frame
, &fsr
);
634 for (regnum
= 0; regnum
< 8; regnum
++)
636 /* Don't forget SP_REGNUM is a frame_saved_regs struct is the
637 actual value we want, not the address of the value we want. */
638 if (fsr
.regs
[regnum
] && regnum
!= SP_REGNUM
)
639 write_register (regnum
,
640 read_memory_integer (fsr
.regs
[regnum
], BINWORD
));
641 else if (fsr
.regs
[regnum
] && regnum
== SP_REGNUM
)
642 write_register (regnum
, frame
->frame
+ 2 * BINWORD
);
645 /* Don't forget the update the PC too! */
646 write_pc (frame
->from_pc
);
648 flush_cached_frames ();
651 /* Function: extract_return_value
652 Figure out where in REGBUF the called function has left its return value.
653 Copy that into VALBUF. Be sure to account for CPU type. */
656 h8300_extract_return_value (struct type
*type
, char *regbuf
, char *valbuf
)
660 if (h8300smode
|| h8300hmode
)
665 len
= TYPE_LENGTH (type
);
670 case 2: /* (short), (int) */
671 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (0) + (wordsize
- len
), len
);
673 case 4: /* (long), (float) */
674 if (h8300smode
|| h8300hmode
)
676 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (0), 4);
680 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (0), 2);
681 memcpy (valbuf
+ 2, regbuf
+ REGISTER_BYTE (1), 2);
684 case 8: /* (double) (doesn't seem to happen, which is good,
685 because this almost certainly isn't right. */
686 error ("I don't know how a double is returned.");
691 /* Function: store_return_value
692 Place the appropriate value in the appropriate registers.
693 Primarily used by the RETURN command. */
696 h8300_store_return_value (struct type
*type
, char *valbuf
)
698 int wordsize
, len
, regval
;
700 if (h8300hmode
|| h8300smode
)
705 len
= TYPE_LENGTH (type
);
709 case 2: /* short, int */
710 regval
= extract_address (valbuf
, len
);
711 write_register (0, regval
);
713 case 4: /* long, float */
714 regval
= extract_address (valbuf
, len
);
715 if (h8300smode
|| h8300hmode
)
717 write_register (0, regval
);
721 write_register (0, regval
>> 16);
722 write_register (1, regval
& 0xffff);
725 case 8: /* presumeably double, but doesn't seem to happen */
726 error ("I don't know how to return a double.");
731 struct cmd_list_element
*setmemorylist
;
734 set_register_names (void)
737 h8300_register_names
= h8300h_register_names
;
739 h8300_register_names
= original_register_names
;
743 h8300_command (char *args
, int from_tty
)
745 extern int h8300hmode
;
748 set_register_names ();
752 h8300h_command (char *args
, int from_tty
)
754 extern int h8300hmode
;
757 set_register_names ();
761 h8300s_command (char *args
, int from_tty
)
763 extern int h8300smode
;
764 extern int h8300hmode
;
767 set_register_names ();
772 set_machine (char *args
, int from_tty
)
774 printf_unfiltered ("\"set machine\" must be followed by h8300, h8300h");
775 printf_unfiltered ("or h8300s");
776 help_list (setmemorylist
, "set memory ", -1, gdb_stdout
);
779 /* set_machine_hook is called as the exec file is being opened, but
780 before the symbol file is opened. This allows us to set the
781 h8300hmode flag based on the machine type specified in the exec
782 file. This in turn will cause subsequently defined pointer types
783 to be 16 or 32 bits as appropriate for the machine. */
786 set_machine_hook (char *filename
)
788 if (bfd_get_mach (exec_bfd
) == bfd_mach_h8300s
)
793 else if (bfd_get_mach (exec_bfd
) == bfd_mach_h8300h
)
803 set_register_names ();
807 _initialize_h8300m (void)
809 add_prefix_cmd ("machine", no_class
, set_machine
,
810 "set the machine type",
811 &setmemorylist
, "set machine ", 0,
814 add_cmd ("h8300", class_support
, h8300_command
,
815 "Set machine to be H8/300.", &setmemorylist
);
817 add_cmd ("h8300h", class_support
, h8300h_command
,
818 "Set machine to be H8/300H.", &setmemorylist
);
820 add_cmd ("h8300s", class_support
, h8300s_command
,
821 "Set machine to be H8/300S.", &setmemorylist
);
823 /* Add a hook to set the machine type when we're loading a file. */
825 specify_exec_file_hook (set_machine_hook
);
831 print_register_hook (int regno
)
839 read_relative_register_raw_bytes (regno
, b
);
840 l
= b
[REGISTER_VIRTUAL_SIZE (8) - 1];
841 printf_unfiltered ("\t");
842 printf_unfiltered ("I-%d - ", (l
& 0x80) != 0);
843 printf_unfiltered ("H-%d - ", (l
& 0x20) != 0);
848 printf_unfiltered ("N-%d ", N
);
849 printf_unfiltered ("Z-%d ", Z
);
850 printf_unfiltered ("V-%d ", V
);
851 printf_unfiltered ("C-%d ", C
);
853 printf_unfiltered ("u> ");
855 printf_unfiltered ("u<= ");
857 printf_unfiltered ("u>= ");
859 printf_unfiltered ("u< ");
861 printf_unfiltered ("!= ");
863 printf_unfiltered ("== ");
865 printf_unfiltered (">= ");
867 printf_unfiltered ("< ");
868 if ((Z
| (N
^ V
)) == 0)
869 printf_unfiltered ("> ");
870 if ((Z
| (N
^ V
)) == 1)
871 printf_unfiltered ("<= ");
876 _initialize_h8300_tdep (void)
878 tm_print_insn
= gdb_print_insn_h8300
;