1 /* Target-machine dependent code for Renesas H8/300, for GDB.
3 Copyright (C) 1988, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999,
4 2000, 2001, 2002, 2003, 2005, 2007, 2008 Free Software Foundation, Inc.
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 3 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, see <http://www.gnu.org/licenses/>. */
22 Contributed by Steve Chamberlain
28 #include "arch-utils.h"
32 #include "gdb_assert.h"
34 #include "dwarf2-frame.h"
35 #include "frame-base.h"
36 #include "frame-unwind.h"
40 E_R0_REGNUM
, E_ER0_REGNUM
= E_R0_REGNUM
, E_ARG0_REGNUM
= E_R0_REGNUM
,
41 E_RET0_REGNUM
= E_R0_REGNUM
,
42 E_R1_REGNUM
, E_ER1_REGNUM
= E_R1_REGNUM
, E_RET1_REGNUM
= E_R1_REGNUM
,
43 E_R2_REGNUM
, E_ER2_REGNUM
= E_R2_REGNUM
, E_ARGLAST_REGNUM
= E_R2_REGNUM
,
44 E_R3_REGNUM
, E_ER3_REGNUM
= E_R3_REGNUM
,
45 E_R4_REGNUM
, E_ER4_REGNUM
= E_R4_REGNUM
,
46 E_R5_REGNUM
, E_ER5_REGNUM
= E_R5_REGNUM
,
47 E_R6_REGNUM
, E_ER6_REGNUM
= E_R6_REGNUM
, E_FP_REGNUM
= E_R6_REGNUM
,
52 E_TICK_REGNUM
, E_EXR_REGNUM
= E_TICK_REGNUM
,
53 E_INST_REGNUM
, E_TICKS_REGNUM
= E_INST_REGNUM
,
61 #define H8300_MAX_NUM_REGS 18
63 #define E_PSEUDO_CCR_REGNUM(gdbarch) (gdbarch_num_regs (gdbarch))
64 #define E_PSEUDO_EXR_REGNUM(gdbarch) (gdbarch_num_regs (gdbarch)+1)
66 struct h8300_frame_cache
73 /* Flag showing that a frame has been created in the prologue code. */
76 /* Saved registers. */
77 CORE_ADDR saved_regs
[H8300_MAX_NUM_REGS
];
85 h8300_max_reg_size
= 4,
88 static int is_h8300hmode (struct gdbarch
*gdbarch
);
89 static int is_h8300smode (struct gdbarch
*gdbarch
);
90 static int is_h8300sxmode (struct gdbarch
*gdbarch
);
91 static int is_h8300_normal_mode (struct gdbarch
*gdbarch
);
93 #define BINWORD(gdbarch) ((is_h8300hmode (gdbarch) \
94 && !is_h8300_normal_mode (gdbarch)) \
95 ? h8300h_reg_size : h8300_reg_size)
98 h8300_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
100 return frame_unwind_register_unsigned (next_frame
, E_PC_REGNUM
);
104 h8300_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
106 return frame_unwind_register_unsigned (next_frame
, E_SP_REGNUM
);
109 static struct frame_id
110 h8300_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
112 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, E_SP_REGNUM
);
113 return frame_id_build (sp
, get_frame_pc (this_frame
));
118 /* Allocate and initialize a frame cache. */
121 h8300_init_frame_cache (struct gdbarch
*gdbarch
,
122 struct h8300_frame_cache
*cache
)
128 cache
->sp_offset
= 0;
131 /* Frameless until proven otherwise. */
134 /* Saved registers. We initialize these to -1 since zero is a valid
135 offset (that's where %fp is supposed to be stored). */
136 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
137 cache
->saved_regs
[i
] = -1;
140 #define IS_MOVB_RnRm(x) (((x) & 0xff88) == 0x0c88)
141 #define IS_MOVW_RnRm(x) (((x) & 0xff88) == 0x0d00)
142 #define IS_MOVL_RnRm(x) (((x) & 0xff88) == 0x0f80)
143 #define IS_MOVB_Rn16_SP(x) (((x) & 0xfff0) == 0x6ee0)
144 #define IS_MOVB_EXT(x) ((x) == 0x7860)
145 #define IS_MOVB_Rn24_SP(x) (((x) & 0xfff0) == 0x6aa0)
146 #define IS_MOVW_Rn16_SP(x) (((x) & 0xfff0) == 0x6fe0)
147 #define IS_MOVW_EXT(x) ((x) == 0x78e0)
148 #define IS_MOVW_Rn24_SP(x) (((x) & 0xfff0) == 0x6ba0)
149 /* Same instructions as mov.w, just prefixed with 0x0100 */
150 #define IS_MOVL_PRE(x) ((x) == 0x0100)
151 #define IS_MOVL_Rn16_SP(x) (((x) & 0xfff0) == 0x6fe0)
152 #define IS_MOVL_EXT(x) ((x) == 0x78e0)
153 #define IS_MOVL_Rn24_SP(x) (((x) & 0xfff0) == 0x6ba0)
155 #define IS_PUSHFP_MOVESPFP(x) ((x) == 0x6df60d76)
156 #define IS_PUSH_FP(x) ((x) == 0x01006df6)
157 #define IS_MOV_SP_FP(x) ((x) == 0x0ff6)
158 #define IS_SUB2_SP(x) ((x) == 0x1b87)
159 #define IS_SUB4_SP(x) ((x) == 0x1b97)
160 #define IS_ADD_IMM_SP(x) ((x) == 0x7a1f)
161 #define IS_SUB_IMM_SP(x) ((x) == 0x7a3f)
162 #define IS_SUBL4_SP(x) ((x) == 0x1acf)
163 #define IS_MOV_IMM_Rn(x) (((x) & 0xfff0) == 0x7905)
164 #define IS_SUB_RnSP(x) (((x) & 0xff0f) == 0x1907)
165 #define IS_ADD_RnSP(x) (((x) & 0xff0f) == 0x0907)
166 #define IS_PUSH(x) (((x) & 0xfff0) == 0x6df0)
168 /* If the instruction at PC is an argument register spill, return its
169 length. Otherwise, return zero.
171 An argument register spill is an instruction that moves an argument
172 from the register in which it was passed to the stack slot in which
173 it really lives. It is a byte, word, or longword move from an
174 argument register to a negative offset from the frame pointer.
176 CV, 2003-06-16: Or, in optimized code or when the `register' qualifier
177 is used, it could be a byte, word or long move to registers r3-r5. */
180 h8300_is_argument_spill (CORE_ADDR pc
)
182 int w
= read_memory_unsigned_integer (pc
, 2);
184 if ((IS_MOVB_RnRm (w
) || IS_MOVW_RnRm (w
) || IS_MOVL_RnRm (w
))
185 && (w
& 0x70) <= 0x20 /* Rs is R0, R1 or R2 */
186 && (w
& 0x7) >= 0x3 && (w
& 0x7) <= 0x5) /* Rd is R3, R4 or R5 */
189 if (IS_MOVB_Rn16_SP (w
)
190 && 8 <= (w
& 0xf) && (w
& 0xf) <= 10) /* Rs is R0L, R1L, or R2L */
192 if (read_memory_integer (pc
+ 2, 2) < 0) /* ... and d:16 is negative. */
195 else if (IS_MOVB_EXT (w
))
197 if (IS_MOVB_Rn24_SP (read_memory_unsigned_integer (pc
+ 2, 2)))
199 LONGEST disp
= read_memory_integer (pc
+ 4, 4);
201 /* ... and d:24 is negative. */
202 if (disp
< 0 && disp
> 0xffffff)
206 else if (IS_MOVW_Rn16_SP (w
)
207 && (w
& 0xf) <= 2) /* Rs is R0, R1, or R2 */
209 /* ... and d:16 is negative. */
210 if (read_memory_integer (pc
+ 2, 2) < 0)
213 else if (IS_MOVW_EXT (w
))
215 if (IS_MOVW_Rn24_SP (read_memory_unsigned_integer (pc
+ 2, 2)))
217 LONGEST disp
= read_memory_integer (pc
+ 4, 4);
219 /* ... and d:24 is negative. */
220 if (disp
< 0 && disp
> 0xffffff)
224 else if (IS_MOVL_PRE (w
))
226 int w2
= read_memory_integer (pc
+ 2, 2);
228 if (IS_MOVL_Rn16_SP (w2
)
229 && (w2
& 0xf) <= 2) /* Rs is ER0, ER1, or ER2 */
231 /* ... and d:16 is negative. */
232 if (read_memory_integer (pc
+ 4, 2) < 0)
235 else if (IS_MOVL_EXT (w2
))
237 int w3
= read_memory_integer (pc
+ 4, 2);
239 if (IS_MOVL_Rn24_SP (read_memory_integer (pc
+ 4, 2)))
241 LONGEST disp
= read_memory_integer (pc
+ 6, 4);
243 /* ... and d:24 is negative. */
244 if (disp
< 0 && disp
> 0xffffff)
253 /* Do a full analysis of the prologue at PC and update CACHE
254 accordingly. Bail out early if CURRENT_PC is reached. Return the
255 address where the analysis stopped.
257 We handle all cases that can be generated by gcc.
259 For allocating a stack frame:
280 For saving registers:
289 h8300_analyze_prologue (CORE_ADDR pc
, CORE_ADDR current_pc
,
290 struct h8300_frame_cache
*cache
)
293 int regno
, i
, spill_size
;
295 cache
->sp_offset
= 0;
297 if (pc
>= current_pc
)
300 op
= read_memory_unsigned_integer (pc
, 4);
302 if (IS_PUSHFP_MOVESPFP (op
))
304 cache
->saved_regs
[E_FP_REGNUM
] = 0;
308 else if (IS_PUSH_FP (op
))
310 cache
->saved_regs
[E_FP_REGNUM
] = 0;
312 if (pc
>= current_pc
)
314 op
= read_memory_unsigned_integer (pc
, 2);
315 if (IS_MOV_SP_FP (op
))
322 while (pc
< current_pc
)
324 op
= read_memory_unsigned_integer (pc
, 2);
327 cache
->sp_offset
+= 2;
330 else if (IS_SUB4_SP (op
))
332 cache
->sp_offset
+= 4;
335 else if (IS_ADD_IMM_SP (op
))
337 cache
->sp_offset
+= -read_memory_integer (pc
+ 2, 2);
340 else if (IS_SUB_IMM_SP (op
))
342 cache
->sp_offset
+= read_memory_integer (pc
+ 2, 2);
345 else if (IS_SUBL4_SP (op
))
347 cache
->sp_offset
+= 4;
350 else if (IS_MOV_IMM_Rn (op
))
352 int offset
= read_memory_integer (pc
+ 2, 2);
354 op
= read_memory_unsigned_integer (pc
+ 4, 2);
355 if (IS_ADD_RnSP (op
) && (op
& 0x00f0) == regno
)
357 cache
->sp_offset
-= offset
;
360 else if (IS_SUB_RnSP (op
) && (op
& 0x00f0) == regno
)
362 cache
->sp_offset
+= offset
;
368 else if (IS_PUSH (op
))
371 cache
->sp_offset
+= 2;
372 cache
->saved_regs
[regno
] = cache
->sp_offset
;
375 else if (op
== 0x0100)
377 op
= read_memory_unsigned_integer (pc
+ 2, 2);
381 cache
->sp_offset
+= 4;
382 cache
->saved_regs
[regno
] = cache
->sp_offset
;
388 else if ((op
& 0xffcf) == 0x0100)
391 op1
= read_memory_unsigned_integer (pc
+ 2, 2);
394 /* Since the prefix is 0x01x0, this is not a simple pushm but a
395 stm.l reglist,@-sp */
396 i
= ((op
& 0x0030) >> 4) + 1;
397 regno
= op1
& 0x000f;
398 for (; i
> 0; regno
++, --i
)
400 cache
->sp_offset
+= 4;
401 cache
->saved_regs
[regno
] = cache
->sp_offset
;
412 /* Check for spilling an argument register to the stack frame.
413 This could also be an initializing store from non-prologue code,
414 but I don't think there's any harm in skipping that. */
415 while ((spill_size
= h8300_is_argument_spill (pc
)) > 0
416 && pc
+ spill_size
<= current_pc
)
422 static struct h8300_frame_cache
*
423 h8300_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
425 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
426 struct h8300_frame_cache
*cache
;
429 CORE_ADDR current_pc
;
434 cache
= FRAME_OBSTACK_ZALLOC (struct h8300_frame_cache
);
435 h8300_init_frame_cache (gdbarch
, cache
);
438 /* In principle, for normal frames, %fp holds the frame pointer,
439 which holds the base address for the current stack frame.
440 However, for functions that don't need it, the frame pointer is
441 optional. For these "frameless" functions the frame pointer is
442 actually the frame pointer of the calling frame. */
444 cache
->base
= get_frame_register_unsigned (this_frame
, E_FP_REGNUM
);
445 if (cache
->base
== 0)
448 cache
->saved_regs
[E_PC_REGNUM
] = -BINWORD (gdbarch
);
450 cache
->pc
= get_frame_func (this_frame
);
451 current_pc
= get_frame_pc (this_frame
);
453 h8300_analyze_prologue (cache
->pc
, current_pc
, cache
);
457 /* We didn't find a valid frame, which means that CACHE->base
458 currently holds the frame pointer for our calling frame. If
459 we're at the start of a function, or somewhere half-way its
460 prologue, the function's frame probably hasn't been fully
461 setup yet. Try to reconstruct the base address for the stack
462 frame by looking at the stack pointer. For truly "frameless"
463 functions this might work too. */
465 cache
->base
= get_frame_register_unsigned (this_frame
, E_SP_REGNUM
)
467 cache
->saved_sp
= cache
->base
+ BINWORD (gdbarch
);
468 cache
->saved_regs
[E_PC_REGNUM
] = 0;
472 cache
->saved_sp
= cache
->base
+ 2 * BINWORD (gdbarch
);
473 cache
->saved_regs
[E_PC_REGNUM
] = -BINWORD (gdbarch
);
476 /* Adjust all the saved registers such that they contain addresses
477 instead of offsets. */
478 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
479 if (cache
->saved_regs
[i
] != -1)
480 cache
->saved_regs
[i
] = cache
->base
- cache
->saved_regs
[i
];
486 h8300_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
487 struct frame_id
*this_id
)
489 struct h8300_frame_cache
*cache
=
490 h8300_frame_cache (this_frame
, this_cache
);
492 /* This marks the outermost frame. */
493 if (cache
->base
== 0)
496 *this_id
= frame_id_build (cache
->saved_sp
, cache
->pc
);
499 static struct value
*
500 h8300_frame_prev_register (struct frame_info
*this_frame
, void **this_cache
,
503 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
504 struct h8300_frame_cache
*cache
=
505 h8300_frame_cache (this_frame
, this_cache
);
507 gdb_assert (regnum
>= 0);
509 if (regnum
== E_SP_REGNUM
&& cache
->saved_sp
)
510 return frame_unwind_got_constant (this_frame
, regnum
, cache
->saved_sp
);
512 if (regnum
< gdbarch_num_regs (gdbarch
)
513 && cache
->saved_regs
[regnum
] != -1)
514 return frame_unwind_got_memory (this_frame
, regnum
,
515 cache
->saved_regs
[regnum
]);
517 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
520 static const struct frame_unwind h8300_frame_unwind
= {
523 h8300_frame_prev_register
,
525 default_frame_sniffer
529 h8300_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
531 struct h8300_frame_cache
*cache
= h8300_frame_cache (this_frame
, this_cache
);
535 static const struct frame_base h8300_frame_base
= {
537 h8300_frame_base_address
,
538 h8300_frame_base_address
,
539 h8300_frame_base_address
543 h8300_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
545 CORE_ADDR func_addr
= 0 , func_end
= 0;
547 if (find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
549 struct symtab_and_line sal
;
550 struct h8300_frame_cache cache
;
552 /* Found a function. */
553 sal
= find_pc_line (func_addr
, 0);
554 if (sal
.end
&& sal
.end
< func_end
)
555 /* Found a line number, use it as end of prologue. */
558 /* No useable line symbol. Use prologue parsing method. */
559 h8300_init_frame_cache (gdbarch
, &cache
);
560 return h8300_analyze_prologue (func_addr
, func_end
, &cache
);
563 /* No function symbol -- just return the PC. */
564 return (CORE_ADDR
) pc
;
567 /* Function: push_dummy_call
568 Setup the function arguments for calling a function in the inferior.
569 In this discussion, a `word' is 16 bits on the H8/300s, and 32 bits
572 There are actually two ABI's here: -mquickcall (the default) and
573 -mno-quickcall. With -mno-quickcall, all arguments are passed on
574 the stack after the return address, word-aligned. With
575 -mquickcall, GCC tries to use r0 -- r2 to pass registers. Since
576 GCC doesn't indicate in the object file which ABI was used to
577 compile it, GDB only supports the default --- -mquickcall.
579 Here are the rules for -mquickcall, in detail:
581 Each argument, whether scalar or aggregate, is padded to occupy a
582 whole number of words. Arguments smaller than a word are padded at
583 the most significant end; those larger than a word are padded at
584 the least significant end.
586 The initial arguments are passed in r0 -- r2. Earlier arguments go in
587 lower-numbered registers. Multi-word arguments are passed in
588 consecutive registers, with the most significant end in the
589 lower-numbered register.
591 If an argument doesn't fit entirely in the remaining registers, it
592 is passed entirely on the stack. Stack arguments begin just after
593 the return address. Once an argument has overflowed onto the stack
594 this way, all subsequent arguments are passed on the stack.
596 The above rule has odd consequences. For example, on the h8/300s,
597 if a function takes two longs and an int as arguments:
598 - the first long will be passed in r0/r1,
599 - the second long will be passed entirely on the stack, since it
601 - and the int will be passed on the stack, even though it could fit
604 A weird exception: if an argument is larger than a word, but not a
605 whole number of words in length (before padding), it is passed on
606 the stack following the rules for stack arguments above, even if
607 there are sufficient registers available to hold it. Stranger
608 still, the argument registers are still `used up' --- even though
609 there's nothing in them.
611 So, for example, on the h8/300s, if a function expects a three-byte
612 structure and an int, the structure will go on the stack, and the
613 int will go in r2, not r0.
615 If the function returns an aggregate type (struct, union, or class)
616 by value, the caller must allocate space to hold the return value,
617 and pass the callee a pointer to this space as an invisible first
620 For varargs functions, the last fixed argument and all the variable
621 arguments are always passed on the stack. This means that calls to
622 varargs functions don't work properly unless there is a prototype
625 Basically, this ABI is not good, for the following reasons:
626 - You can't call vararg functions properly unless a prototype is in scope.
627 - Structure passing is inconsistent, to no purpose I can see.
628 - It often wastes argument registers, of which there are only three
632 h8300_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
633 struct regcache
*regcache
, CORE_ADDR bp_addr
,
634 int nargs
, struct value
**args
, CORE_ADDR sp
,
635 int struct_return
, CORE_ADDR struct_addr
)
637 int stack_alloc
= 0, stack_offset
= 0;
638 int wordsize
= BINWORD (gdbarch
);
639 int reg
= E_ARG0_REGNUM
;
642 /* First, make sure the stack is properly aligned. */
643 sp
= align_down (sp
, wordsize
);
645 /* Now make sure there's space on the stack for the arguments. We
646 may over-allocate a little here, but that won't hurt anything. */
647 for (argument
= 0; argument
< nargs
; argument
++)
648 stack_alloc
+= align_up (TYPE_LENGTH (value_type (args
[argument
])),
652 /* Now load as many arguments as possible into registers, and push
653 the rest onto the stack.
654 If we're returning a structure by value, then we must pass a
655 pointer to the buffer for the return value as an invisible first
658 regcache_cooked_write_unsigned (regcache
, reg
++, struct_addr
);
660 for (argument
= 0; argument
< nargs
; argument
++)
662 struct type
*type
= value_type (args
[argument
]);
663 int len
= TYPE_LENGTH (type
);
664 char *contents
= (char *) value_contents (args
[argument
]);
666 /* Pad the argument appropriately. */
667 int padded_len
= align_up (len
, wordsize
);
668 gdb_byte
*padded
= alloca (padded_len
);
670 memset (padded
, 0, padded_len
);
671 memcpy (len
< wordsize
? padded
+ padded_len
- len
: padded
,
674 /* Could the argument fit in the remaining registers? */
675 if (padded_len
<= (E_ARGLAST_REGNUM
- reg
+ 1) * wordsize
)
677 /* Are we going to pass it on the stack anyway, for no good
679 if (len
> wordsize
&& len
% wordsize
)
681 /* I feel so unclean. */
682 write_memory (sp
+ stack_offset
, padded
, padded_len
);
683 stack_offset
+= padded_len
;
685 /* That's right --- even though we passed the argument
686 on the stack, we consume the registers anyway! Love
688 reg
+= padded_len
/ wordsize
;
692 /* Heavens to Betsy --- it's really going in registers!
693 It would be nice if we could use write_register_bytes
694 here, but on the h8/300s, there are gaps between
695 the registers in the register file. */
698 for (offset
= 0; offset
< padded_len
; offset
+= wordsize
)
700 ULONGEST word
= extract_unsigned_integer (padded
+ offset
,
702 regcache_cooked_write_unsigned (regcache
, reg
++, word
);
708 /* It doesn't fit in registers! Onto the stack it goes. */
709 write_memory (sp
+ stack_offset
, padded
, padded_len
);
710 stack_offset
+= padded_len
;
712 /* Once one argument has spilled onto the stack, all
713 subsequent arguments go on the stack. */
714 reg
= E_ARGLAST_REGNUM
+ 1;
718 /* Store return address. */
720 write_memory_unsigned_integer (sp
, wordsize
, bp_addr
);
722 /* Update stack pointer. */
723 regcache_cooked_write_unsigned (regcache
, E_SP_REGNUM
, sp
);
725 /* Return the new stack pointer minus the return address slot since
726 that's what DWARF2/GCC uses as the frame's CFA. */
727 return sp
+ wordsize
;
730 /* Function: extract_return_value
731 Figure out where in REGBUF the called function has left its return value.
732 Copy that into VALBUF. Be sure to account for CPU type. */
735 h8300_extract_return_value (struct type
*type
, struct regcache
*regcache
,
738 int len
= TYPE_LENGTH (type
);
745 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &c
);
746 store_unsigned_integer (valbuf
, len
, c
);
748 case 4: /* Needs two registers on plain H8/300 */
749 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &c
);
750 store_unsigned_integer (valbuf
, 2, c
);
751 regcache_cooked_read_unsigned (regcache
, E_RET1_REGNUM
, &c
);
752 store_unsigned_integer ((void *) ((char *) valbuf
+ 2), 2, c
);
754 case 8: /* long long is now 8 bytes. */
755 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
757 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &addr
);
758 c
= read_memory_unsigned_integer ((CORE_ADDR
) addr
, len
);
759 store_unsigned_integer (valbuf
, len
, c
);
763 error ("I don't know how this 8 byte value is returned.");
770 h8300h_extract_return_value (struct type
*type
, struct regcache
*regcache
,
773 int len
= TYPE_LENGTH (type
);
781 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &c
);
782 store_unsigned_integer (valbuf
, len
, c
);
784 case 8: /* long long is now 8 bytes. */
785 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
787 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &c
);
788 store_unsigned_integer (valbuf
, 4, c
);
789 regcache_cooked_read_unsigned (regcache
, E_RET1_REGNUM
, &c
);
790 store_unsigned_integer ((void *) ((char *) valbuf
+ 4), 4, c
);
794 error ("I don't know how this 8 byte value is returned.");
801 h8300_use_struct_convention (struct type
*value_type
)
803 /* Types of 1, 2 or 4 bytes are returned in R0/R1, everything else on the
806 if (TYPE_CODE (value_type
) == TYPE_CODE_STRUCT
807 || TYPE_CODE (value_type
) == TYPE_CODE_UNION
)
809 return !(TYPE_LENGTH (value_type
) == 1
810 || TYPE_LENGTH (value_type
) == 2
811 || TYPE_LENGTH (value_type
) == 4);
815 h8300h_use_struct_convention (struct type
*value_type
)
817 /* Types of 1, 2 or 4 bytes are returned in R0, INT types of 8 bytes are
818 returned in R0/R1, everything else on the stack. */
819 if (TYPE_CODE (value_type
) == TYPE_CODE_STRUCT
820 || TYPE_CODE (value_type
) == TYPE_CODE_UNION
)
822 return !(TYPE_LENGTH (value_type
) == 1
823 || TYPE_LENGTH (value_type
) == 2
824 || TYPE_LENGTH (value_type
) == 4
825 || (TYPE_LENGTH (value_type
) == 8
826 && TYPE_CODE (value_type
) == TYPE_CODE_INT
));
829 /* Function: store_return_value
830 Place the appropriate value in the appropriate registers.
831 Primarily used by the RETURN command. */
834 h8300_store_return_value (struct type
*type
, struct regcache
*regcache
,
837 int len
= TYPE_LENGTH (type
);
843 case 2: /* short... */
844 val
= extract_unsigned_integer (valbuf
, len
);
845 regcache_cooked_write_unsigned (regcache
, E_RET0_REGNUM
, val
);
847 case 4: /* long, float */
848 val
= extract_unsigned_integer (valbuf
, len
);
849 regcache_cooked_write_unsigned (regcache
, E_RET0_REGNUM
,
850 (val
>> 16) & 0xffff);
851 regcache_cooked_write_unsigned (regcache
, E_RET1_REGNUM
, val
& 0xffff);
853 case 8: /* long long, double and long double are all defined
854 as 4 byte types so far so this shouldn't happen. */
855 error ("I don't know how to return an 8 byte value.");
861 h8300h_store_return_value (struct type
*type
, struct regcache
*regcache
,
864 int len
= TYPE_LENGTH (type
);
871 case 4: /* long, float */
872 val
= extract_unsigned_integer (valbuf
, len
);
873 regcache_cooked_write_unsigned (regcache
, E_RET0_REGNUM
, val
);
876 val
= extract_unsigned_integer (valbuf
, len
);
877 regcache_cooked_write_unsigned (regcache
, E_RET0_REGNUM
,
878 (val
>> 32) & 0xffffffff);
879 regcache_cooked_write_unsigned (regcache
, E_RET1_REGNUM
,
885 static enum return_value_convention
886 h8300_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
887 struct type
*type
, struct regcache
*regcache
,
888 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
890 if (h8300_use_struct_convention (type
))
891 return RETURN_VALUE_STRUCT_CONVENTION
;
893 h8300_store_return_value (type
, regcache
, writebuf
);
895 h8300_extract_return_value (type
, regcache
, readbuf
);
896 return RETURN_VALUE_REGISTER_CONVENTION
;
899 static enum return_value_convention
900 h8300h_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
901 struct type
*type
, struct regcache
*regcache
,
902 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
904 if (h8300h_use_struct_convention (type
))
910 regcache_raw_read_unsigned (regcache
, E_R0_REGNUM
, &addr
);
911 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
914 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
917 h8300h_store_return_value (type
, regcache
, writebuf
);
919 h8300h_extract_return_value (type
, regcache
, readbuf
);
920 return RETURN_VALUE_REGISTER_CONVENTION
;
923 static struct cmd_list_element
*setmachinelist
;
926 h8300_register_name (struct gdbarch
*gdbarch
, int regno
)
928 /* The register names change depending on which h8300 processor
930 static char *register_names
[] = {
931 "r0", "r1", "r2", "r3", "r4", "r5", "r6",
932 "sp", "", "pc", "cycles", "tick", "inst",
933 "ccr", /* pseudo register */
936 || regno
>= (sizeof (register_names
) / sizeof (*register_names
)))
937 internal_error (__FILE__
, __LINE__
,
938 "h8300_register_name: illegal register number %d", regno
);
940 return register_names
[regno
];
944 h8300s_register_name (struct gdbarch
*gdbarch
, int regno
)
946 static char *register_names
[] = {
947 "er0", "er1", "er2", "er3", "er4", "er5", "er6",
948 "sp", "", "pc", "cycles", "", "tick", "inst",
950 "ccr", "exr" /* pseudo registers */
953 || regno
>= (sizeof (register_names
) / sizeof (*register_names
)))
954 internal_error (__FILE__
, __LINE__
,
955 "h8300s_register_name: illegal register number %d",
958 return register_names
[regno
];
962 h8300sx_register_name (struct gdbarch
*gdbarch
, int regno
)
964 static char *register_names
[] = {
965 "er0", "er1", "er2", "er3", "er4", "er5", "er6",
966 "sp", "", "pc", "cycles", "", "tick", "inst",
967 "mach", "macl", "sbr", "vbr",
968 "ccr", "exr" /* pseudo registers */
971 || regno
>= (sizeof (register_names
) / sizeof (*register_names
)))
972 internal_error (__FILE__
, __LINE__
,
973 "h8300sx_register_name: illegal register number %d",
976 return register_names
[regno
];
980 h8300_print_register (struct gdbarch
*gdbarch
, struct ui_file
*file
,
981 struct frame_info
*frame
, int regno
)
984 const char *name
= gdbarch_register_name (gdbarch
, regno
);
989 rval
= get_frame_register_signed (frame
, regno
);
991 fprintf_filtered (file
, "%-14s ", name
);
992 if ((regno
== E_PSEUDO_CCR_REGNUM (gdbarch
)) || \
993 (regno
== E_PSEUDO_EXR_REGNUM (gdbarch
) && is_h8300smode (gdbarch
)))
995 fprintf_filtered (file
, "0x%02x ", (unsigned char) rval
);
996 print_longest (file
, 'u', 1, rval
);
1000 fprintf_filtered (file
, "0x%s ", phex ((ULONGEST
) rval
,
1001 BINWORD (gdbarch
)));
1002 print_longest (file
, 'd', 1, rval
);
1004 if (regno
== E_PSEUDO_CCR_REGNUM (gdbarch
))
1008 unsigned char l
= rval
& 0xff;
1009 fprintf_filtered (file
, "\t");
1010 fprintf_filtered (file
, "I-%d ", (l
& 0x80) != 0);
1011 fprintf_filtered (file
, "UI-%d ", (l
& 0x40) != 0);
1012 fprintf_filtered (file
, "H-%d ", (l
& 0x20) != 0);
1013 fprintf_filtered (file
, "U-%d ", (l
& 0x10) != 0);
1018 fprintf_filtered (file
, "N-%d ", N
);
1019 fprintf_filtered (file
, "Z-%d ", Z
);
1020 fprintf_filtered (file
, "V-%d ", V
);
1021 fprintf_filtered (file
, "C-%d ", C
);
1023 fprintf_filtered (file
, "u> ");
1025 fprintf_filtered (file
, "u<= ");
1027 fprintf_filtered (file
, "u>= ");
1029 fprintf_filtered (file
, "u< ");
1031 fprintf_filtered (file
, "!= ");
1033 fprintf_filtered (file
, "== ");
1035 fprintf_filtered (file
, ">= ");
1037 fprintf_filtered (file
, "< ");
1038 if ((Z
| (N
^ V
)) == 0)
1039 fprintf_filtered (file
, "> ");
1040 if ((Z
| (N
^ V
)) == 1)
1041 fprintf_filtered (file
, "<= ");
1043 else if (regno
== E_PSEUDO_EXR_REGNUM (gdbarch
) && is_h8300smode (gdbarch
))
1046 unsigned char l
= rval
& 0xff;
1047 fprintf_filtered (file
, "\t");
1048 fprintf_filtered (file
, "T-%d - - - ", (l
& 0x80) != 0);
1049 fprintf_filtered (file
, "I2-%d ", (l
& 4) != 0);
1050 fprintf_filtered (file
, "I1-%d ", (l
& 2) != 0);
1051 fprintf_filtered (file
, "I0-%d", (l
& 1) != 0);
1053 fprintf_filtered (file
, "\n");
1057 h8300_print_registers_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
1058 struct frame_info
*frame
, int regno
, int cpregs
)
1062 for (regno
= E_R0_REGNUM
; regno
<= E_SP_REGNUM
; ++regno
)
1063 h8300_print_register (gdbarch
, file
, frame
, regno
);
1064 h8300_print_register (gdbarch
, file
, frame
,
1065 E_PSEUDO_CCR_REGNUM (gdbarch
));
1066 h8300_print_register (gdbarch
, file
, frame
, E_PC_REGNUM
);
1067 if (is_h8300smode (gdbarch
))
1069 h8300_print_register (gdbarch
, file
, frame
,
1070 E_PSEUDO_EXR_REGNUM (gdbarch
));
1071 if (is_h8300sxmode (gdbarch
))
1073 h8300_print_register (gdbarch
, file
, frame
, E_SBR_REGNUM
);
1074 h8300_print_register (gdbarch
, file
, frame
, E_VBR_REGNUM
);
1076 h8300_print_register (gdbarch
, file
, frame
, E_MACH_REGNUM
);
1077 h8300_print_register (gdbarch
, file
, frame
, E_MACL_REGNUM
);
1078 h8300_print_register (gdbarch
, file
, frame
, E_CYCLES_REGNUM
);
1079 h8300_print_register (gdbarch
, file
, frame
, E_TICKS_REGNUM
);
1080 h8300_print_register (gdbarch
, file
, frame
, E_INSTS_REGNUM
);
1084 h8300_print_register (gdbarch
, file
, frame
, E_CYCLES_REGNUM
);
1085 h8300_print_register (gdbarch
, file
, frame
, E_TICK_REGNUM
);
1086 h8300_print_register (gdbarch
, file
, frame
, E_INST_REGNUM
);
1091 if (regno
== E_CCR_REGNUM
)
1092 h8300_print_register (gdbarch
, file
, frame
,
1093 E_PSEUDO_CCR_REGNUM (gdbarch
));
1094 else if (regno
== E_PSEUDO_EXR_REGNUM (gdbarch
)
1095 && is_h8300smode (gdbarch
))
1096 h8300_print_register (gdbarch
, file
, frame
,
1097 E_PSEUDO_EXR_REGNUM (gdbarch
));
1099 h8300_print_register (gdbarch
, file
, frame
, regno
);
1103 static struct type
*
1104 h8300_register_type (struct gdbarch
*gdbarch
, int regno
)
1106 if (regno
< 0 || regno
>= gdbarch_num_regs (gdbarch
)
1107 + gdbarch_num_pseudo_regs (gdbarch
))
1108 internal_error (__FILE__
, __LINE__
,
1109 "h8300_register_type: illegal register number %d", regno
);
1115 return builtin_type (gdbarch
)->builtin_func_ptr
;
1118 return builtin_type (gdbarch
)->builtin_data_ptr
;
1120 if (regno
== E_PSEUDO_CCR_REGNUM (gdbarch
))
1121 return builtin_type_uint8
;
1122 else if (regno
== E_PSEUDO_EXR_REGNUM (gdbarch
))
1123 return builtin_type_uint8
;
1124 else if (is_h8300hmode (gdbarch
))
1125 return builtin_type_int32
;
1127 return builtin_type_int16
;
1133 h8300_pseudo_register_read (struct gdbarch
*gdbarch
,
1134 struct regcache
*regcache
, int regno
,
1137 if (regno
== E_PSEUDO_CCR_REGNUM (gdbarch
))
1138 regcache_raw_read (regcache
, E_CCR_REGNUM
, buf
);
1139 else if (regno
== E_PSEUDO_EXR_REGNUM (gdbarch
))
1140 regcache_raw_read (regcache
, E_EXR_REGNUM
, buf
);
1142 regcache_raw_read (regcache
, regno
, buf
);
1146 h8300_pseudo_register_write (struct gdbarch
*gdbarch
,
1147 struct regcache
*regcache
, int regno
,
1148 const gdb_byte
*buf
)
1150 if (regno
== E_PSEUDO_CCR_REGNUM (gdbarch
))
1151 regcache_raw_write (regcache
, E_CCR_REGNUM
, buf
);
1152 else if (regno
== E_PSEUDO_EXR_REGNUM (gdbarch
))
1153 regcache_raw_write (regcache
, E_EXR_REGNUM
, buf
);
1155 regcache_raw_write (regcache
, regno
, buf
);
1159 h8300_dbg_reg_to_regnum (struct gdbarch
*gdbarch
, int regno
)
1161 if (regno
== E_CCR_REGNUM
)
1162 return E_PSEUDO_CCR_REGNUM (gdbarch
);
1167 h8300s_dbg_reg_to_regnum (struct gdbarch
*gdbarch
, int regno
)
1169 if (regno
== E_CCR_REGNUM
)
1170 return E_PSEUDO_CCR_REGNUM (gdbarch
);
1171 if (regno
== E_EXR_REGNUM
)
1172 return E_PSEUDO_EXR_REGNUM (gdbarch
);
1176 const static unsigned char *
1177 h8300_breakpoint_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*pcptr
,
1180 /*static unsigned char breakpoint[] = { 0x7A, 0xFF }; *//* ??? */
1181 static unsigned char breakpoint
[] = { 0x01, 0x80 }; /* Sleep */
1183 *lenptr
= sizeof (breakpoint
);
1188 h8300_print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
1189 struct frame_info
*frame
, const char *args
)
1191 fprintf_filtered (file
, "\
1192 No floating-point info available for this processor.\n");
1195 static struct gdbarch
*
1196 h8300_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1198 struct gdbarch_tdep
*tdep
= NULL
;
1199 struct gdbarch
*gdbarch
;
1201 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1203 return arches
->gdbarch
;
1206 tdep
= (struct gdbarch_tdep
*) xmalloc (sizeof (struct gdbarch_tdep
));
1209 if (info
.bfd_arch_info
->arch
!= bfd_arch_h8300
)
1212 gdbarch
= gdbarch_alloc (&info
, 0);
1214 switch (info
.bfd_arch_info
->mach
)
1216 case bfd_mach_h8300
:
1217 set_gdbarch_num_regs (gdbarch
, 13);
1218 set_gdbarch_num_pseudo_regs (gdbarch
, 1);
1219 set_gdbarch_ecoff_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1220 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1221 set_gdbarch_stab_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1222 set_gdbarch_register_name (gdbarch
, h8300_register_name
);
1223 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1224 set_gdbarch_addr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1225 set_gdbarch_return_value (gdbarch
, h8300_return_value
);
1226 set_gdbarch_print_insn (gdbarch
, print_insn_h8300
);
1228 case bfd_mach_h8300h
:
1229 case bfd_mach_h8300hn
:
1230 set_gdbarch_num_regs (gdbarch
, 13);
1231 set_gdbarch_num_pseudo_regs (gdbarch
, 1);
1232 set_gdbarch_ecoff_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1233 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1234 set_gdbarch_stab_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1235 set_gdbarch_register_name (gdbarch
, h8300_register_name
);
1236 if (info
.bfd_arch_info
->mach
!= bfd_mach_h8300hn
)
1238 set_gdbarch_ptr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1239 set_gdbarch_addr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1243 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1244 set_gdbarch_addr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1246 set_gdbarch_return_value (gdbarch
, h8300h_return_value
);
1247 set_gdbarch_print_insn (gdbarch
, print_insn_h8300h
);
1249 case bfd_mach_h8300s
:
1250 case bfd_mach_h8300sn
:
1251 set_gdbarch_num_regs (gdbarch
, 16);
1252 set_gdbarch_num_pseudo_regs (gdbarch
, 2);
1253 set_gdbarch_ecoff_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1254 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1255 set_gdbarch_stab_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1256 set_gdbarch_register_name (gdbarch
, h8300s_register_name
);
1257 if (info
.bfd_arch_info
->mach
!= bfd_mach_h8300sn
)
1259 set_gdbarch_ptr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1260 set_gdbarch_addr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1264 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1265 set_gdbarch_addr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1267 set_gdbarch_return_value (gdbarch
, h8300h_return_value
);
1268 set_gdbarch_print_insn (gdbarch
, print_insn_h8300s
);
1270 case bfd_mach_h8300sx
:
1271 case bfd_mach_h8300sxn
:
1272 set_gdbarch_num_regs (gdbarch
, 18);
1273 set_gdbarch_num_pseudo_regs (gdbarch
, 2);
1274 set_gdbarch_ecoff_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1275 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1276 set_gdbarch_stab_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1277 set_gdbarch_register_name (gdbarch
, h8300sx_register_name
);
1278 if (info
.bfd_arch_info
->mach
!= bfd_mach_h8300sxn
)
1280 set_gdbarch_ptr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1281 set_gdbarch_addr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1285 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1286 set_gdbarch_addr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1288 set_gdbarch_return_value (gdbarch
, h8300h_return_value
);
1289 set_gdbarch_print_insn (gdbarch
, print_insn_h8300s
);
1293 set_gdbarch_pseudo_register_read (gdbarch
, h8300_pseudo_register_read
);
1294 set_gdbarch_pseudo_register_write (gdbarch
, h8300_pseudo_register_write
);
1297 * Basic register fields and methods.
1300 set_gdbarch_sp_regnum (gdbarch
, E_SP_REGNUM
);
1301 set_gdbarch_pc_regnum (gdbarch
, E_PC_REGNUM
);
1302 set_gdbarch_register_type (gdbarch
, h8300_register_type
);
1303 set_gdbarch_print_registers_info (gdbarch
, h8300_print_registers_info
);
1304 set_gdbarch_print_float_info (gdbarch
, h8300_print_float_info
);
1309 set_gdbarch_skip_prologue (gdbarch
, h8300_skip_prologue
);
1311 /* Frame unwinder. */
1312 set_gdbarch_unwind_pc (gdbarch
, h8300_unwind_pc
);
1313 set_gdbarch_unwind_sp (gdbarch
, h8300_unwind_sp
);
1314 set_gdbarch_dummy_id (gdbarch
, h8300_dummy_id
);
1315 frame_base_set_default (gdbarch
, &h8300_frame_base
);
1320 /* Stack grows up. */
1321 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1323 set_gdbarch_breakpoint_from_pc (gdbarch
, h8300_breakpoint_from_pc
);
1324 set_gdbarch_push_dummy_call (gdbarch
, h8300_push_dummy_call
);
1326 set_gdbarch_char_signed (gdbarch
, 0);
1327 set_gdbarch_int_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1328 set_gdbarch_long_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1329 set_gdbarch_long_long_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
1330 set_gdbarch_double_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1331 set_gdbarch_long_double_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1333 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
1335 /* Hook in the DWARF CFI frame unwinder. */
1336 dwarf2_append_unwinders (gdbarch
);
1337 frame_unwind_append_unwinder (gdbarch
, &h8300_frame_unwind
);
1343 extern initialize_file_ftype _initialize_h8300_tdep
; /* -Wmissing-prototypes */
1346 _initialize_h8300_tdep (void)
1348 register_gdbarch_init (bfd_arch_h8300
, h8300_gdbarch_init
);
1352 is_h8300hmode (struct gdbarch
*gdbarch
)
1354 return gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sx
1355 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sxn
1356 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300s
1357 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sn
1358 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300h
1359 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300hn
;
1363 is_h8300smode (struct gdbarch
*gdbarch
)
1365 return gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sx
1366 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sxn
1367 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300s
1368 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sn
;
1372 is_h8300sxmode (struct gdbarch
*gdbarch
)
1374 return gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sx
1375 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sxn
;
1379 is_h8300_normal_mode (struct gdbarch
*gdbarch
)
1381 return gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sxn
1382 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sn
1383 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300hn
;