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 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 2 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, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
24 Contributed by Steve Chamberlain
30 #include "arch-utils.h"
34 #include "gdb_assert.h"
36 #include "dwarf2-frame.h"
37 #include "frame-base.h"
38 #include "frame-unwind.h"
42 E_R0_REGNUM
, E_ER0_REGNUM
= E_R0_REGNUM
, E_ARG0_REGNUM
= E_R0_REGNUM
,
43 E_RET0_REGNUM
= E_R0_REGNUM
,
44 E_R1_REGNUM
, E_ER1_REGNUM
= E_R1_REGNUM
, E_RET1_REGNUM
= E_R1_REGNUM
,
45 E_R2_REGNUM
, E_ER2_REGNUM
= E_R2_REGNUM
, E_ARGLAST_REGNUM
= E_R2_REGNUM
,
46 E_R3_REGNUM
, E_ER3_REGNUM
= E_R3_REGNUM
,
47 E_R4_REGNUM
, E_ER4_REGNUM
= E_R4_REGNUM
,
48 E_R5_REGNUM
, E_ER5_REGNUM
= E_R5_REGNUM
,
49 E_R6_REGNUM
, E_ER6_REGNUM
= E_R6_REGNUM
, E_FP_REGNUM
= E_R6_REGNUM
,
54 E_TICK_REGNUM
, E_EXR_REGNUM
= E_TICK_REGNUM
,
55 E_INST_REGNUM
, E_TICKS_REGNUM
= E_INST_REGNUM
,
63 #define H8300_MAX_NUM_REGS 18
65 #define E_PSEUDO_CCR_REGNUM (gdbarch_num_regs (current_gdbarch))
66 #define E_PSEUDO_EXR_REGNUM (gdbarch_num_regs (current_gdbarch)+1)
68 struct h8300_frame_cache
75 /* Flag showing that a frame has been created in the prologue code. */
78 /* Saved registers. */
79 CORE_ADDR saved_regs
[H8300_MAX_NUM_REGS
];
87 h8300_max_reg_size
= 4,
90 static int is_h8300hmode (struct gdbarch
*gdbarch
);
91 static int is_h8300smode (struct gdbarch
*gdbarch
);
92 static int is_h8300sxmode (struct gdbarch
*gdbarch
);
93 static int is_h8300_normal_mode (struct gdbarch
*gdbarch
);
95 #define BINWORD ((is_h8300hmode (current_gdbarch) \
96 && !is_h8300_normal_mode (current_gdbarch)) \
97 ? h8300h_reg_size : h8300_reg_size)
100 h8300_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
102 return frame_unwind_register_unsigned (next_frame
, E_PC_REGNUM
);
106 h8300_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
108 return frame_unwind_register_unsigned (next_frame
, E_SP_REGNUM
);
111 static struct frame_id
112 h8300_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
114 return frame_id_build (h8300_unwind_sp (gdbarch
, next_frame
),
115 frame_pc_unwind (next_frame
));
120 /* Allocate and initialize a frame cache. */
123 h8300_init_frame_cache (struct h8300_frame_cache
*cache
)
129 cache
->sp_offset
= 0;
132 /* Frameless until proven otherwise. */
135 /* Saved registers. We initialize these to -1 since zero is a valid
136 offset (that's where %fp is supposed to be stored). */
137 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
138 cache
->saved_regs
[i
] = -1;
141 #define IS_MOVB_RnRm(x) (((x) & 0xff88) == 0x0c88)
142 #define IS_MOVW_RnRm(x) (((x) & 0xff88) == 0x0d00)
143 #define IS_MOVL_RnRm(x) (((x) & 0xff88) == 0x0f80)
144 #define IS_MOVB_Rn16_SP(x) (((x) & 0xfff0) == 0x6ee0)
145 #define IS_MOVB_EXT(x) ((x) == 0x7860)
146 #define IS_MOVB_Rn24_SP(x) (((x) & 0xfff0) == 0x6aa0)
147 #define IS_MOVW_Rn16_SP(x) (((x) & 0xfff0) == 0x6fe0)
148 #define IS_MOVW_EXT(x) ((x) == 0x78e0)
149 #define IS_MOVW_Rn24_SP(x) (((x) & 0xfff0) == 0x6ba0)
150 /* Same instructions as mov.w, just prefixed with 0x0100 */
151 #define IS_MOVL_PRE(x) ((x) == 0x0100)
152 #define IS_MOVL_Rn16_SP(x) (((x) & 0xfff0) == 0x6fe0)
153 #define IS_MOVL_EXT(x) ((x) == 0x78e0)
154 #define IS_MOVL_Rn24_SP(x) (((x) & 0xfff0) == 0x6ba0)
156 #define IS_PUSHFP_MOVESPFP(x) ((x) == 0x6df60d76)
157 #define IS_PUSH_FP(x) ((x) == 0x01006df6)
158 #define IS_MOV_SP_FP(x) ((x) == 0x0ff6)
159 #define IS_SUB2_SP(x) ((x) == 0x1b87)
160 #define IS_SUB4_SP(x) ((x) == 0x1b97)
161 #define IS_ADD_IMM_SP(x) ((x) == 0x7a1f)
162 #define IS_SUB_IMM_SP(x) ((x) == 0x7a3f)
163 #define IS_SUBL4_SP(x) ((x) == 0x1acf)
164 #define IS_MOV_IMM_Rn(x) (((x) & 0xfff0) == 0x7905)
165 #define IS_SUB_RnSP(x) (((x) & 0xff0f) == 0x1907)
166 #define IS_ADD_RnSP(x) (((x) & 0xff0f) == 0x0907)
167 #define IS_PUSH(x) (((x) & 0xfff0) == 0x6df0)
169 /* If the instruction at PC is an argument register spill, return its
170 length. Otherwise, return zero.
172 An argument register spill is an instruction that moves an argument
173 from the register in which it was passed to the stack slot in which
174 it really lives. It is a byte, word, or longword move from an
175 argument register to a negative offset from the frame pointer.
177 CV, 2003-06-16: Or, in optimized code or when the `register' qualifier
178 is used, it could be a byte, word or long move to registers r3-r5. */
181 h8300_is_argument_spill (CORE_ADDR pc
)
183 int w
= read_memory_unsigned_integer (pc
, 2);
185 if ((IS_MOVB_RnRm (w
) || IS_MOVW_RnRm (w
) || IS_MOVL_RnRm (w
))
186 && (w
& 0x70) <= 0x20 /* Rs is R0, R1 or R2 */
187 && (w
& 0x7) >= 0x3 && (w
& 0x7) <= 0x5) /* Rd is R3, R4 or R5 */
190 if (IS_MOVB_Rn16_SP (w
)
191 && 8 <= (w
& 0xf) && (w
& 0xf) <= 10) /* Rs is R0L, R1L, or R2L */
193 if (read_memory_integer (pc
+ 2, 2) < 0) /* ... and d:16 is negative. */
196 else if (IS_MOVB_EXT (w
))
198 if (IS_MOVB_Rn24_SP (read_memory_unsigned_integer (pc
+ 2, 2)))
200 LONGEST disp
= read_memory_integer (pc
+ 4, 4);
202 /* ... and d:24 is negative. */
203 if (disp
< 0 && disp
> 0xffffff)
207 else if (IS_MOVW_Rn16_SP (w
)
208 && (w
& 0xf) <= 2) /* Rs is R0, R1, or R2 */
210 /* ... and d:16 is negative. */
211 if (read_memory_integer (pc
+ 2, 2) < 0)
214 else if (IS_MOVW_EXT (w
))
216 if (IS_MOVW_Rn24_SP (read_memory_unsigned_integer (pc
+ 2, 2)))
218 LONGEST disp
= read_memory_integer (pc
+ 4, 4);
220 /* ... and d:24 is negative. */
221 if (disp
< 0 && disp
> 0xffffff)
225 else if (IS_MOVL_PRE (w
))
227 int w2
= read_memory_integer (pc
+ 2, 2);
229 if (IS_MOVL_Rn16_SP (w2
)
230 && (w2
& 0xf) <= 2) /* Rs is ER0, ER1, or ER2 */
232 /* ... and d:16 is negative. */
233 if (read_memory_integer (pc
+ 4, 2) < 0)
236 else if (IS_MOVL_EXT (w2
))
238 int w3
= read_memory_integer (pc
+ 4, 2);
240 if (IS_MOVL_Rn24_SP (read_memory_integer (pc
+ 4, 2)))
242 LONGEST disp
= read_memory_integer (pc
+ 6, 4);
244 /* ... and d:24 is negative. */
245 if (disp
< 0 && disp
> 0xffffff)
254 /* Do a full analysis of the prologue at PC and update CACHE
255 accordingly. Bail out early if CURRENT_PC is reached. Return the
256 address where the analysis stopped.
258 We handle all cases that can be generated by gcc.
260 For allocating a stack frame:
281 For saving registers:
290 h8300_analyze_prologue (CORE_ADDR pc
, CORE_ADDR current_pc
,
291 struct h8300_frame_cache
*cache
)
294 int regno
, i
, spill_size
;
296 cache
->sp_offset
= 0;
298 if (pc
>= current_pc
)
301 op
= read_memory_unsigned_integer (pc
, 4);
303 if (IS_PUSHFP_MOVESPFP (op
))
305 cache
->saved_regs
[E_FP_REGNUM
] = 0;
309 else if (IS_PUSH_FP (op
))
311 cache
->saved_regs
[E_FP_REGNUM
] = 0;
313 if (pc
>= current_pc
)
315 op
= read_memory_unsigned_integer (pc
, 2);
316 if (IS_MOV_SP_FP (op
))
323 while (pc
< current_pc
)
325 op
= read_memory_unsigned_integer (pc
, 2);
328 cache
->sp_offset
+= 2;
331 else if (IS_SUB4_SP (op
))
333 cache
->sp_offset
+= 4;
336 else if (IS_ADD_IMM_SP (op
))
338 cache
->sp_offset
+= -read_memory_integer (pc
+ 2, 2);
341 else if (IS_SUB_IMM_SP (op
))
343 cache
->sp_offset
+= read_memory_integer (pc
+ 2, 2);
346 else if (IS_SUBL4_SP (op
))
348 cache
->sp_offset
+= 4;
351 else if (IS_MOV_IMM_Rn (op
))
353 int offset
= read_memory_integer (pc
+ 2, 2);
355 op
= read_memory_unsigned_integer (pc
+ 4, 2);
356 if (IS_ADD_RnSP (op
) && (op
& 0x00f0) == regno
)
358 cache
->sp_offset
-= offset
;
361 else if (IS_SUB_RnSP (op
) && (op
& 0x00f0) == regno
)
363 cache
->sp_offset
+= offset
;
369 else if (IS_PUSH (op
))
372 cache
->sp_offset
+= 2;
373 cache
->saved_regs
[regno
] = cache
->sp_offset
;
376 else if (op
== 0x0100)
378 op
= read_memory_unsigned_integer (pc
+ 2, 2);
382 cache
->sp_offset
+= 4;
383 cache
->saved_regs
[regno
] = cache
->sp_offset
;
389 else if ((op
& 0xffcf) == 0x0100)
392 op1
= read_memory_unsigned_integer (pc
+ 2, 2);
395 /* Since the prefix is 0x01x0, this is not a simple pushm but a
396 stm.l reglist,@-sp */
397 i
= ((op
& 0x0030) >> 4) + 1;
398 regno
= op1
& 0x000f;
399 for (; i
> 0; regno
++, --i
)
401 cache
->sp_offset
+= 4;
402 cache
->saved_regs
[regno
] = cache
->sp_offset
;
413 /* Check for spilling an argument register to the stack frame.
414 This could also be an initializing store from non-prologue code,
415 but I don't think there's any harm in skipping that. */
416 while ((spill_size
= h8300_is_argument_spill (pc
)) > 0
417 && pc
+ spill_size
<= current_pc
)
423 static struct h8300_frame_cache
*
424 h8300_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
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 (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
= frame_unwind_register_unsigned (next_frame
, E_FP_REGNUM
);
445 if (cache
->base
== 0)
448 cache
->saved_regs
[E_PC_REGNUM
] = -BINWORD
;
450 cache
->pc
= frame_func_unwind (next_frame
, NORMAL_FRAME
);
451 current_pc
= frame_pc_unwind (next_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
= frame_unwind_register_unsigned (next_frame
, E_SP_REGNUM
)
467 cache
->saved_sp
= cache
->base
+ BINWORD
;
468 cache
->saved_regs
[E_PC_REGNUM
] = 0;
472 cache
->saved_sp
= cache
->base
+ 2 * BINWORD
;
473 cache
->saved_regs
[E_PC_REGNUM
] = -BINWORD
;
476 /* Adjust all the saved registers such that they contain addresses
477 instead of offsets. */
478 for (i
= 0; i
< gdbarch_num_regs (current_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
*next_frame
, void **this_cache
,
487 struct frame_id
*this_id
)
489 struct h8300_frame_cache
*cache
=
490 h8300_frame_cache (next_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
);
500 h8300_frame_prev_register (struct frame_info
*next_frame
, void **this_cache
,
501 int regnum
, int *optimizedp
,
502 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
503 int *realnump
, gdb_byte
*valuep
)
505 struct h8300_frame_cache
*cache
=
506 h8300_frame_cache (next_frame
, this_cache
);
508 gdb_assert (regnum
>= 0);
510 if (regnum
== E_SP_REGNUM
&& cache
->saved_sp
)
517 store_unsigned_integer (valuep
, BINWORD
, cache
->saved_sp
);
521 if (regnum
< gdbarch_num_regs (current_gdbarch
)
522 && cache
->saved_regs
[regnum
] != -1)
525 *lvalp
= lval_memory
;
526 *addrp
= cache
->saved_regs
[regnum
];
529 read_memory (*addrp
, valuep
, register_size (current_gdbarch
, regnum
));
534 *lvalp
= lval_register
;
538 frame_unwind_register (next_frame
, *realnump
, valuep
);
541 static const struct frame_unwind h8300_frame_unwind
= {
544 h8300_frame_prev_register
547 static const struct frame_unwind
*
548 h8300_frame_sniffer (struct frame_info
*next_frame
)
550 return &h8300_frame_unwind
;
554 h8300_frame_base_address (struct frame_info
*next_frame
, void **this_cache
)
556 struct h8300_frame_cache
*cache
= h8300_frame_cache (next_frame
, this_cache
);
560 static const struct frame_base h8300_frame_base
= {
562 h8300_frame_base_address
,
563 h8300_frame_base_address
,
564 h8300_frame_base_address
568 h8300_skip_prologue (CORE_ADDR pc
)
570 CORE_ADDR func_addr
= 0 , func_end
= 0;
572 if (find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
574 struct symtab_and_line sal
;
575 struct h8300_frame_cache cache
;
577 /* Found a function. */
578 sal
= find_pc_line (func_addr
, 0);
579 if (sal
.end
&& sal
.end
< func_end
)
580 /* Found a line number, use it as end of prologue. */
583 /* No useable line symbol. Use prologue parsing method. */
584 h8300_init_frame_cache (&cache
);
585 return h8300_analyze_prologue (func_addr
, func_end
, &cache
);
588 /* No function symbol -- just return the PC. */
589 return (CORE_ADDR
) pc
;
592 /* Function: push_dummy_call
593 Setup the function arguments for calling a function in the inferior.
594 In this discussion, a `word' is 16 bits on the H8/300s, and 32 bits
597 There are actually two ABI's here: -mquickcall (the default) and
598 -mno-quickcall. With -mno-quickcall, all arguments are passed on
599 the stack after the return address, word-aligned. With
600 -mquickcall, GCC tries to use r0 -- r2 to pass registers. Since
601 GCC doesn't indicate in the object file which ABI was used to
602 compile it, GDB only supports the default --- -mquickcall.
604 Here are the rules for -mquickcall, in detail:
606 Each argument, whether scalar or aggregate, is padded to occupy a
607 whole number of words. Arguments smaller than a word are padded at
608 the most significant end; those larger than a word are padded at
609 the least significant end.
611 The initial arguments are passed in r0 -- r2. Earlier arguments go in
612 lower-numbered registers. Multi-word arguments are passed in
613 consecutive registers, with the most significant end in the
614 lower-numbered register.
616 If an argument doesn't fit entirely in the remaining registers, it
617 is passed entirely on the stack. Stack arguments begin just after
618 the return address. Once an argument has overflowed onto the stack
619 this way, all subsequent arguments are passed on the stack.
621 The above rule has odd consequences. For example, on the h8/300s,
622 if a function takes two longs and an int as arguments:
623 - the first long will be passed in r0/r1,
624 - the second long will be passed entirely on the stack, since it
626 - and the int will be passed on the stack, even though it could fit
629 A weird exception: if an argument is larger than a word, but not a
630 whole number of words in length (before padding), it is passed on
631 the stack following the rules for stack arguments above, even if
632 there are sufficient registers available to hold it. Stranger
633 still, the argument registers are still `used up' --- even though
634 there's nothing in them.
636 So, for example, on the h8/300s, if a function expects a three-byte
637 structure and an int, the structure will go on the stack, and the
638 int will go in r2, not r0.
640 If the function returns an aggregate type (struct, union, or class)
641 by value, the caller must allocate space to hold the return value,
642 and pass the callee a pointer to this space as an invisible first
645 For varargs functions, the last fixed argument and all the variable
646 arguments are always passed on the stack. This means that calls to
647 varargs functions don't work properly unless there is a prototype
650 Basically, this ABI is not good, for the following reasons:
651 - You can't call vararg functions properly unless a prototype is in scope.
652 - Structure passing is inconsistent, to no purpose I can see.
653 - It often wastes argument registers, of which there are only three
657 h8300_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
658 struct regcache
*regcache
, CORE_ADDR bp_addr
,
659 int nargs
, struct value
**args
, CORE_ADDR sp
,
660 int struct_return
, CORE_ADDR struct_addr
)
662 int stack_alloc
= 0, stack_offset
= 0;
663 int wordsize
= BINWORD
;
664 int reg
= E_ARG0_REGNUM
;
667 /* First, make sure the stack is properly aligned. */
668 sp
= align_down (sp
, wordsize
);
670 /* Now make sure there's space on the stack for the arguments. We
671 may over-allocate a little here, but that won't hurt anything. */
672 for (argument
= 0; argument
< nargs
; argument
++)
673 stack_alloc
+= align_up (TYPE_LENGTH (value_type (args
[argument
])),
677 /* Now load as many arguments as possible into registers, and push
678 the rest onto the stack.
679 If we're returning a structure by value, then we must pass a
680 pointer to the buffer for the return value as an invisible first
683 regcache_cooked_write_unsigned (regcache
, reg
++, struct_addr
);
685 for (argument
= 0; argument
< nargs
; argument
++)
687 struct type
*type
= value_type (args
[argument
]);
688 int len
= TYPE_LENGTH (type
);
689 char *contents
= (char *) value_contents (args
[argument
]);
691 /* Pad the argument appropriately. */
692 int padded_len
= align_up (len
, wordsize
);
693 gdb_byte
*padded
= alloca (padded_len
);
695 memset (padded
, 0, padded_len
);
696 memcpy (len
< wordsize
? padded
+ padded_len
- len
: padded
,
699 /* Could the argument fit in the remaining registers? */
700 if (padded_len
<= (E_ARGLAST_REGNUM
- reg
+ 1) * wordsize
)
702 /* Are we going to pass it on the stack anyway, for no good
704 if (len
> wordsize
&& len
% wordsize
)
706 /* I feel so unclean. */
707 write_memory (sp
+ stack_offset
, padded
, padded_len
);
708 stack_offset
+= padded_len
;
710 /* That's right --- even though we passed the argument
711 on the stack, we consume the registers anyway! Love
713 reg
+= padded_len
/ wordsize
;
717 /* Heavens to Betsy --- it's really going in registers!
718 It would be nice if we could use write_register_bytes
719 here, but on the h8/300s, there are gaps between
720 the registers in the register file. */
723 for (offset
= 0; offset
< padded_len
; offset
+= wordsize
)
725 ULONGEST word
= extract_unsigned_integer (padded
+ offset
,
727 regcache_cooked_write_unsigned (regcache
, reg
++, word
);
733 /* It doesn't fit in registers! Onto the stack it goes. */
734 write_memory (sp
+ stack_offset
, padded
, padded_len
);
735 stack_offset
+= padded_len
;
737 /* Once one argument has spilled onto the stack, all
738 subsequent arguments go on the stack. */
739 reg
= E_ARGLAST_REGNUM
+ 1;
743 /* Store return address. */
745 write_memory_unsigned_integer (sp
, wordsize
, bp_addr
);
747 /* Update stack pointer. */
748 regcache_cooked_write_unsigned (regcache
, E_SP_REGNUM
, sp
);
750 /* Return the new stack pointer minus the return address slot since
751 that's what DWARF2/GCC uses as the frame's CFA. */
752 return sp
+ wordsize
;
755 /* Function: extract_return_value
756 Figure out where in REGBUF the called function has left its return value.
757 Copy that into VALBUF. Be sure to account for CPU type. */
760 h8300_extract_return_value (struct type
*type
, struct regcache
*regcache
,
763 int len
= TYPE_LENGTH (type
);
770 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &c
);
771 store_unsigned_integer (valbuf
, len
, c
);
773 case 4: /* Needs two registers on plain H8/300 */
774 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &c
);
775 store_unsigned_integer (valbuf
, 2, c
);
776 regcache_cooked_read_unsigned (regcache
, E_RET1_REGNUM
, &c
);
777 store_unsigned_integer ((void *) ((char *) valbuf
+ 2), 2, c
);
779 case 8: /* long long is now 8 bytes. */
780 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
782 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &addr
);
783 c
= read_memory_unsigned_integer ((CORE_ADDR
) addr
, len
);
784 store_unsigned_integer (valbuf
, len
, c
);
788 error ("I don't know how this 8 byte value is returned.");
795 h8300h_extract_return_value (struct type
*type
, struct regcache
*regcache
,
798 int len
= TYPE_LENGTH (type
);
806 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &c
);
807 store_unsigned_integer (valbuf
, len
, c
);
809 case 8: /* long long is now 8 bytes. */
810 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
812 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &c
);
813 store_unsigned_integer (valbuf
, 4, c
);
814 regcache_cooked_read_unsigned (regcache
, E_RET1_REGNUM
, &c
);
815 store_unsigned_integer ((void *) ((char *) valbuf
+ 4), 4, c
);
819 error ("I don't know how this 8 byte value is returned.");
826 h8300_use_struct_convention (struct type
*value_type
)
828 /* Types of 1, 2 or 4 bytes are returned in R0/R1, everything else on the
831 if (TYPE_CODE (value_type
) == TYPE_CODE_STRUCT
832 || TYPE_CODE (value_type
) == TYPE_CODE_UNION
)
834 return !(TYPE_LENGTH (value_type
) == 1
835 || TYPE_LENGTH (value_type
) == 2
836 || TYPE_LENGTH (value_type
) == 4);
840 h8300h_use_struct_convention (struct type
*value_type
)
842 /* Types of 1, 2 or 4 bytes are returned in R0, INT types of 8 bytes are
843 returned in R0/R1, everything else on the stack. */
844 if (TYPE_CODE (value_type
) == TYPE_CODE_STRUCT
845 || TYPE_CODE (value_type
) == TYPE_CODE_UNION
)
847 return !(TYPE_LENGTH (value_type
) == 1
848 || TYPE_LENGTH (value_type
) == 2
849 || TYPE_LENGTH (value_type
) == 4
850 || (TYPE_LENGTH (value_type
) == 8
851 && TYPE_CODE (value_type
) == TYPE_CODE_INT
));
854 /* Function: store_return_value
855 Place the appropriate value in the appropriate registers.
856 Primarily used by the RETURN command. */
859 h8300_store_return_value (struct type
*type
, struct regcache
*regcache
,
862 int len
= TYPE_LENGTH (type
);
868 case 2: /* short... */
869 val
= extract_unsigned_integer (valbuf
, len
);
870 regcache_cooked_write_unsigned (regcache
, E_RET0_REGNUM
, val
);
872 case 4: /* long, float */
873 val
= extract_unsigned_integer (valbuf
, len
);
874 regcache_cooked_write_unsigned (regcache
, E_RET0_REGNUM
,
875 (val
>> 16) & 0xffff);
876 regcache_cooked_write_unsigned (regcache
, E_RET1_REGNUM
, val
& 0xffff);
878 case 8: /* long long, double and long double are all defined
879 as 4 byte types so far so this shouldn't happen. */
880 error ("I don't know how to return an 8 byte value.");
886 h8300h_store_return_value (struct type
*type
, struct regcache
*regcache
,
889 int len
= TYPE_LENGTH (type
);
896 case 4: /* long, float */
897 val
= extract_unsigned_integer (valbuf
, len
);
898 regcache_cooked_write_unsigned (regcache
, E_RET0_REGNUM
, val
);
901 val
= extract_unsigned_integer (valbuf
, len
);
902 regcache_cooked_write_unsigned (regcache
, E_RET0_REGNUM
,
903 (val
>> 32) & 0xffffffff);
904 regcache_cooked_write_unsigned (regcache
, E_RET1_REGNUM
,
910 static enum return_value_convention
911 h8300_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
912 struct regcache
*regcache
,
913 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
915 if (h8300_use_struct_convention (type
))
916 return RETURN_VALUE_STRUCT_CONVENTION
;
918 h8300_store_return_value (type
, regcache
, writebuf
);
920 h8300_extract_return_value (type
, regcache
, readbuf
);
921 return RETURN_VALUE_REGISTER_CONVENTION
;
924 static enum return_value_convention
925 h8300h_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
926 struct regcache
*regcache
,
927 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
929 if (h8300h_use_struct_convention (type
))
935 regcache_raw_read_unsigned (regcache
, E_R0_REGNUM
, &addr
);
936 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
939 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
942 h8300h_store_return_value (type
, regcache
, writebuf
);
944 h8300h_extract_return_value (type
, regcache
, readbuf
);
945 return RETURN_VALUE_REGISTER_CONVENTION
;
948 static struct cmd_list_element
*setmachinelist
;
951 h8300_register_name (int regno
)
953 /* The register names change depending on which h8300 processor
955 static char *register_names
[] = {
956 "r0", "r1", "r2", "r3", "r4", "r5", "r6",
957 "sp", "", "pc", "cycles", "tick", "inst",
958 "ccr", /* pseudo register */
961 || regno
>= (sizeof (register_names
) / sizeof (*register_names
)))
962 internal_error (__FILE__
, __LINE__
,
963 "h8300_register_name: illegal register number %d", regno
);
965 return register_names
[regno
];
969 h8300s_register_name (int regno
)
971 static char *register_names
[] = {
972 "er0", "er1", "er2", "er3", "er4", "er5", "er6",
973 "sp", "", "pc", "cycles", "", "tick", "inst",
975 "ccr", "exr" /* pseudo registers */
978 || regno
>= (sizeof (register_names
) / sizeof (*register_names
)))
979 internal_error (__FILE__
, __LINE__
,
980 "h8300s_register_name: illegal register number %d",
983 return register_names
[regno
];
987 h8300sx_register_name (int regno
)
989 static char *register_names
[] = {
990 "er0", "er1", "er2", "er3", "er4", "er5", "er6",
991 "sp", "", "pc", "cycles", "", "tick", "inst",
992 "mach", "macl", "sbr", "vbr",
993 "ccr", "exr" /* pseudo registers */
996 || regno
>= (sizeof (register_names
) / sizeof (*register_names
)))
997 internal_error (__FILE__
, __LINE__
,
998 "h8300sx_register_name: illegal register number %d",
1001 return register_names
[regno
];
1005 h8300_print_register (struct gdbarch
*gdbarch
, struct ui_file
*file
,
1006 struct frame_info
*frame
, int regno
)
1009 const char *name
= gdbarch_register_name (gdbarch
, regno
);
1011 if (!name
|| !*name
)
1014 rval
= get_frame_register_signed (frame
, regno
);
1016 fprintf_filtered (file
, "%-14s ", name
);
1017 if ((regno
== E_PSEUDO_CCR_REGNUM
) || \
1018 (regno
== E_PSEUDO_EXR_REGNUM
&& is_h8300smode (current_gdbarch
)))
1020 fprintf_filtered (file
, "0x%02x ", (unsigned char) rval
);
1021 print_longest (file
, 'u', 1, rval
);
1025 fprintf_filtered (file
, "0x%s ", phex ((ULONGEST
) rval
, BINWORD
));
1026 print_longest (file
, 'd', 1, rval
);
1028 if (regno
== E_PSEUDO_CCR_REGNUM
)
1032 unsigned char l
= rval
& 0xff;
1033 fprintf_filtered (file
, "\t");
1034 fprintf_filtered (file
, "I-%d ", (l
& 0x80) != 0);
1035 fprintf_filtered (file
, "UI-%d ", (l
& 0x40) != 0);
1036 fprintf_filtered (file
, "H-%d ", (l
& 0x20) != 0);
1037 fprintf_filtered (file
, "U-%d ", (l
& 0x10) != 0);
1042 fprintf_filtered (file
, "N-%d ", N
);
1043 fprintf_filtered (file
, "Z-%d ", Z
);
1044 fprintf_filtered (file
, "V-%d ", V
);
1045 fprintf_filtered (file
, "C-%d ", C
);
1047 fprintf_filtered (file
, "u> ");
1049 fprintf_filtered (file
, "u<= ");
1051 fprintf_filtered (file
, "u>= ");
1053 fprintf_filtered (file
, "u< ");
1055 fprintf_filtered (file
, "!= ");
1057 fprintf_filtered (file
, "== ");
1059 fprintf_filtered (file
, ">= ");
1061 fprintf_filtered (file
, "< ");
1062 if ((Z
| (N
^ V
)) == 0)
1063 fprintf_filtered (file
, "> ");
1064 if ((Z
| (N
^ V
)) == 1)
1065 fprintf_filtered (file
, "<= ");
1067 else if (regno
== E_PSEUDO_EXR_REGNUM
&& is_h8300smode (current_gdbarch
))
1070 unsigned char l
= rval
& 0xff;
1071 fprintf_filtered (file
, "\t");
1072 fprintf_filtered (file
, "T-%d - - - ", (l
& 0x80) != 0);
1073 fprintf_filtered (file
, "I2-%d ", (l
& 4) != 0);
1074 fprintf_filtered (file
, "I1-%d ", (l
& 2) != 0);
1075 fprintf_filtered (file
, "I0-%d", (l
& 1) != 0);
1077 fprintf_filtered (file
, "\n");
1081 h8300_print_registers_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
1082 struct frame_info
*frame
, int regno
, int cpregs
)
1086 for (regno
= E_R0_REGNUM
; regno
<= E_SP_REGNUM
; ++regno
)
1087 h8300_print_register (gdbarch
, file
, frame
, regno
);
1088 h8300_print_register (gdbarch
, file
, frame
, E_PSEUDO_CCR_REGNUM
);
1089 h8300_print_register (gdbarch
, file
, frame
, E_PC_REGNUM
);
1090 if (is_h8300smode (current_gdbarch
))
1092 h8300_print_register (gdbarch
, file
, frame
, E_PSEUDO_EXR_REGNUM
);
1093 if (is_h8300sxmode (current_gdbarch
))
1095 h8300_print_register (gdbarch
, file
, frame
, E_SBR_REGNUM
);
1096 h8300_print_register (gdbarch
, file
, frame
, E_VBR_REGNUM
);
1098 h8300_print_register (gdbarch
, file
, frame
, E_MACH_REGNUM
);
1099 h8300_print_register (gdbarch
, file
, frame
, E_MACL_REGNUM
);
1100 h8300_print_register (gdbarch
, file
, frame
, E_CYCLES_REGNUM
);
1101 h8300_print_register (gdbarch
, file
, frame
, E_TICKS_REGNUM
);
1102 h8300_print_register (gdbarch
, file
, frame
, E_INSTS_REGNUM
);
1106 h8300_print_register (gdbarch
, file
, frame
, E_CYCLES_REGNUM
);
1107 h8300_print_register (gdbarch
, file
, frame
, E_TICK_REGNUM
);
1108 h8300_print_register (gdbarch
, file
, frame
, E_INST_REGNUM
);
1113 if (regno
== E_CCR_REGNUM
)
1114 h8300_print_register (gdbarch
, file
, frame
, E_PSEUDO_CCR_REGNUM
);
1115 else if (regno
== E_PSEUDO_EXR_REGNUM
1116 && is_h8300smode (current_gdbarch
))
1117 h8300_print_register (gdbarch
, file
, frame
, E_PSEUDO_EXR_REGNUM
);
1119 h8300_print_register (gdbarch
, file
, frame
, regno
);
1123 static struct type
*
1124 h8300_register_type (struct gdbarch
*gdbarch
, int regno
)
1126 if (regno
< 0 || regno
>= gdbarch_num_regs (current_gdbarch
)
1127 + gdbarch_num_pseudo_regs (current_gdbarch
))
1128 internal_error (__FILE__
, __LINE__
,
1129 "h8300_register_type: illegal register number %d", regno
);
1135 return builtin_type_void_func_ptr
;
1138 return builtin_type_void_data_ptr
;
1140 if (regno
== E_PSEUDO_CCR_REGNUM
)
1141 return builtin_type_uint8
;
1142 else if (regno
== E_PSEUDO_EXR_REGNUM
)
1143 return builtin_type_uint8
;
1144 else if (is_h8300hmode (current_gdbarch
))
1145 return builtin_type_int32
;
1147 return builtin_type_int16
;
1153 h8300_pseudo_register_read (struct gdbarch
*gdbarch
,
1154 struct regcache
*regcache
, int regno
,
1157 if (regno
== E_PSEUDO_CCR_REGNUM
)
1158 regcache_raw_read (regcache
, E_CCR_REGNUM
, buf
);
1159 else if (regno
== E_PSEUDO_EXR_REGNUM
)
1160 regcache_raw_read (regcache
, E_EXR_REGNUM
, buf
);
1162 regcache_raw_read (regcache
, regno
, buf
);
1166 h8300_pseudo_register_write (struct gdbarch
*gdbarch
,
1167 struct regcache
*regcache
, int regno
,
1168 const gdb_byte
*buf
)
1170 if (regno
== E_PSEUDO_CCR_REGNUM
)
1171 regcache_raw_write (regcache
, E_CCR_REGNUM
, buf
);
1172 else if (regno
== E_PSEUDO_EXR_REGNUM
)
1173 regcache_raw_write (regcache
, E_EXR_REGNUM
, buf
);
1175 regcache_raw_write (regcache
, regno
, buf
);
1179 h8300_dbg_reg_to_regnum (int regno
)
1181 if (regno
== E_CCR_REGNUM
)
1182 return E_PSEUDO_CCR_REGNUM
;
1187 h8300s_dbg_reg_to_regnum (int regno
)
1189 if (regno
== E_CCR_REGNUM
)
1190 return E_PSEUDO_CCR_REGNUM
;
1191 if (regno
== E_EXR_REGNUM
)
1192 return E_PSEUDO_EXR_REGNUM
;
1196 const static unsigned char *
1197 h8300_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
1199 /*static unsigned char breakpoint[] = { 0x7A, 0xFF }; *//* ??? */
1200 static unsigned char breakpoint
[] = { 0x01, 0x80 }; /* Sleep */
1202 *lenptr
= sizeof (breakpoint
);
1207 h8300_print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
1208 struct frame_info
*frame
, const char *args
)
1210 fprintf_filtered (file
, "\
1211 No floating-point info available for this processor.\n");
1214 static struct gdbarch
*
1215 h8300_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1217 struct gdbarch_tdep
*tdep
= NULL
;
1218 struct gdbarch
*gdbarch
;
1220 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1222 return arches
->gdbarch
;
1225 tdep
= (struct gdbarch_tdep
*) xmalloc (sizeof (struct gdbarch_tdep
));
1228 if (info
.bfd_arch_info
->arch
!= bfd_arch_h8300
)
1231 gdbarch
= gdbarch_alloc (&info
, 0);
1233 switch (info
.bfd_arch_info
->mach
)
1235 case bfd_mach_h8300
:
1236 set_gdbarch_num_regs (gdbarch
, 13);
1237 set_gdbarch_num_pseudo_regs (gdbarch
, 1);
1238 set_gdbarch_ecoff_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1239 set_gdbarch_dwarf_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1240 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1241 set_gdbarch_stab_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1242 set_gdbarch_register_name (gdbarch
, h8300_register_name
);
1243 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1244 set_gdbarch_addr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1245 set_gdbarch_return_value (gdbarch
, h8300_return_value
);
1246 set_gdbarch_print_insn (gdbarch
, print_insn_h8300
);
1248 case bfd_mach_h8300h
:
1249 case bfd_mach_h8300hn
:
1250 set_gdbarch_num_regs (gdbarch
, 13);
1251 set_gdbarch_num_pseudo_regs (gdbarch
, 1);
1252 set_gdbarch_ecoff_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1253 set_gdbarch_dwarf_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1254 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1255 set_gdbarch_stab_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1256 set_gdbarch_register_name (gdbarch
, h8300_register_name
);
1257 if (info
.bfd_arch_info
->mach
!= bfd_mach_h8300hn
)
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_h8300h
);
1270 case bfd_mach_h8300s
:
1271 case bfd_mach_h8300sn
:
1272 set_gdbarch_num_regs (gdbarch
, 16);
1273 set_gdbarch_num_pseudo_regs (gdbarch
, 2);
1274 set_gdbarch_ecoff_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1275 set_gdbarch_dwarf_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1276 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1277 set_gdbarch_stab_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1278 set_gdbarch_register_name (gdbarch
, h8300s_register_name
);
1279 if (info
.bfd_arch_info
->mach
!= bfd_mach_h8300sn
)
1281 set_gdbarch_ptr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1282 set_gdbarch_addr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1286 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1287 set_gdbarch_addr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1289 set_gdbarch_return_value (gdbarch
, h8300h_return_value
);
1290 set_gdbarch_print_insn (gdbarch
, print_insn_h8300s
);
1292 case bfd_mach_h8300sx
:
1293 case bfd_mach_h8300sxn
:
1294 set_gdbarch_num_regs (gdbarch
, 18);
1295 set_gdbarch_num_pseudo_regs (gdbarch
, 2);
1296 set_gdbarch_ecoff_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1297 set_gdbarch_dwarf_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1298 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1299 set_gdbarch_stab_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1300 set_gdbarch_register_name (gdbarch
, h8300sx_register_name
);
1301 if (info
.bfd_arch_info
->mach
!= bfd_mach_h8300sxn
)
1303 set_gdbarch_ptr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1304 set_gdbarch_addr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1308 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1309 set_gdbarch_addr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1311 set_gdbarch_return_value (gdbarch
, h8300h_return_value
);
1312 set_gdbarch_print_insn (gdbarch
, print_insn_h8300s
);
1316 set_gdbarch_pseudo_register_read (gdbarch
, h8300_pseudo_register_read
);
1317 set_gdbarch_pseudo_register_write (gdbarch
, h8300_pseudo_register_write
);
1320 * Basic register fields and methods.
1323 set_gdbarch_sp_regnum (gdbarch
, E_SP_REGNUM
);
1324 set_gdbarch_pc_regnum (gdbarch
, E_PC_REGNUM
);
1325 set_gdbarch_register_type (gdbarch
, h8300_register_type
);
1326 set_gdbarch_print_registers_info (gdbarch
, h8300_print_registers_info
);
1327 set_gdbarch_print_float_info (gdbarch
, h8300_print_float_info
);
1332 set_gdbarch_skip_prologue (gdbarch
, h8300_skip_prologue
);
1334 /* Frame unwinder. */
1335 set_gdbarch_unwind_pc (gdbarch
, h8300_unwind_pc
);
1336 set_gdbarch_unwind_sp (gdbarch
, h8300_unwind_sp
);
1337 set_gdbarch_unwind_dummy_id (gdbarch
, h8300_unwind_dummy_id
);
1338 frame_base_set_default (gdbarch
, &h8300_frame_base
);
1343 /* Stack grows up. */
1344 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1346 set_gdbarch_breakpoint_from_pc (gdbarch
, h8300_breakpoint_from_pc
);
1347 set_gdbarch_push_dummy_call (gdbarch
, h8300_push_dummy_call
);
1349 set_gdbarch_char_signed (gdbarch
, 0);
1350 set_gdbarch_int_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1351 set_gdbarch_long_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1352 set_gdbarch_long_long_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
1353 set_gdbarch_double_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1354 set_gdbarch_long_double_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1356 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
1358 /* Hook in the DWARF CFI frame unwinder. */
1359 frame_unwind_append_sniffer (gdbarch
, dwarf2_frame_sniffer
);
1360 frame_unwind_append_sniffer (gdbarch
, h8300_frame_sniffer
);
1366 extern initialize_file_ftype _initialize_h8300_tdep
; /* -Wmissing-prototypes */
1369 _initialize_h8300_tdep (void)
1371 register_gdbarch_init (bfd_arch_h8300
, h8300_gdbarch_init
);
1375 is_h8300hmode (struct gdbarch
*gdbarch
)
1377 return gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sx
1378 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sxn
1379 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300s
1380 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sn
1381 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300h
1382 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300hn
;
1386 is_h8300smode (struct gdbarch
*gdbarch
)
1388 return gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sx
1389 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sxn
1390 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300s
1391 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sn
;
1395 is_h8300sxmode (struct gdbarch
*gdbarch
)
1397 return gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sx
1398 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sxn
;
1402 is_h8300_normal_mode (struct gdbarch
*gdbarch
)
1404 return gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sxn
1405 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sn
1406 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300hn
;