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, 2009
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 Contributed by Steve Chamberlain
29 #include "arch-utils.h"
33 #include "gdb_assert.h"
35 #include "dwarf2-frame.h"
36 #include "frame-base.h"
37 #include "frame-unwind.h"
41 E_R0_REGNUM
, E_ER0_REGNUM
= E_R0_REGNUM
, E_ARG0_REGNUM
= E_R0_REGNUM
,
42 E_RET0_REGNUM
= E_R0_REGNUM
,
43 E_R1_REGNUM
, E_ER1_REGNUM
= E_R1_REGNUM
, E_RET1_REGNUM
= E_R1_REGNUM
,
44 E_R2_REGNUM
, E_ER2_REGNUM
= E_R2_REGNUM
, E_ARGLAST_REGNUM
= E_R2_REGNUM
,
45 E_R3_REGNUM
, E_ER3_REGNUM
= E_R3_REGNUM
,
46 E_R4_REGNUM
, E_ER4_REGNUM
= E_R4_REGNUM
,
47 E_R5_REGNUM
, E_ER5_REGNUM
= E_R5_REGNUM
,
48 E_R6_REGNUM
, E_ER6_REGNUM
= E_R6_REGNUM
, E_FP_REGNUM
= E_R6_REGNUM
,
53 E_TICK_REGNUM
, E_EXR_REGNUM
= E_TICK_REGNUM
,
54 E_INST_REGNUM
, E_TICKS_REGNUM
= E_INST_REGNUM
,
62 #define H8300_MAX_NUM_REGS 18
64 #define E_PSEUDO_CCR_REGNUM(gdbarch) (gdbarch_num_regs (gdbarch))
65 #define E_PSEUDO_EXR_REGNUM(gdbarch) (gdbarch_num_regs (gdbarch)+1)
67 struct h8300_frame_cache
74 /* Flag showing that a frame has been created in the prologue code. */
77 /* Saved registers. */
78 CORE_ADDR saved_regs
[H8300_MAX_NUM_REGS
];
86 h8300_max_reg_size
= 4,
89 static int is_h8300hmode (struct gdbarch
*gdbarch
);
90 static int is_h8300smode (struct gdbarch
*gdbarch
);
91 static int is_h8300sxmode (struct gdbarch
*gdbarch
);
92 static int is_h8300_normal_mode (struct gdbarch
*gdbarch
);
94 #define BINWORD(gdbarch) ((is_h8300hmode (gdbarch) \
95 && !is_h8300_normal_mode (gdbarch)) \
96 ? h8300h_reg_size : h8300_reg_size)
99 h8300_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
101 return frame_unwind_register_unsigned (next_frame
, E_PC_REGNUM
);
105 h8300_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
107 return frame_unwind_register_unsigned (next_frame
, E_SP_REGNUM
);
110 static struct frame_id
111 h8300_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
113 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, E_SP_REGNUM
);
114 return frame_id_build (sp
, get_frame_pc (this_frame
));
119 /* Allocate and initialize a frame cache. */
122 h8300_init_frame_cache (struct gdbarch
*gdbarch
,
123 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 (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
*this_frame
, void **this_cache
)
426 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
427 struct h8300_frame_cache
*cache
;
430 CORE_ADDR current_pc
;
435 cache
= FRAME_OBSTACK_ZALLOC (struct h8300_frame_cache
);
436 h8300_init_frame_cache (gdbarch
, cache
);
439 /* In principle, for normal frames, %fp holds the frame pointer,
440 which holds the base address for the current stack frame.
441 However, for functions that don't need it, the frame pointer is
442 optional. For these "frameless" functions the frame pointer is
443 actually the frame pointer of the calling frame. */
445 cache
->base
= get_frame_register_unsigned (this_frame
, E_FP_REGNUM
);
446 if (cache
->base
== 0)
449 cache
->saved_regs
[E_PC_REGNUM
] = -BINWORD (gdbarch
);
451 cache
->pc
= get_frame_func (this_frame
);
452 current_pc
= get_frame_pc (this_frame
);
454 h8300_analyze_prologue (cache
->pc
, current_pc
, cache
);
458 /* We didn't find a valid frame, which means that CACHE->base
459 currently holds the frame pointer for our calling frame. If
460 we're at the start of a function, or somewhere half-way its
461 prologue, the function's frame probably hasn't been fully
462 setup yet. Try to reconstruct the base address for the stack
463 frame by looking at the stack pointer. For truly "frameless"
464 functions this might work too. */
466 cache
->base
= get_frame_register_unsigned (this_frame
, E_SP_REGNUM
)
468 cache
->saved_sp
= cache
->base
+ BINWORD (gdbarch
);
469 cache
->saved_regs
[E_PC_REGNUM
] = 0;
473 cache
->saved_sp
= cache
->base
+ 2 * BINWORD (gdbarch
);
474 cache
->saved_regs
[E_PC_REGNUM
] = -BINWORD (gdbarch
);
477 /* Adjust all the saved registers such that they contain addresses
478 instead of offsets. */
479 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
480 if (cache
->saved_regs
[i
] != -1)
481 cache
->saved_regs
[i
] = cache
->base
- cache
->saved_regs
[i
];
487 h8300_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
488 struct frame_id
*this_id
)
490 struct h8300_frame_cache
*cache
=
491 h8300_frame_cache (this_frame
, this_cache
);
493 /* This marks the outermost frame. */
494 if (cache
->base
== 0)
497 *this_id
= frame_id_build (cache
->saved_sp
, cache
->pc
);
500 static struct value
*
501 h8300_frame_prev_register (struct frame_info
*this_frame
, void **this_cache
,
504 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
505 struct h8300_frame_cache
*cache
=
506 h8300_frame_cache (this_frame
, this_cache
);
508 gdb_assert (regnum
>= 0);
510 if (regnum
== E_SP_REGNUM
&& cache
->saved_sp
)
511 return frame_unwind_got_constant (this_frame
, regnum
, cache
->saved_sp
);
513 if (regnum
< gdbarch_num_regs (gdbarch
)
514 && cache
->saved_regs
[regnum
] != -1)
515 return frame_unwind_got_memory (this_frame
, regnum
,
516 cache
->saved_regs
[regnum
]);
518 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
521 static const struct frame_unwind h8300_frame_unwind
= {
524 h8300_frame_prev_register
,
526 default_frame_sniffer
530 h8300_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
532 struct h8300_frame_cache
*cache
= h8300_frame_cache (this_frame
, this_cache
);
536 static const struct frame_base h8300_frame_base
= {
538 h8300_frame_base_address
,
539 h8300_frame_base_address
,
540 h8300_frame_base_address
544 h8300_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
546 CORE_ADDR func_addr
= 0 , func_end
= 0;
548 if (find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
550 struct symtab_and_line sal
;
551 struct h8300_frame_cache cache
;
553 /* Found a function. */
554 sal
= find_pc_line (func_addr
, 0);
555 if (sal
.end
&& sal
.end
< func_end
)
556 /* Found a line number, use it as end of prologue. */
559 /* No useable line symbol. Use prologue parsing method. */
560 h8300_init_frame_cache (gdbarch
, &cache
);
561 return h8300_analyze_prologue (func_addr
, func_end
, &cache
);
564 /* No function symbol -- just return the PC. */
565 return (CORE_ADDR
) pc
;
568 /* Function: push_dummy_call
569 Setup the function arguments for calling a function in the inferior.
570 In this discussion, a `word' is 16 bits on the H8/300s, and 32 bits
573 There are actually two ABI's here: -mquickcall (the default) and
574 -mno-quickcall. With -mno-quickcall, all arguments are passed on
575 the stack after the return address, word-aligned. With
576 -mquickcall, GCC tries to use r0 -- r2 to pass registers. Since
577 GCC doesn't indicate in the object file which ABI was used to
578 compile it, GDB only supports the default --- -mquickcall.
580 Here are the rules for -mquickcall, in detail:
582 Each argument, whether scalar or aggregate, is padded to occupy a
583 whole number of words. Arguments smaller than a word are padded at
584 the most significant end; those larger than a word are padded at
585 the least significant end.
587 The initial arguments are passed in r0 -- r2. Earlier arguments go in
588 lower-numbered registers. Multi-word arguments are passed in
589 consecutive registers, with the most significant end in the
590 lower-numbered register.
592 If an argument doesn't fit entirely in the remaining registers, it
593 is passed entirely on the stack. Stack arguments begin just after
594 the return address. Once an argument has overflowed onto the stack
595 this way, all subsequent arguments are passed on the stack.
597 The above rule has odd consequences. For example, on the h8/300s,
598 if a function takes two longs and an int as arguments:
599 - the first long will be passed in r0/r1,
600 - the second long will be passed entirely on the stack, since it
602 - and the int will be passed on the stack, even though it could fit
605 A weird exception: if an argument is larger than a word, but not a
606 whole number of words in length (before padding), it is passed on
607 the stack following the rules for stack arguments above, even if
608 there are sufficient registers available to hold it. Stranger
609 still, the argument registers are still `used up' --- even though
610 there's nothing in them.
612 So, for example, on the h8/300s, if a function expects a three-byte
613 structure and an int, the structure will go on the stack, and the
614 int will go in r2, not r0.
616 If the function returns an aggregate type (struct, union, or class)
617 by value, the caller must allocate space to hold the return value,
618 and pass the callee a pointer to this space as an invisible first
621 For varargs functions, the last fixed argument and all the variable
622 arguments are always passed on the stack. This means that calls to
623 varargs functions don't work properly unless there is a prototype
626 Basically, this ABI is not good, for the following reasons:
627 - You can't call vararg functions properly unless a prototype is in scope.
628 - Structure passing is inconsistent, to no purpose I can see.
629 - It often wastes argument registers, of which there are only three
633 h8300_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
634 struct regcache
*regcache
, CORE_ADDR bp_addr
,
635 int nargs
, struct value
**args
, CORE_ADDR sp
,
636 int struct_return
, CORE_ADDR struct_addr
)
638 int stack_alloc
= 0, stack_offset
= 0;
639 int wordsize
= BINWORD (gdbarch
);
640 int reg
= E_ARG0_REGNUM
;
643 /* First, make sure the stack is properly aligned. */
644 sp
= align_down (sp
, wordsize
);
646 /* Now make sure there's space on the stack for the arguments. We
647 may over-allocate a little here, but that won't hurt anything. */
648 for (argument
= 0; argument
< nargs
; argument
++)
649 stack_alloc
+= align_up (TYPE_LENGTH (value_type (args
[argument
])),
653 /* Now load as many arguments as possible into registers, and push
654 the rest onto the stack.
655 If we're returning a structure by value, then we must pass a
656 pointer to the buffer for the return value as an invisible first
659 regcache_cooked_write_unsigned (regcache
, reg
++, struct_addr
);
661 for (argument
= 0; argument
< nargs
; argument
++)
663 struct type
*type
= value_type (args
[argument
]);
664 int len
= TYPE_LENGTH (type
);
665 char *contents
= (char *) value_contents (args
[argument
]);
667 /* Pad the argument appropriately. */
668 int padded_len
= align_up (len
, wordsize
);
669 gdb_byte
*padded
= alloca (padded_len
);
671 memset (padded
, 0, padded_len
);
672 memcpy (len
< wordsize
? padded
+ padded_len
- len
: padded
,
675 /* Could the argument fit in the remaining registers? */
676 if (padded_len
<= (E_ARGLAST_REGNUM
- reg
+ 1) * wordsize
)
678 /* Are we going to pass it on the stack anyway, for no good
680 if (len
> wordsize
&& len
% wordsize
)
682 /* I feel so unclean. */
683 write_memory (sp
+ stack_offset
, padded
, padded_len
);
684 stack_offset
+= padded_len
;
686 /* That's right --- even though we passed the argument
687 on the stack, we consume the registers anyway! Love
689 reg
+= padded_len
/ wordsize
;
693 /* Heavens to Betsy --- it's really going in registers!
694 It would be nice if we could use write_register_bytes
695 here, but on the h8/300s, there are gaps between
696 the registers in the register file. */
699 for (offset
= 0; offset
< padded_len
; offset
+= wordsize
)
701 ULONGEST word
= extract_unsigned_integer (padded
+ offset
,
703 regcache_cooked_write_unsigned (regcache
, reg
++, word
);
709 /* It doesn't fit in registers! Onto the stack it goes. */
710 write_memory (sp
+ stack_offset
, padded
, padded_len
);
711 stack_offset
+= padded_len
;
713 /* Once one argument has spilled onto the stack, all
714 subsequent arguments go on the stack. */
715 reg
= E_ARGLAST_REGNUM
+ 1;
719 /* Store return address. */
721 write_memory_unsigned_integer (sp
, wordsize
, bp_addr
);
723 /* Update stack pointer. */
724 regcache_cooked_write_unsigned (regcache
, E_SP_REGNUM
, sp
);
726 /* Return the new stack pointer minus the return address slot since
727 that's what DWARF2/GCC uses as the frame's CFA. */
728 return sp
+ wordsize
;
731 /* Function: extract_return_value
732 Figure out where in REGBUF the called function has left its return value.
733 Copy that into VALBUF. Be sure to account for CPU type. */
736 h8300_extract_return_value (struct type
*type
, struct regcache
*regcache
,
739 int len
= TYPE_LENGTH (type
);
746 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &c
);
747 store_unsigned_integer (valbuf
, len
, c
);
749 case 4: /* Needs two registers on plain H8/300 */
750 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &c
);
751 store_unsigned_integer (valbuf
, 2, c
);
752 regcache_cooked_read_unsigned (regcache
, E_RET1_REGNUM
, &c
);
753 store_unsigned_integer ((void *) ((char *) valbuf
+ 2), 2, c
);
755 case 8: /* long long is now 8 bytes. */
756 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
758 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &addr
);
759 c
= read_memory_unsigned_integer ((CORE_ADDR
) addr
, len
);
760 store_unsigned_integer (valbuf
, len
, c
);
764 error ("I don't know how this 8 byte value is returned.");
771 h8300h_extract_return_value (struct type
*type
, struct regcache
*regcache
,
774 int len
= TYPE_LENGTH (type
);
782 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &c
);
783 store_unsigned_integer (valbuf
, len
, c
);
785 case 8: /* long long is now 8 bytes. */
786 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
788 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &c
);
789 store_unsigned_integer (valbuf
, 4, c
);
790 regcache_cooked_read_unsigned (regcache
, E_RET1_REGNUM
, &c
);
791 store_unsigned_integer ((void *) ((char *) valbuf
+ 4), 4, c
);
795 error ("I don't know how this 8 byte value is returned.");
802 h8300_use_struct_convention (struct type
*value_type
)
804 /* Types of 1, 2 or 4 bytes are returned in R0/R1, everything else on the
807 if (TYPE_CODE (value_type
) == TYPE_CODE_STRUCT
808 || TYPE_CODE (value_type
) == TYPE_CODE_UNION
)
810 return !(TYPE_LENGTH (value_type
) == 1
811 || TYPE_LENGTH (value_type
) == 2
812 || TYPE_LENGTH (value_type
) == 4);
816 h8300h_use_struct_convention (struct type
*value_type
)
818 /* Types of 1, 2 or 4 bytes are returned in R0, INT types of 8 bytes are
819 returned in R0/R1, everything else on the stack. */
820 if (TYPE_CODE (value_type
) == TYPE_CODE_STRUCT
821 || TYPE_CODE (value_type
) == TYPE_CODE_UNION
)
823 return !(TYPE_LENGTH (value_type
) == 1
824 || TYPE_LENGTH (value_type
) == 2
825 || TYPE_LENGTH (value_type
) == 4
826 || (TYPE_LENGTH (value_type
) == 8
827 && TYPE_CODE (value_type
) == TYPE_CODE_INT
));
830 /* Function: store_return_value
831 Place the appropriate value in the appropriate registers.
832 Primarily used by the RETURN command. */
835 h8300_store_return_value (struct type
*type
, struct regcache
*regcache
,
838 int len
= TYPE_LENGTH (type
);
844 case 2: /* short... */
845 val
= extract_unsigned_integer (valbuf
, len
);
846 regcache_cooked_write_unsigned (regcache
, E_RET0_REGNUM
, val
);
848 case 4: /* long, float */
849 val
= extract_unsigned_integer (valbuf
, len
);
850 regcache_cooked_write_unsigned (regcache
, E_RET0_REGNUM
,
851 (val
>> 16) & 0xffff);
852 regcache_cooked_write_unsigned (regcache
, E_RET1_REGNUM
, val
& 0xffff);
854 case 8: /* long long, double and long double are all defined
855 as 4 byte types so far so this shouldn't happen. */
856 error ("I don't know how to return an 8 byte value.");
862 h8300h_store_return_value (struct type
*type
, struct regcache
*regcache
,
865 int len
= TYPE_LENGTH (type
);
872 case 4: /* long, float */
873 val
= extract_unsigned_integer (valbuf
, len
);
874 regcache_cooked_write_unsigned (regcache
, E_RET0_REGNUM
, val
);
877 val
= extract_unsigned_integer (valbuf
, len
);
878 regcache_cooked_write_unsigned (regcache
, E_RET0_REGNUM
,
879 (val
>> 32) & 0xffffffff);
880 regcache_cooked_write_unsigned (regcache
, E_RET1_REGNUM
,
886 static enum return_value_convention
887 h8300_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
888 struct type
*type
, struct regcache
*regcache
,
889 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
891 if (h8300_use_struct_convention (type
))
892 return RETURN_VALUE_STRUCT_CONVENTION
;
894 h8300_store_return_value (type
, regcache
, writebuf
);
896 h8300_extract_return_value (type
, regcache
, readbuf
);
897 return RETURN_VALUE_REGISTER_CONVENTION
;
900 static enum return_value_convention
901 h8300h_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
902 struct type
*type
, struct regcache
*regcache
,
903 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
905 if (h8300h_use_struct_convention (type
))
911 regcache_raw_read_unsigned (regcache
, E_R0_REGNUM
, &addr
);
912 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
915 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
918 h8300h_store_return_value (type
, regcache
, writebuf
);
920 h8300h_extract_return_value (type
, regcache
, readbuf
);
921 return RETURN_VALUE_REGISTER_CONVENTION
;
924 static struct cmd_list_element
*setmachinelist
;
927 h8300_register_name (struct gdbarch
*gdbarch
, int regno
)
929 /* The register names change depending on which h8300 processor
931 static char *register_names
[] = {
932 "r0", "r1", "r2", "r3", "r4", "r5", "r6",
933 "sp", "", "pc", "cycles", "tick", "inst",
934 "ccr", /* pseudo register */
937 || regno
>= (sizeof (register_names
) / sizeof (*register_names
)))
938 internal_error (__FILE__
, __LINE__
,
939 "h8300_register_name: illegal register number %d", regno
);
941 return register_names
[regno
];
945 h8300s_register_name (struct gdbarch
*gdbarch
, int regno
)
947 static char *register_names
[] = {
948 "er0", "er1", "er2", "er3", "er4", "er5", "er6",
949 "sp", "", "pc", "cycles", "", "tick", "inst",
951 "ccr", "exr" /* pseudo registers */
954 || regno
>= (sizeof (register_names
) / sizeof (*register_names
)))
955 internal_error (__FILE__
, __LINE__
,
956 "h8300s_register_name: illegal register number %d",
959 return register_names
[regno
];
963 h8300sx_register_name (struct gdbarch
*gdbarch
, int regno
)
965 static char *register_names
[] = {
966 "er0", "er1", "er2", "er3", "er4", "er5", "er6",
967 "sp", "", "pc", "cycles", "", "tick", "inst",
968 "mach", "macl", "sbr", "vbr",
969 "ccr", "exr" /* pseudo registers */
972 || regno
>= (sizeof (register_names
) / sizeof (*register_names
)))
973 internal_error (__FILE__
, __LINE__
,
974 "h8300sx_register_name: illegal register number %d",
977 return register_names
[regno
];
981 h8300_print_register (struct gdbarch
*gdbarch
, struct ui_file
*file
,
982 struct frame_info
*frame
, int regno
)
985 const char *name
= gdbarch_register_name (gdbarch
, regno
);
990 rval
= get_frame_register_signed (frame
, regno
);
992 fprintf_filtered (file
, "%-14s ", name
);
993 if ((regno
== E_PSEUDO_CCR_REGNUM (gdbarch
)) || \
994 (regno
== E_PSEUDO_EXR_REGNUM (gdbarch
) && is_h8300smode (gdbarch
)))
996 fprintf_filtered (file
, "0x%02x ", (unsigned char) rval
);
997 print_longest (file
, 'u', 1, rval
);
1001 fprintf_filtered (file
, "0x%s ", phex ((ULONGEST
) rval
,
1002 BINWORD (gdbarch
)));
1003 print_longest (file
, 'd', 1, rval
);
1005 if (regno
== E_PSEUDO_CCR_REGNUM (gdbarch
))
1009 unsigned char l
= rval
& 0xff;
1010 fprintf_filtered (file
, "\t");
1011 fprintf_filtered (file
, "I-%d ", (l
& 0x80) != 0);
1012 fprintf_filtered (file
, "UI-%d ", (l
& 0x40) != 0);
1013 fprintf_filtered (file
, "H-%d ", (l
& 0x20) != 0);
1014 fprintf_filtered (file
, "U-%d ", (l
& 0x10) != 0);
1019 fprintf_filtered (file
, "N-%d ", N
);
1020 fprintf_filtered (file
, "Z-%d ", Z
);
1021 fprintf_filtered (file
, "V-%d ", V
);
1022 fprintf_filtered (file
, "C-%d ", C
);
1024 fprintf_filtered (file
, "u> ");
1026 fprintf_filtered (file
, "u<= ");
1028 fprintf_filtered (file
, "u>= ");
1030 fprintf_filtered (file
, "u< ");
1032 fprintf_filtered (file
, "!= ");
1034 fprintf_filtered (file
, "== ");
1036 fprintf_filtered (file
, ">= ");
1038 fprintf_filtered (file
, "< ");
1039 if ((Z
| (N
^ V
)) == 0)
1040 fprintf_filtered (file
, "> ");
1041 if ((Z
| (N
^ V
)) == 1)
1042 fprintf_filtered (file
, "<= ");
1044 else if (regno
== E_PSEUDO_EXR_REGNUM (gdbarch
) && is_h8300smode (gdbarch
))
1047 unsigned char l
= rval
& 0xff;
1048 fprintf_filtered (file
, "\t");
1049 fprintf_filtered (file
, "T-%d - - - ", (l
& 0x80) != 0);
1050 fprintf_filtered (file
, "I2-%d ", (l
& 4) != 0);
1051 fprintf_filtered (file
, "I1-%d ", (l
& 2) != 0);
1052 fprintf_filtered (file
, "I0-%d", (l
& 1) != 0);
1054 fprintf_filtered (file
, "\n");
1058 h8300_print_registers_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
1059 struct frame_info
*frame
, int regno
, int cpregs
)
1063 for (regno
= E_R0_REGNUM
; regno
<= E_SP_REGNUM
; ++regno
)
1064 h8300_print_register (gdbarch
, file
, frame
, regno
);
1065 h8300_print_register (gdbarch
, file
, frame
,
1066 E_PSEUDO_CCR_REGNUM (gdbarch
));
1067 h8300_print_register (gdbarch
, file
, frame
, E_PC_REGNUM
);
1068 if (is_h8300smode (gdbarch
))
1070 h8300_print_register (gdbarch
, file
, frame
,
1071 E_PSEUDO_EXR_REGNUM (gdbarch
));
1072 if (is_h8300sxmode (gdbarch
))
1074 h8300_print_register (gdbarch
, file
, frame
, E_SBR_REGNUM
);
1075 h8300_print_register (gdbarch
, file
, frame
, E_VBR_REGNUM
);
1077 h8300_print_register (gdbarch
, file
, frame
, E_MACH_REGNUM
);
1078 h8300_print_register (gdbarch
, file
, frame
, E_MACL_REGNUM
);
1079 h8300_print_register (gdbarch
, file
, frame
, E_CYCLES_REGNUM
);
1080 h8300_print_register (gdbarch
, file
, frame
, E_TICKS_REGNUM
);
1081 h8300_print_register (gdbarch
, file
, frame
, E_INSTS_REGNUM
);
1085 h8300_print_register (gdbarch
, file
, frame
, E_CYCLES_REGNUM
);
1086 h8300_print_register (gdbarch
, file
, frame
, E_TICK_REGNUM
);
1087 h8300_print_register (gdbarch
, file
, frame
, E_INST_REGNUM
);
1092 if (regno
== E_CCR_REGNUM
)
1093 h8300_print_register (gdbarch
, file
, frame
,
1094 E_PSEUDO_CCR_REGNUM (gdbarch
));
1095 else if (regno
== E_PSEUDO_EXR_REGNUM (gdbarch
)
1096 && is_h8300smode (gdbarch
))
1097 h8300_print_register (gdbarch
, file
, frame
,
1098 E_PSEUDO_EXR_REGNUM (gdbarch
));
1100 h8300_print_register (gdbarch
, file
, frame
, regno
);
1104 static struct type
*
1105 h8300_register_type (struct gdbarch
*gdbarch
, int regno
)
1107 if (regno
< 0 || regno
>= gdbarch_num_regs (gdbarch
)
1108 + gdbarch_num_pseudo_regs (gdbarch
))
1109 internal_error (__FILE__
, __LINE__
,
1110 "h8300_register_type: illegal register number %d", regno
);
1116 return builtin_type (gdbarch
)->builtin_func_ptr
;
1119 return builtin_type (gdbarch
)->builtin_data_ptr
;
1121 if (regno
== E_PSEUDO_CCR_REGNUM (gdbarch
))
1122 return builtin_type_uint8
;
1123 else if (regno
== E_PSEUDO_EXR_REGNUM (gdbarch
))
1124 return builtin_type_uint8
;
1125 else if (is_h8300hmode (gdbarch
))
1126 return builtin_type_int32
;
1128 return builtin_type_int16
;
1134 h8300_pseudo_register_read (struct gdbarch
*gdbarch
,
1135 struct regcache
*regcache
, int regno
,
1138 if (regno
== E_PSEUDO_CCR_REGNUM (gdbarch
))
1139 regcache_raw_read (regcache
, E_CCR_REGNUM
, buf
);
1140 else if (regno
== E_PSEUDO_EXR_REGNUM (gdbarch
))
1141 regcache_raw_read (regcache
, E_EXR_REGNUM
, buf
);
1143 regcache_raw_read (regcache
, regno
, buf
);
1147 h8300_pseudo_register_write (struct gdbarch
*gdbarch
,
1148 struct regcache
*regcache
, int regno
,
1149 const gdb_byte
*buf
)
1151 if (regno
== E_PSEUDO_CCR_REGNUM (gdbarch
))
1152 regcache_raw_write (regcache
, E_CCR_REGNUM
, buf
);
1153 else if (regno
== E_PSEUDO_EXR_REGNUM (gdbarch
))
1154 regcache_raw_write (regcache
, E_EXR_REGNUM
, buf
);
1156 regcache_raw_write (regcache
, regno
, buf
);
1160 h8300_dbg_reg_to_regnum (struct gdbarch
*gdbarch
, int regno
)
1162 if (regno
== E_CCR_REGNUM
)
1163 return E_PSEUDO_CCR_REGNUM (gdbarch
);
1168 h8300s_dbg_reg_to_regnum (struct gdbarch
*gdbarch
, int regno
)
1170 if (regno
== E_CCR_REGNUM
)
1171 return E_PSEUDO_CCR_REGNUM (gdbarch
);
1172 if (regno
== E_EXR_REGNUM
)
1173 return E_PSEUDO_EXR_REGNUM (gdbarch
);
1177 const static unsigned char *
1178 h8300_breakpoint_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*pcptr
,
1181 /*static unsigned char breakpoint[] = { 0x7A, 0xFF }; *//* ??? */
1182 static unsigned char breakpoint
[] = { 0x01, 0x80 }; /* Sleep */
1184 *lenptr
= sizeof (breakpoint
);
1189 h8300_print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
1190 struct frame_info
*frame
, const char *args
)
1192 fprintf_filtered (file
, "\
1193 No floating-point info available for this processor.\n");
1196 static struct gdbarch
*
1197 h8300_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1199 struct gdbarch_tdep
*tdep
= NULL
;
1200 struct gdbarch
*gdbarch
;
1202 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1204 return arches
->gdbarch
;
1207 tdep
= (struct gdbarch_tdep
*) xmalloc (sizeof (struct gdbarch_tdep
));
1210 if (info
.bfd_arch_info
->arch
!= bfd_arch_h8300
)
1213 gdbarch
= gdbarch_alloc (&info
, 0);
1215 switch (info
.bfd_arch_info
->mach
)
1217 case bfd_mach_h8300
:
1218 set_gdbarch_num_regs (gdbarch
, 13);
1219 set_gdbarch_num_pseudo_regs (gdbarch
, 1);
1220 set_gdbarch_ecoff_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1221 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1222 set_gdbarch_stab_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1223 set_gdbarch_register_name (gdbarch
, h8300_register_name
);
1224 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1225 set_gdbarch_addr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1226 set_gdbarch_return_value (gdbarch
, h8300_return_value
);
1227 set_gdbarch_print_insn (gdbarch
, print_insn_h8300
);
1229 case bfd_mach_h8300h
:
1230 case bfd_mach_h8300hn
:
1231 set_gdbarch_num_regs (gdbarch
, 13);
1232 set_gdbarch_num_pseudo_regs (gdbarch
, 1);
1233 set_gdbarch_ecoff_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1234 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1235 set_gdbarch_stab_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1236 set_gdbarch_register_name (gdbarch
, h8300_register_name
);
1237 if (info
.bfd_arch_info
->mach
!= bfd_mach_h8300hn
)
1239 set_gdbarch_ptr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1240 set_gdbarch_addr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1244 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1245 set_gdbarch_addr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1247 set_gdbarch_return_value (gdbarch
, h8300h_return_value
);
1248 set_gdbarch_print_insn (gdbarch
, print_insn_h8300h
);
1250 case bfd_mach_h8300s
:
1251 case bfd_mach_h8300sn
:
1252 set_gdbarch_num_regs (gdbarch
, 16);
1253 set_gdbarch_num_pseudo_regs (gdbarch
, 2);
1254 set_gdbarch_ecoff_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1255 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1256 set_gdbarch_stab_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1257 set_gdbarch_register_name (gdbarch
, h8300s_register_name
);
1258 if (info
.bfd_arch_info
->mach
!= bfd_mach_h8300sn
)
1260 set_gdbarch_ptr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1261 set_gdbarch_addr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1265 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1266 set_gdbarch_addr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1268 set_gdbarch_return_value (gdbarch
, h8300h_return_value
);
1269 set_gdbarch_print_insn (gdbarch
, print_insn_h8300s
);
1271 case bfd_mach_h8300sx
:
1272 case bfd_mach_h8300sxn
:
1273 set_gdbarch_num_regs (gdbarch
, 18);
1274 set_gdbarch_num_pseudo_regs (gdbarch
, 2);
1275 set_gdbarch_ecoff_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
, h8300sx_register_name
);
1279 if (info
.bfd_arch_info
->mach
!= bfd_mach_h8300sxn
)
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
);
1294 set_gdbarch_pseudo_register_read (gdbarch
, h8300_pseudo_register_read
);
1295 set_gdbarch_pseudo_register_write (gdbarch
, h8300_pseudo_register_write
);
1298 * Basic register fields and methods.
1301 set_gdbarch_sp_regnum (gdbarch
, E_SP_REGNUM
);
1302 set_gdbarch_pc_regnum (gdbarch
, E_PC_REGNUM
);
1303 set_gdbarch_register_type (gdbarch
, h8300_register_type
);
1304 set_gdbarch_print_registers_info (gdbarch
, h8300_print_registers_info
);
1305 set_gdbarch_print_float_info (gdbarch
, h8300_print_float_info
);
1310 set_gdbarch_skip_prologue (gdbarch
, h8300_skip_prologue
);
1312 /* Frame unwinder. */
1313 set_gdbarch_unwind_pc (gdbarch
, h8300_unwind_pc
);
1314 set_gdbarch_unwind_sp (gdbarch
, h8300_unwind_sp
);
1315 set_gdbarch_dummy_id (gdbarch
, h8300_dummy_id
);
1316 frame_base_set_default (gdbarch
, &h8300_frame_base
);
1321 /* Stack grows up. */
1322 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1324 set_gdbarch_breakpoint_from_pc (gdbarch
, h8300_breakpoint_from_pc
);
1325 set_gdbarch_push_dummy_call (gdbarch
, h8300_push_dummy_call
);
1327 set_gdbarch_char_signed (gdbarch
, 0);
1328 set_gdbarch_int_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1329 set_gdbarch_long_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1330 set_gdbarch_long_long_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
1331 set_gdbarch_double_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1332 set_gdbarch_long_double_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1334 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
1336 /* Hook in the DWARF CFI frame unwinder. */
1337 dwarf2_append_unwinders (gdbarch
);
1338 frame_unwind_append_unwinder (gdbarch
, &h8300_frame_unwind
);
1344 extern initialize_file_ftype _initialize_h8300_tdep
; /* -Wmissing-prototypes */
1347 _initialize_h8300_tdep (void)
1349 register_gdbarch_init (bfd_arch_h8300
, h8300_gdbarch_init
);
1353 is_h8300hmode (struct gdbarch
*gdbarch
)
1355 return gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sx
1356 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sxn
1357 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300s
1358 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sn
1359 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300h
1360 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300hn
;
1364 is_h8300smode (struct gdbarch
*gdbarch
)
1366 return gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sx
1367 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sxn
1368 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300s
1369 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sn
;
1373 is_h8300sxmode (struct gdbarch
*gdbarch
)
1375 return gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sx
1376 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sxn
;
1380 is_h8300_normal_mode (struct gdbarch
*gdbarch
)
1382 return gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sxn
1383 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sn
1384 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300hn
;