1 /* Target-machine dependent code for Hitachi H8/300, for GDB.
2 Copyright (C) 1988, 1990, 1991 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
33 #include "gdb_string.h"
36 extern int h8300hmode
, h8300smode
;
41 #define UNSIGNED_SHORT(X) ((X) & 0xffff)
43 #define IS_PUSH(x) ((x & 0xfff0)==0x6df0)
44 #define IS_PUSH_FP(x) (x == 0x6df6)
45 #define IS_MOVE_FP(x) (x == 0x0d76 || x == 0x0ff6)
46 #define IS_MOV_SP_FP(x) (x == 0x0d76 || x == 0x0ff6)
47 #define IS_SUB2_SP(x) (x==0x1b87)
48 #define IS_SUB4_SP(x) (x==0x1b97)
49 #define IS_SUBL_SP(x) (x==0x7a37)
50 #define IS_MOVK_R5(x) (x==0x7905)
51 #define IS_SUB_R5SP(x) (x==0x1957)
54 /* The register names change depending on whether the h8300h processor
57 static char *original_register_names
[] = REGISTER_NAMES
;
59 static char *h8300h_register_names
[] =
60 {"er0", "er1", "er2", "er3", "er4", "er5", "er6",
61 "sp", "ccr","pc","cycles","tick","inst" };
63 char **h8300_register_names
= original_register_names
;
66 /* Local function declarations. */
68 static CORE_ADDR
examine_prologue ();
69 static void set_machine_hook
PARAMS ((char *filename
));
71 void h8300_frame_find_saved_regs ();
74 h8300_skip_prologue (start_pc
)
80 /* Skip past all push and stm insns. */
83 w
= read_memory_unsigned_integer (start_pc
, 2);
84 /* First look for push insns. */
85 if (w
== 0x0100 || w
== 0x0110 || w
== 0x0120 || w
== 0x0130)
87 w
= read_memory_unsigned_integer (start_pc
+ 2, 2);
93 start_pc
+= 2 + adjust
;
94 w
= read_memory_unsigned_integer (start_pc
, 2);
101 /* Skip past a move to FP, either word or long sized */
102 w
= read_memory_unsigned_integer (start_pc
, 2);
105 w
= read_memory_unsigned_integer (start_pc
+ 2, 2);
111 start_pc
+= 2 + adjust
;
112 w
= read_memory_unsigned_integer (start_pc
, 2);
115 /* Check for loading either a word constant into r5;
116 long versions are handled by the SUBL_SP below. */
120 w
= read_memory_unsigned_integer (start_pc
, 2);
123 /* Now check for subtracting r5 from sp, word sized only. */
126 start_pc
+= 2 + adjust
;
127 w
= read_memory_unsigned_integer (start_pc
, 2);
130 /* Check for subs #2 and subs #4. */
131 while (IS_SUB2_SP (w
) || IS_SUB4_SP (w
))
133 start_pc
+= 2 + adjust
;
134 w
= read_memory_unsigned_integer (start_pc
, 2);
137 /* Check for a 32bit subtract. */
139 start_pc
+= 6 + adjust
;
145 gdb_print_insn_h8300 (memaddr
, info
)
147 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 (thisframe
)
166 struct frame_info
*thisframe
;
168 if (PC_IN_CALL_DUMMY(thisframe
->pc
, thisframe
->frame
, thisframe
->frame
))
169 { /* initialize the from_pc now */
170 thisframe
->from_pc
= generic_read_register_dummy (thisframe
->pc
,
173 return thisframe
->frame
;
175 h8300_frame_find_saved_regs (thisframe
, (struct frame_saved_regs
*) 0);
176 return thisframe
->fsr
->regs
[SP_REGNUM
];
179 /* Put here the code to store, into a struct frame_saved_regs,
180 the addresses of the saved registers of frame described by FRAME_INFO.
181 This includes special registers such as pc and fp saved in special
182 ways in the stack frame. sp is even more special:
183 the address we return for it IS the sp for the next frame.
185 We cache the result of doing this in the frame_obstack, since it is
189 h8300_frame_find_saved_regs (fi
, fsr
)
190 struct frame_info
*fi
;
191 struct frame_saved_regs
*fsr
;
193 register struct frame_saved_regs
*cache_fsr
;
195 struct symtab_and_line sal
;
200 cache_fsr
= (struct frame_saved_regs
*)
201 frame_obstack_alloc (sizeof (struct frame_saved_regs
));
202 memset (cache_fsr
, '\0', sizeof (struct frame_saved_regs
));
206 if (PC_IN_CALL_DUMMY(fi
->pc
, fi
->frame
, fi
->frame
))
207 { /* no more to do. */
212 /* Find the start and end of the function prologue. If the PC
213 is in the function prologue, we only consider the part that
214 has executed already. */
216 ip
= get_pc_function_start (fi
->pc
);
217 sal
= find_pc_line (ip
, 0);
218 limit
= (sal
.end
&& sal
.end
< fi
->pc
) ? sal
.end
: fi
->pc
;
220 /* This will fill in fields in *fi as well as in cache_fsr. */
221 examine_prologue (ip
, limit
, fi
->frame
, cache_fsr
, fi
);
228 /* Fetch the instruction at ADDR, returning 0 if ADDR is beyond LIM or
229 is not the address of a valid instruction, the address of the next
230 instruction beyond ADDR otherwise. *PWORD1 receives the first word
231 of the instruction.*/
234 NEXT_PROLOGUE_INSN (addr
, lim
, pword1
)
242 read_memory (addr
, buf
, 2);
243 *pword1
= extract_signed_integer (buf
, 2);
250 /* Examine the prologue of a function. `ip' points to the first instruction.
251 `limit' is the limit of the prologue (e.g. the addr of the first
252 linenumber, or perhaps the program counter if we're stepping through).
253 `frame_sp' is the stack pointer value in use in this frame.
254 `fsr' is a pointer to a frame_saved_regs structure into which we put
255 info about the registers saved by this frame.
256 `fi' is a struct frame_info pointer; we fill in various fields in it
257 to reflect the offsets of the arg pointer and the locals pointer. */
260 examine_prologue (ip
, limit
, after_prolog_fp
, fsr
, fi
)
261 register CORE_ADDR ip
;
262 register CORE_ADDR limit
;
263 CORE_ADDR after_prolog_fp
;
264 struct frame_saved_regs
*fsr
;
265 struct frame_info
*fi
;
267 register CORE_ADDR next_ip
;
271 /* Number of things pushed onto stack, starts at 2/4, 'cause the
272 PC is already there */
273 unsigned int reg_save_depth
= h8300hmode
? 4 : 2;
275 unsigned int auto_depth
= 0; /* Number of bytes of autos */
277 char in_frame
[11]; /* One for each reg */
281 memset (in_frame
, 1, 11);
282 for (r
= 0; r
< 8; r
++)
286 if (after_prolog_fp
== 0)
288 after_prolog_fp
= read_register (SP_REGNUM
);
291 /* If the PC isn't valid, quit now. */
292 if (ip
== 0 || ip
& (h8300hmode
? ~0xffffff : ~0xffff))
295 next_ip
= NEXT_PROLOGUE_INSN (ip
, limit
, &insn_word
);
297 if (insn_word
== 0x0100)
299 insn_word
= read_memory_unsigned_integer (ip
+ 2, 2);
303 /* Skip over any fp push instructions */
304 fsr
->regs
[6] = after_prolog_fp
;
305 while (next_ip
&& IS_PUSH_FP (insn_word
))
307 ip
= next_ip
+ adjust
;
309 in_frame
[insn_word
& 0x7] = reg_save_depth
;
310 next_ip
= NEXT_PROLOGUE_INSN (ip
, limit
, &insn_word
);
311 reg_save_depth
+= 2 + adjust
;
314 /* Is this a move into the fp */
315 if (next_ip
&& IS_MOV_SP_FP (insn_word
))
318 next_ip
= NEXT_PROLOGUE_INSN (ip
, limit
, &insn_word
);
322 /* Skip over any stack adjustment, happens either with a number of
323 sub#2,sp or a mov #x,r5 sub r5,sp */
325 if (next_ip
&& (IS_SUB2_SP (insn_word
) || IS_SUB4_SP (insn_word
)))
327 while (next_ip
&& (IS_SUB2_SP (insn_word
) || IS_SUB4_SP (insn_word
)))
329 auto_depth
+= IS_SUB2_SP (insn_word
) ? 2 : 4;
331 next_ip
= NEXT_PROLOGUE_INSN (ip
, limit
, &insn_word
);
336 if (next_ip
&& IS_MOVK_R5 (insn_word
))
339 next_ip
= NEXT_PROLOGUE_INSN (ip
, limit
, &insn_word
);
340 auto_depth
+= insn_word
;
342 next_ip
= NEXT_PROLOGUE_INSN (next_ip
, limit
, &insn_word
);
343 auto_depth
+= insn_word
;
345 if (next_ip
&& IS_SUBL_SP (insn_word
))
348 auto_depth
+= read_memory_unsigned_integer (ip
, 4);
351 next_ip
= NEXT_PROLOGUE_INSN (ip
, limit
, &insn_word
);
355 /* Now examine the push insns to determine where everything lives
363 if (insn_word
== 0x0100)
366 next_ip
= NEXT_PROLOGUE_INSN (ip
, limit
, &insn_word
);
370 if (IS_PUSH (insn_word
))
373 next_ip
= NEXT_PROLOGUE_INSN (ip
, limit
, &insn_word
);
374 fsr
->regs
[r
] = after_prolog_fp
+ auto_depth
;
375 auto_depth
+= 2 + adjust
;
379 /* Now check for push multiple insns. */
380 if (insn_word
== 0x0110 || insn_word
== 0x0120 || insn_word
== 0x0130)
382 int count
= ((insn_word
>> 4) & 0xf) + 1;
386 next_ip
= NEXT_PROLOGUE_INSN (ip
, limit
, &insn_word
);
387 start
= insn_word
& 0x7;
389 for (i
= start
; i
<= start
+ count
; i
++)
391 fsr
->regs
[i
] = after_prolog_fp
+ auto_depth
;
398 /* The args are always reffed based from the stack pointer */
399 fi
->args_pointer
= after_prolog_fp
;
400 /* Locals are always reffed based from the fp */
401 fi
->locals_pointer
= after_prolog_fp
;
402 /* The PC is at a known place */
403 fi
->from_pc
= read_memory_unsigned_integer (after_prolog_fp
+ BINWORD
, BINWORD
);
405 /* Rememeber any others too */
406 in_frame
[PC_REGNUM
] = 0;
409 /* We keep the old FP in the SP spot */
410 fsr
->regs
[SP_REGNUM
] = read_memory_unsigned_integer (fsr
->regs
[6], BINWORD
);
412 fsr
->regs
[SP_REGNUM
] = after_prolog_fp
+ auto_depth
;
418 h8300_init_extra_frame_info (fromleaf
, fi
)
420 struct frame_info
*fi
;
422 fi
->fsr
= 0; /* Not yet allocated */
423 fi
->args_pointer
= 0; /* Unknown */
424 fi
->locals_pointer
= 0; /* Unknown */
426 if (PC_IN_CALL_DUMMY(fi
->pc
, fi
->frame
, fi
->frame
))
427 { /* anything special to do? */
432 /* Return the saved PC from this frame.
434 If the frame has a memory copy of SRP_REGNUM, use that. If not,
435 just use the register SRP_REGNUM itself. */
438 h8300_frame_saved_pc (frame
)
439 struct frame_info
*frame
;
441 if (PC_IN_CALL_DUMMY(frame
->pc
, frame
->frame
, frame
->frame
))
442 return generic_read_register_dummy (frame
->pc
, frame
->frame
, PC_REGNUM
);
444 return frame
->from_pc
;
448 frame_locals_address (fi
)
449 struct frame_info
*fi
;
451 if (PC_IN_CALL_DUMMY(fi
->pc
, fi
->frame
, fi
->frame
))
452 return (CORE_ADDR
) 0; /* Not sure what else to do... */
453 if (!fi
->locals_pointer
)
455 struct frame_saved_regs ignore
;
457 get_frame_saved_regs (fi
, &ignore
);
460 return fi
->locals_pointer
;
463 /* Return the address of the argument block for the frame
464 described by FI. Returns 0 if the address is unknown. */
467 frame_args_address (fi
)
468 struct frame_info
*fi
;
470 if (PC_IN_CALL_DUMMY(fi
->pc
, fi
->frame
, fi
->frame
))
471 return (CORE_ADDR
) 0; /* Not sure what else to do... */
472 if (!fi
->args_pointer
)
474 struct frame_saved_regs ignore
;
476 get_frame_saved_regs (fi
, &ignore
);
480 return fi
->args_pointer
;
483 /* Function: push_arguments
484 Setup the function arguments for calling a function in the inferior.
486 On the Hitachi H8/300 architecture, there are three registers (R0 to R2)
487 which are dedicated for passing function arguments. Up to the first
488 three arguments (depending on size) may go into these registers.
489 The rest go on the stack.
491 Arguments that are smaller than WORDSIZE bytes will still take up a
492 whole register or a whole WORDSIZE word on the stack, and will be
493 right-justified in the register or the stack word. This includes
494 chars and small aggregate types. Note that WORDSIZE depends on the
497 Arguments that are larger than WORDSIZE bytes will be split between
498 two or more registers as available, but will NOT be split between a
499 register and the stack.
501 An exceptional case exists for struct arguments (and possibly other
502 aggregates such as arrays) -- if the size is larger than WORDSIZE
503 bytes but not a multiple of WORDSIZE bytes. In this case the
504 argument is never split between the registers and the stack, but
505 instead is copied in its entirety onto the stack, AND also copied
506 into as many registers as there is room for. In other words, space
507 in registers permitting, two copies of the same argument are passed
508 in. As far as I can tell, only the one on the stack is used,
509 although that may be a function of the level of compiler
510 optimization. I suspect this is a compiler bug. Arguments of
511 these odd sizes are left-justified within the word (as opposed to
512 arguments smaller than WORDSIZE bytes, which are right-justified).
514 If the function is to return an aggregate type such as a struct,
515 the caller must allocate space into which the callee will copy the
516 return value. In this case, a pointer to the return value location
517 is passed into the callee in register R0, which displaces one of
518 the other arguments passed in via registers R0 to R2. */
521 h8300_push_arguments(nargs
, args
, sp
, struct_return
, struct_addr
)
525 unsigned char struct_return
;
526 CORE_ADDR struct_addr
;
528 int stack_align
, stack_alloc
, stack_offset
;
538 if (h8300hmode
|| h8300smode
)
549 /* first force sp to a n-byte alignment */
550 sp
= sp
& ~stack_align
;
552 /* Now make sure there's space on the stack */
553 for (argnum
= 0, stack_alloc
= 0;
554 argnum
< nargs
; argnum
++)
555 stack_alloc
+= ((TYPE_LENGTH(VALUE_TYPE(args
[argnum
])) + stack_align
)
557 sp
-= stack_alloc
; /* make room on stack for args */
558 /* we may over-allocate a little here, but that won't hurt anything */
560 argreg
= ARG0_REGNUM
;
561 if (struct_return
) /* "struct return" pointer takes up one argreg */
563 write_register (argreg
++, struct_addr
);
566 /* Now load as many as possible of the first arguments into
567 registers, and push the rest onto the stack. There are 3N bytes
568 in three registers available. Loop thru args from first to last. */
570 for (argnum
= 0, stack_offset
= 0; argnum
< nargs
; argnum
++)
572 type
= VALUE_TYPE (args
[argnum
]);
573 len
= TYPE_LENGTH (type
);
574 memset(valbuf
, 0, sizeof(valbuf
));
577 /* the purpose of this is to right-justify the value within the word */
578 memcpy(valbuf
+ (wordsize
- len
),
579 (char *) VALUE_CONTENTS (args
[argnum
]), len
);
583 val
= (char *) VALUE_CONTENTS (args
[argnum
]);
585 if (len
> (ARGLAST_REGNUM
+1 - argreg
) * REGISTER_RAW_SIZE(ARG0_REGNUM
) ||
586 (len
> wordsize
&& (len
& stack_align
) != 0))
587 { /* passed on the stack */
588 write_memory (sp
+ stack_offset
, val
,
589 len
< wordsize
? wordsize
: len
);
590 stack_offset
+= (len
+ stack_align
) & ~stack_align
;
592 /* NOTE WELL!!!!! This is not an "else if" clause!!!
593 That's because some *&^%$ things get passed on the stack
594 AND in the registers! */
595 if (len
<= (ARGLAST_REGNUM
+1 - argreg
) * REGISTER_RAW_SIZE(ARG0_REGNUM
))
597 { /* there's room in registers */
598 regval
= extract_address (val
, wordsize
);
599 write_register (argreg
, regval
);
608 /* Function: push_return_address
609 Setup the return address for a dummy frame, as called by
610 call_function_by_hand. Only necessary when you are using an
611 empty CALL_DUMMY, ie. the target will not actually be executing
612 a JSR/BSR instruction. */
615 h8300_push_return_address (pc
, sp
)
619 unsigned char buf
[4];
622 if (h8300hmode
|| h8300smode
)
628 store_unsigned_integer (buf
, wordsize
, CALL_DUMMY_ADDRESS ());
629 write_memory (sp
, buf
, wordsize
);
633 /* Function: pop_frame
634 Restore the machine to the state it had before the current frame
635 was created. Usually used either by the "RETURN" command, or by
636 call_function_by_hand after the dummy_frame is finished. */
642 struct frame_saved_regs fsr
;
643 struct frame_info
*frame
= get_current_frame ();
645 if (PC_IN_CALL_DUMMY(frame
->pc
, frame
->frame
, frame
->frame
))
647 generic_pop_dummy_frame();
651 get_frame_saved_regs (frame
, &fsr
);
653 for (regnum
= 0; regnum
< 8; regnum
++)
655 /* Don't forget SP_REGNUM is a frame_saved_regs struct is the
656 actual value we want, not the address of the value we want. */
657 if (fsr
.regs
[regnum
] && regnum
!= SP_REGNUM
)
658 write_register (regnum
,
659 read_memory_integer(fsr
.regs
[regnum
], BINWORD
));
660 else if (fsr
.regs
[regnum
] && regnum
== SP_REGNUM
)
661 write_register (regnum
, frame
->frame
+ 2 * BINWORD
);
664 /* Don't forget the update the PC too! */
665 write_pc (frame
->from_pc
);
667 flush_cached_frames ();
670 /* Function: extract_return_value
671 Figure out where in REGBUF the called function has left its return value.
672 Copy that into VALBUF. Be sure to account for CPU type. */
675 h8300_extract_return_value (type
, regbuf
, valbuf
)
682 if (h8300smode
|| h8300hmode
)
687 len
= TYPE_LENGTH(type
);
691 case 2: /* (short), (int) */
692 memcpy (valbuf
, regbuf
+ REGISTER_BYTE(0) + (wordsize
- len
), len
);
694 case 4: /* (long), (float) */
695 if (h8300smode
|| h8300hmode
)
697 memcpy (valbuf
, regbuf
+ REGISTER_BYTE(0), 4);
701 memcpy (valbuf
, regbuf
+ REGISTER_BYTE(0), 2);
702 memcpy (valbuf
+2, regbuf
+ REGISTER_BYTE(1), 2);
705 case 8: /* (double) (doesn't seem to happen, which is good,
706 because this almost certainly isn't right. */
707 error ("I don't know how a double is returned.");
712 /* Function: store_return_value
713 Place the appropriate value in the appropriate registers.
714 Primarily used by the RETURN command. */
717 h8300_store_return_value (type
, valbuf
)
721 int wordsize
, len
, regval
;
723 if (h8300hmode
|| h8300smode
)
728 len
= TYPE_LENGTH(type
);
731 case 2: /* short, int */
732 regval
= extract_address(valbuf
, len
);
733 write_register (0, regval
);
735 case 4: /* long, float */
736 regval
= extract_address(valbuf
, len
);
737 if (h8300smode
|| h8300hmode
)
739 write_register (0, regval
);
743 write_register (0, regval
>> 16);
744 write_register (1, regval
& 0xffff);
747 case 8: /* presumeably double, but doesn't seem to happen */
748 error ("I don't know how to return a double.");
753 /* Function: get_saved_register
754 Just call the generic_get_saved_register function. */
757 get_saved_register (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
)
761 struct frame_info
*frame
;
763 enum lval_type
*lval
;
765 generic_get_saved_register (raw_buffer
, optimized
, addrp
,
766 frame
, regnum
, lval
);
769 struct cmd_list_element
*setmemorylist
;
772 set_register_names ()
775 h8300_register_names
= h8300h_register_names
;
777 h8300_register_names
= original_register_names
;
781 h8300_command(args
, from_tty
)
783 extern int h8300hmode
;
786 set_register_names ();
790 h8300h_command(args
, from_tty
)
792 extern int h8300hmode
;
795 set_register_names ();
799 h8300s_command(args
, from_tty
)
801 extern int h8300smode
;
802 extern int h8300hmode
;
805 set_register_names ();
810 set_machine (args
, from_tty
)
814 printf_unfiltered ("\"set machine\" must be followed by h8300, h8300h");
815 printf_unfiltered ("or h8300s");
816 help_list (setmemorylist
, "set memory ", -1, gdb_stdout
);
819 /* set_machine_hook is called as the exec file is being opened, but
820 before the symbol file is opened. This allows us to set the
821 h8300hmode flag based on the machine type specified in the exec
822 file. This in turn will cause subsequently defined pointer types
823 to be 16 or 32 bits as appropriate for the machine. */
826 set_machine_hook (filename
)
829 if (bfd_get_mach (exec_bfd
) == bfd_mach_h8300s
)
835 if (bfd_get_mach (exec_bfd
) == bfd_mach_h8300h
)
845 set_register_names ();
849 _initialize_h8300m ()
851 add_prefix_cmd ("machine", no_class
, set_machine
,
852 "set the machine type",
853 &setmemorylist
, "set machine ", 0,
856 add_cmd ("h8300", class_support
, h8300_command
,
857 "Set machine to be H8/300.", &setmemorylist
);
859 add_cmd ("h8300h", class_support
, h8300h_command
,
860 "Set machine to be H8/300H.", &setmemorylist
);
862 add_cmd ("h8300s", class_support
, h8300s_command
,
863 "Set machine to be H8/300S.", &setmemorylist
);
865 /* Add a hook to set the machine type when we're loading a file. */
867 specify_exec_file_hook(set_machine_hook
);
873 print_register_hook (regno
)
881 read_relative_register_raw_bytes (regno
, b
);
882 l
= b
[REGISTER_VIRTUAL_SIZE(8) -1];
883 printf_unfiltered ("\t");
884 printf_unfiltered ("I-%d - ", (l
& 0x80) != 0);
885 printf_unfiltered ("H-%d - ", (l
& 0x20) != 0);
890 printf_unfiltered ("N-%d ", N
);
891 printf_unfiltered ("Z-%d ", Z
);
892 printf_unfiltered ("V-%d ", V
);
893 printf_unfiltered ("C-%d ", C
);
895 printf_unfiltered ("u> ");
897 printf_unfiltered ("u<= ");
899 printf_unfiltered ("u>= ");
901 printf_unfiltered ("u< ");
903 printf_unfiltered ("!= ");
905 printf_unfiltered ("== ");
907 printf_unfiltered (">= ");
909 printf_unfiltered ("< ");
910 if ((Z
| (N
^ V
)) == 0)
911 printf_unfiltered ("> ");
912 if ((Z
| (N
^ V
)) == 1)
913 printf_unfiltered ("<= ");
918 _initialize_h8300_tdep ()
920 tm_print_insn
= gdb_print_insn_h8300
;