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 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_num_regs (current_gdbarch))
64 #define E_PSEUDO_EXR_REGNUM (gdbarch_num_regs (current_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 ((is_h8300hmode (current_gdbarch) \
94 && !is_h8300_normal_mode (current_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_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
112 return frame_id_build (h8300_unwind_sp (gdbarch
, next_frame
),
113 frame_pc_unwind (next_frame
));
118 /* Allocate and initialize a frame cache. */
121 h8300_init_frame_cache (struct h8300_frame_cache
*cache
)
127 cache
->sp_offset
= 0;
130 /* Frameless until proven otherwise. */
133 /* Saved registers. We initialize these to -1 since zero is a valid
134 offset (that's where %fp is supposed to be stored). */
135 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
136 cache
->saved_regs
[i
] = -1;
139 #define IS_MOVB_RnRm(x) (((x) & 0xff88) == 0x0c88)
140 #define IS_MOVW_RnRm(x) (((x) & 0xff88) == 0x0d00)
141 #define IS_MOVL_RnRm(x) (((x) & 0xff88) == 0x0f80)
142 #define IS_MOVB_Rn16_SP(x) (((x) & 0xfff0) == 0x6ee0)
143 #define IS_MOVB_EXT(x) ((x) == 0x7860)
144 #define IS_MOVB_Rn24_SP(x) (((x) & 0xfff0) == 0x6aa0)
145 #define IS_MOVW_Rn16_SP(x) (((x) & 0xfff0) == 0x6fe0)
146 #define IS_MOVW_EXT(x) ((x) == 0x78e0)
147 #define IS_MOVW_Rn24_SP(x) (((x) & 0xfff0) == 0x6ba0)
148 /* Same instructions as mov.w, just prefixed with 0x0100 */
149 #define IS_MOVL_PRE(x) ((x) == 0x0100)
150 #define IS_MOVL_Rn16_SP(x) (((x) & 0xfff0) == 0x6fe0)
151 #define IS_MOVL_EXT(x) ((x) == 0x78e0)
152 #define IS_MOVL_Rn24_SP(x) (((x) & 0xfff0) == 0x6ba0)
154 #define IS_PUSHFP_MOVESPFP(x) ((x) == 0x6df60d76)
155 #define IS_PUSH_FP(x) ((x) == 0x01006df6)
156 #define IS_MOV_SP_FP(x) ((x) == 0x0ff6)
157 #define IS_SUB2_SP(x) ((x) == 0x1b87)
158 #define IS_SUB4_SP(x) ((x) == 0x1b97)
159 #define IS_ADD_IMM_SP(x) ((x) == 0x7a1f)
160 #define IS_SUB_IMM_SP(x) ((x) == 0x7a3f)
161 #define IS_SUBL4_SP(x) ((x) == 0x1acf)
162 #define IS_MOV_IMM_Rn(x) (((x) & 0xfff0) == 0x7905)
163 #define IS_SUB_RnSP(x) (((x) & 0xff0f) == 0x1907)
164 #define IS_ADD_RnSP(x) (((x) & 0xff0f) == 0x0907)
165 #define IS_PUSH(x) (((x) & 0xfff0) == 0x6df0)
167 /* If the instruction at PC is an argument register spill, return its
168 length. Otherwise, return zero.
170 An argument register spill is an instruction that moves an argument
171 from the register in which it was passed to the stack slot in which
172 it really lives. It is a byte, word, or longword move from an
173 argument register to a negative offset from the frame pointer.
175 CV, 2003-06-16: Or, in optimized code or when the `register' qualifier
176 is used, it could be a byte, word or long move to registers r3-r5. */
179 h8300_is_argument_spill (CORE_ADDR pc
)
181 int w
= read_memory_unsigned_integer (pc
, 2);
183 if ((IS_MOVB_RnRm (w
) || IS_MOVW_RnRm (w
) || IS_MOVL_RnRm (w
))
184 && (w
& 0x70) <= 0x20 /* Rs is R0, R1 or R2 */
185 && (w
& 0x7) >= 0x3 && (w
& 0x7) <= 0x5) /* Rd is R3, R4 or R5 */
188 if (IS_MOVB_Rn16_SP (w
)
189 && 8 <= (w
& 0xf) && (w
& 0xf) <= 10) /* Rs is R0L, R1L, or R2L */
191 if (read_memory_integer (pc
+ 2, 2) < 0) /* ... and d:16 is negative. */
194 else if (IS_MOVB_EXT (w
))
196 if (IS_MOVB_Rn24_SP (read_memory_unsigned_integer (pc
+ 2, 2)))
198 LONGEST disp
= read_memory_integer (pc
+ 4, 4);
200 /* ... and d:24 is negative. */
201 if (disp
< 0 && disp
> 0xffffff)
205 else if (IS_MOVW_Rn16_SP (w
)
206 && (w
& 0xf) <= 2) /* Rs is R0, R1, or R2 */
208 /* ... and d:16 is negative. */
209 if (read_memory_integer (pc
+ 2, 2) < 0)
212 else if (IS_MOVW_EXT (w
))
214 if (IS_MOVW_Rn24_SP (read_memory_unsigned_integer (pc
+ 2, 2)))
216 LONGEST disp
= read_memory_integer (pc
+ 4, 4);
218 /* ... and d:24 is negative. */
219 if (disp
< 0 && disp
> 0xffffff)
223 else if (IS_MOVL_PRE (w
))
225 int w2
= read_memory_integer (pc
+ 2, 2);
227 if (IS_MOVL_Rn16_SP (w2
)
228 && (w2
& 0xf) <= 2) /* Rs is ER0, ER1, or ER2 */
230 /* ... and d:16 is negative. */
231 if (read_memory_integer (pc
+ 4, 2) < 0)
234 else if (IS_MOVL_EXT (w2
))
236 int w3
= read_memory_integer (pc
+ 4, 2);
238 if (IS_MOVL_Rn24_SP (read_memory_integer (pc
+ 4, 2)))
240 LONGEST disp
= read_memory_integer (pc
+ 6, 4);
242 /* ... and d:24 is negative. */
243 if (disp
< 0 && disp
> 0xffffff)
252 /* Do a full analysis of the prologue at PC and update CACHE
253 accordingly. Bail out early if CURRENT_PC is reached. Return the
254 address where the analysis stopped.
256 We handle all cases that can be generated by gcc.
258 For allocating a stack frame:
279 For saving registers:
288 h8300_analyze_prologue (CORE_ADDR pc
, CORE_ADDR current_pc
,
289 struct h8300_frame_cache
*cache
)
292 int regno
, i
, spill_size
;
294 cache
->sp_offset
= 0;
296 if (pc
>= current_pc
)
299 op
= read_memory_unsigned_integer (pc
, 4);
301 if (IS_PUSHFP_MOVESPFP (op
))
303 cache
->saved_regs
[E_FP_REGNUM
] = 0;
307 else if (IS_PUSH_FP (op
))
309 cache
->saved_regs
[E_FP_REGNUM
] = 0;
311 if (pc
>= current_pc
)
313 op
= read_memory_unsigned_integer (pc
, 2);
314 if (IS_MOV_SP_FP (op
))
321 while (pc
< current_pc
)
323 op
= read_memory_unsigned_integer (pc
, 2);
326 cache
->sp_offset
+= 2;
329 else if (IS_SUB4_SP (op
))
331 cache
->sp_offset
+= 4;
334 else if (IS_ADD_IMM_SP (op
))
336 cache
->sp_offset
+= -read_memory_integer (pc
+ 2, 2);
339 else if (IS_SUB_IMM_SP (op
))
341 cache
->sp_offset
+= read_memory_integer (pc
+ 2, 2);
344 else if (IS_SUBL4_SP (op
))
346 cache
->sp_offset
+= 4;
349 else if (IS_MOV_IMM_Rn (op
))
351 int offset
= read_memory_integer (pc
+ 2, 2);
353 op
= read_memory_unsigned_integer (pc
+ 4, 2);
354 if (IS_ADD_RnSP (op
) && (op
& 0x00f0) == regno
)
356 cache
->sp_offset
-= offset
;
359 else if (IS_SUB_RnSP (op
) && (op
& 0x00f0) == regno
)
361 cache
->sp_offset
+= offset
;
367 else if (IS_PUSH (op
))
370 cache
->sp_offset
+= 2;
371 cache
->saved_regs
[regno
] = cache
->sp_offset
;
374 else if (op
== 0x0100)
376 op
= read_memory_unsigned_integer (pc
+ 2, 2);
380 cache
->sp_offset
+= 4;
381 cache
->saved_regs
[regno
] = cache
->sp_offset
;
387 else if ((op
& 0xffcf) == 0x0100)
390 op1
= read_memory_unsigned_integer (pc
+ 2, 2);
393 /* Since the prefix is 0x01x0, this is not a simple pushm but a
394 stm.l reglist,@-sp */
395 i
= ((op
& 0x0030) >> 4) + 1;
396 regno
= op1
& 0x000f;
397 for (; i
> 0; regno
++, --i
)
399 cache
->sp_offset
+= 4;
400 cache
->saved_regs
[regno
] = cache
->sp_offset
;
411 /* Check for spilling an argument register to the stack frame.
412 This could also be an initializing store from non-prologue code,
413 but I don't think there's any harm in skipping that. */
414 while ((spill_size
= h8300_is_argument_spill (pc
)) > 0
415 && pc
+ spill_size
<= current_pc
)
421 static struct h8300_frame_cache
*
422 h8300_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
424 struct h8300_frame_cache
*cache
;
427 CORE_ADDR current_pc
;
432 cache
= FRAME_OBSTACK_ZALLOC (struct h8300_frame_cache
);
433 h8300_init_frame_cache (cache
);
436 /* In principle, for normal frames, %fp holds the frame pointer,
437 which holds the base address for the current stack frame.
438 However, for functions that don't need it, the frame pointer is
439 optional. For these "frameless" functions the frame pointer is
440 actually the frame pointer of the calling frame. */
442 cache
->base
= frame_unwind_register_unsigned (next_frame
, E_FP_REGNUM
);
443 if (cache
->base
== 0)
446 cache
->saved_regs
[E_PC_REGNUM
] = -BINWORD
;
448 cache
->pc
= frame_func_unwind (next_frame
, NORMAL_FRAME
);
449 current_pc
= frame_pc_unwind (next_frame
);
451 h8300_analyze_prologue (cache
->pc
, current_pc
, cache
);
455 /* We didn't find a valid frame, which means that CACHE->base
456 currently holds the frame pointer for our calling frame. If
457 we're at the start of a function, or somewhere half-way its
458 prologue, the function's frame probably hasn't been fully
459 setup yet. Try to reconstruct the base address for the stack
460 frame by looking at the stack pointer. For truly "frameless"
461 functions this might work too. */
463 cache
->base
= frame_unwind_register_unsigned (next_frame
, E_SP_REGNUM
)
465 cache
->saved_sp
= cache
->base
+ BINWORD
;
466 cache
->saved_regs
[E_PC_REGNUM
] = 0;
470 cache
->saved_sp
= cache
->base
+ 2 * BINWORD
;
471 cache
->saved_regs
[E_PC_REGNUM
] = -BINWORD
;
474 /* Adjust all the saved registers such that they contain addresses
475 instead of offsets. */
476 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
477 if (cache
->saved_regs
[i
] != -1)
478 cache
->saved_regs
[i
] = cache
->base
- cache
->saved_regs
[i
];
484 h8300_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
485 struct frame_id
*this_id
)
487 struct h8300_frame_cache
*cache
=
488 h8300_frame_cache (next_frame
, this_cache
);
490 /* This marks the outermost frame. */
491 if (cache
->base
== 0)
494 *this_id
= frame_id_build (cache
->saved_sp
, cache
->pc
);
498 h8300_frame_prev_register (struct frame_info
*next_frame
, void **this_cache
,
499 int regnum
, int *optimizedp
,
500 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
501 int *realnump
, gdb_byte
*valuep
)
503 struct h8300_frame_cache
*cache
=
504 h8300_frame_cache (next_frame
, this_cache
);
506 gdb_assert (regnum
>= 0);
508 if (regnum
== E_SP_REGNUM
&& cache
->saved_sp
)
515 store_unsigned_integer (valuep
, BINWORD
, cache
->saved_sp
);
519 if (regnum
< gdbarch_num_regs (current_gdbarch
)
520 && cache
->saved_regs
[regnum
] != -1)
523 *lvalp
= lval_memory
;
524 *addrp
= cache
->saved_regs
[regnum
];
527 read_memory (*addrp
, valuep
, register_size (current_gdbarch
, regnum
));
532 *lvalp
= lval_register
;
536 frame_unwind_register (next_frame
, *realnump
, valuep
);
539 static const struct frame_unwind h8300_frame_unwind
= {
542 h8300_frame_prev_register
545 static const struct frame_unwind
*
546 h8300_frame_sniffer (struct frame_info
*next_frame
)
548 return &h8300_frame_unwind
;
552 h8300_frame_base_address (struct frame_info
*next_frame
, void **this_cache
)
554 struct h8300_frame_cache
*cache
= h8300_frame_cache (next_frame
, this_cache
);
558 static const struct frame_base h8300_frame_base
= {
560 h8300_frame_base_address
,
561 h8300_frame_base_address
,
562 h8300_frame_base_address
566 h8300_skip_prologue (CORE_ADDR pc
)
568 CORE_ADDR func_addr
= 0 , func_end
= 0;
570 if (find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
572 struct symtab_and_line sal
;
573 struct h8300_frame_cache cache
;
575 /* Found a function. */
576 sal
= find_pc_line (func_addr
, 0);
577 if (sal
.end
&& sal
.end
< func_end
)
578 /* Found a line number, use it as end of prologue. */
581 /* No useable line symbol. Use prologue parsing method. */
582 h8300_init_frame_cache (&cache
);
583 return h8300_analyze_prologue (func_addr
, func_end
, &cache
);
586 /* No function symbol -- just return the PC. */
587 return (CORE_ADDR
) pc
;
590 /* Function: push_dummy_call
591 Setup the function arguments for calling a function in the inferior.
592 In this discussion, a `word' is 16 bits on the H8/300s, and 32 bits
595 There are actually two ABI's here: -mquickcall (the default) and
596 -mno-quickcall. With -mno-quickcall, all arguments are passed on
597 the stack after the return address, word-aligned. With
598 -mquickcall, GCC tries to use r0 -- r2 to pass registers. Since
599 GCC doesn't indicate in the object file which ABI was used to
600 compile it, GDB only supports the default --- -mquickcall.
602 Here are the rules for -mquickcall, in detail:
604 Each argument, whether scalar or aggregate, is padded to occupy a
605 whole number of words. Arguments smaller than a word are padded at
606 the most significant end; those larger than a word are padded at
607 the least significant end.
609 The initial arguments are passed in r0 -- r2. Earlier arguments go in
610 lower-numbered registers. Multi-word arguments are passed in
611 consecutive registers, with the most significant end in the
612 lower-numbered register.
614 If an argument doesn't fit entirely in the remaining registers, it
615 is passed entirely on the stack. Stack arguments begin just after
616 the return address. Once an argument has overflowed onto the stack
617 this way, all subsequent arguments are passed on the stack.
619 The above rule has odd consequences. For example, on the h8/300s,
620 if a function takes two longs and an int as arguments:
621 - the first long will be passed in r0/r1,
622 - the second long will be passed entirely on the stack, since it
624 - and the int will be passed on the stack, even though it could fit
627 A weird exception: if an argument is larger than a word, but not a
628 whole number of words in length (before padding), it is passed on
629 the stack following the rules for stack arguments above, even if
630 there are sufficient registers available to hold it. Stranger
631 still, the argument registers are still `used up' --- even though
632 there's nothing in them.
634 So, for example, on the h8/300s, if a function expects a three-byte
635 structure and an int, the structure will go on the stack, and the
636 int will go in r2, not r0.
638 If the function returns an aggregate type (struct, union, or class)
639 by value, the caller must allocate space to hold the return value,
640 and pass the callee a pointer to this space as an invisible first
643 For varargs functions, the last fixed argument and all the variable
644 arguments are always passed on the stack. This means that calls to
645 varargs functions don't work properly unless there is a prototype
648 Basically, this ABI is not good, for the following reasons:
649 - You can't call vararg functions properly unless a prototype is in scope.
650 - Structure passing is inconsistent, to no purpose I can see.
651 - It often wastes argument registers, of which there are only three
655 h8300_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
656 struct regcache
*regcache
, CORE_ADDR bp_addr
,
657 int nargs
, struct value
**args
, CORE_ADDR sp
,
658 int struct_return
, CORE_ADDR struct_addr
)
660 int stack_alloc
= 0, stack_offset
= 0;
661 int wordsize
= BINWORD
;
662 int reg
= E_ARG0_REGNUM
;
665 /* First, make sure the stack is properly aligned. */
666 sp
= align_down (sp
, wordsize
);
668 /* Now make sure there's space on the stack for the arguments. We
669 may over-allocate a little here, but that won't hurt anything. */
670 for (argument
= 0; argument
< nargs
; argument
++)
671 stack_alloc
+= align_up (TYPE_LENGTH (value_type (args
[argument
])),
675 /* Now load as many arguments as possible into registers, and push
676 the rest onto the stack.
677 If we're returning a structure by value, then we must pass a
678 pointer to the buffer for the return value as an invisible first
681 regcache_cooked_write_unsigned (regcache
, reg
++, struct_addr
);
683 for (argument
= 0; argument
< nargs
; argument
++)
685 struct type
*type
= value_type (args
[argument
]);
686 int len
= TYPE_LENGTH (type
);
687 char *contents
= (char *) value_contents (args
[argument
]);
689 /* Pad the argument appropriately. */
690 int padded_len
= align_up (len
, wordsize
);
691 gdb_byte
*padded
= alloca (padded_len
);
693 memset (padded
, 0, padded_len
);
694 memcpy (len
< wordsize
? padded
+ padded_len
- len
: padded
,
697 /* Could the argument fit in the remaining registers? */
698 if (padded_len
<= (E_ARGLAST_REGNUM
- reg
+ 1) * wordsize
)
700 /* Are we going to pass it on the stack anyway, for no good
702 if (len
> wordsize
&& len
% wordsize
)
704 /* I feel so unclean. */
705 write_memory (sp
+ stack_offset
, padded
, padded_len
);
706 stack_offset
+= padded_len
;
708 /* That's right --- even though we passed the argument
709 on the stack, we consume the registers anyway! Love
711 reg
+= padded_len
/ wordsize
;
715 /* Heavens to Betsy --- it's really going in registers!
716 It would be nice if we could use write_register_bytes
717 here, but on the h8/300s, there are gaps between
718 the registers in the register file. */
721 for (offset
= 0; offset
< padded_len
; offset
+= wordsize
)
723 ULONGEST word
= extract_unsigned_integer (padded
+ offset
,
725 regcache_cooked_write_unsigned (regcache
, reg
++, word
);
731 /* It doesn't fit in registers! Onto the stack it goes. */
732 write_memory (sp
+ stack_offset
, padded
, padded_len
);
733 stack_offset
+= padded_len
;
735 /* Once one argument has spilled onto the stack, all
736 subsequent arguments go on the stack. */
737 reg
= E_ARGLAST_REGNUM
+ 1;
741 /* Store return address. */
743 write_memory_unsigned_integer (sp
, wordsize
, bp_addr
);
745 /* Update stack pointer. */
746 regcache_cooked_write_unsigned (regcache
, E_SP_REGNUM
, sp
);
748 /* Return the new stack pointer minus the return address slot since
749 that's what DWARF2/GCC uses as the frame's CFA. */
750 return sp
+ wordsize
;
753 /* Function: extract_return_value
754 Figure out where in REGBUF the called function has left its return value.
755 Copy that into VALBUF. Be sure to account for CPU type. */
758 h8300_extract_return_value (struct type
*type
, struct regcache
*regcache
,
761 int len
= TYPE_LENGTH (type
);
768 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &c
);
769 store_unsigned_integer (valbuf
, len
, c
);
771 case 4: /* Needs two registers on plain H8/300 */
772 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &c
);
773 store_unsigned_integer (valbuf
, 2, c
);
774 regcache_cooked_read_unsigned (regcache
, E_RET1_REGNUM
, &c
);
775 store_unsigned_integer ((void *) ((char *) valbuf
+ 2), 2, c
);
777 case 8: /* long long is now 8 bytes. */
778 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
780 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &addr
);
781 c
= read_memory_unsigned_integer ((CORE_ADDR
) addr
, len
);
782 store_unsigned_integer (valbuf
, len
, c
);
786 error ("I don't know how this 8 byte value is returned.");
793 h8300h_extract_return_value (struct type
*type
, struct regcache
*regcache
,
796 int len
= TYPE_LENGTH (type
);
804 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &c
);
805 store_unsigned_integer (valbuf
, len
, c
);
807 case 8: /* long long is now 8 bytes. */
808 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
810 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &c
);
811 store_unsigned_integer (valbuf
, 4, c
);
812 regcache_cooked_read_unsigned (regcache
, E_RET1_REGNUM
, &c
);
813 store_unsigned_integer ((void *) ((char *) valbuf
+ 4), 4, c
);
817 error ("I don't know how this 8 byte value is returned.");
824 h8300_use_struct_convention (struct type
*value_type
)
826 /* Types of 1, 2 or 4 bytes are returned in R0/R1, everything else on the
829 if (TYPE_CODE (value_type
) == TYPE_CODE_STRUCT
830 || TYPE_CODE (value_type
) == TYPE_CODE_UNION
)
832 return !(TYPE_LENGTH (value_type
) == 1
833 || TYPE_LENGTH (value_type
) == 2
834 || TYPE_LENGTH (value_type
) == 4);
838 h8300h_use_struct_convention (struct type
*value_type
)
840 /* Types of 1, 2 or 4 bytes are returned in R0, INT types of 8 bytes are
841 returned in R0/R1, everything else on the stack. */
842 if (TYPE_CODE (value_type
) == TYPE_CODE_STRUCT
843 || TYPE_CODE (value_type
) == TYPE_CODE_UNION
)
845 return !(TYPE_LENGTH (value_type
) == 1
846 || TYPE_LENGTH (value_type
) == 2
847 || TYPE_LENGTH (value_type
) == 4
848 || (TYPE_LENGTH (value_type
) == 8
849 && TYPE_CODE (value_type
) == TYPE_CODE_INT
));
852 /* Function: store_return_value
853 Place the appropriate value in the appropriate registers.
854 Primarily used by the RETURN command. */
857 h8300_store_return_value (struct type
*type
, struct regcache
*regcache
,
860 int len
= TYPE_LENGTH (type
);
866 case 2: /* short... */
867 val
= extract_unsigned_integer (valbuf
, len
);
868 regcache_cooked_write_unsigned (regcache
, E_RET0_REGNUM
, val
);
870 case 4: /* long, float */
871 val
= extract_unsigned_integer (valbuf
, len
);
872 regcache_cooked_write_unsigned (regcache
, E_RET0_REGNUM
,
873 (val
>> 16) & 0xffff);
874 regcache_cooked_write_unsigned (regcache
, E_RET1_REGNUM
, val
& 0xffff);
876 case 8: /* long long, double and long double are all defined
877 as 4 byte types so far so this shouldn't happen. */
878 error ("I don't know how to return an 8 byte value.");
884 h8300h_store_return_value (struct type
*type
, struct regcache
*regcache
,
887 int len
= TYPE_LENGTH (type
);
894 case 4: /* long, float */
895 val
= extract_unsigned_integer (valbuf
, len
);
896 regcache_cooked_write_unsigned (regcache
, E_RET0_REGNUM
, val
);
899 val
= extract_unsigned_integer (valbuf
, len
);
900 regcache_cooked_write_unsigned (regcache
, E_RET0_REGNUM
,
901 (val
>> 32) & 0xffffffff);
902 regcache_cooked_write_unsigned (regcache
, E_RET1_REGNUM
,
908 static enum return_value_convention
909 h8300_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
910 struct regcache
*regcache
,
911 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
913 if (h8300_use_struct_convention (type
))
914 return RETURN_VALUE_STRUCT_CONVENTION
;
916 h8300_store_return_value (type
, regcache
, writebuf
);
918 h8300_extract_return_value (type
, regcache
, readbuf
);
919 return RETURN_VALUE_REGISTER_CONVENTION
;
922 static enum return_value_convention
923 h8300h_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
924 struct regcache
*regcache
,
925 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
927 if (h8300h_use_struct_convention (type
))
933 regcache_raw_read_unsigned (regcache
, E_R0_REGNUM
, &addr
);
934 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
937 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
940 h8300h_store_return_value (type
, regcache
, writebuf
);
942 h8300h_extract_return_value (type
, regcache
, readbuf
);
943 return RETURN_VALUE_REGISTER_CONVENTION
;
946 static struct cmd_list_element
*setmachinelist
;
949 h8300_register_name (int regno
)
951 /* The register names change depending on which h8300 processor
953 static char *register_names
[] = {
954 "r0", "r1", "r2", "r3", "r4", "r5", "r6",
955 "sp", "", "pc", "cycles", "tick", "inst",
956 "ccr", /* pseudo register */
959 || regno
>= (sizeof (register_names
) / sizeof (*register_names
)))
960 internal_error (__FILE__
, __LINE__
,
961 "h8300_register_name: illegal register number %d", regno
);
963 return register_names
[regno
];
967 h8300s_register_name (int regno
)
969 static char *register_names
[] = {
970 "er0", "er1", "er2", "er3", "er4", "er5", "er6",
971 "sp", "", "pc", "cycles", "", "tick", "inst",
973 "ccr", "exr" /* pseudo registers */
976 || regno
>= (sizeof (register_names
) / sizeof (*register_names
)))
977 internal_error (__FILE__
, __LINE__
,
978 "h8300s_register_name: illegal register number %d",
981 return register_names
[regno
];
985 h8300sx_register_name (int regno
)
987 static char *register_names
[] = {
988 "er0", "er1", "er2", "er3", "er4", "er5", "er6",
989 "sp", "", "pc", "cycles", "", "tick", "inst",
990 "mach", "macl", "sbr", "vbr",
991 "ccr", "exr" /* pseudo registers */
994 || regno
>= (sizeof (register_names
) / sizeof (*register_names
)))
995 internal_error (__FILE__
, __LINE__
,
996 "h8300sx_register_name: illegal register number %d",
999 return register_names
[regno
];
1003 h8300_print_register (struct gdbarch
*gdbarch
, struct ui_file
*file
,
1004 struct frame_info
*frame
, int regno
)
1007 const char *name
= gdbarch_register_name (gdbarch
, regno
);
1009 if (!name
|| !*name
)
1012 rval
= get_frame_register_signed (frame
, regno
);
1014 fprintf_filtered (file
, "%-14s ", name
);
1015 if ((regno
== E_PSEUDO_CCR_REGNUM
) || \
1016 (regno
== E_PSEUDO_EXR_REGNUM
&& is_h8300smode (current_gdbarch
)))
1018 fprintf_filtered (file
, "0x%02x ", (unsigned char) rval
);
1019 print_longest (file
, 'u', 1, rval
);
1023 fprintf_filtered (file
, "0x%s ", phex ((ULONGEST
) rval
, BINWORD
));
1024 print_longest (file
, 'd', 1, rval
);
1026 if (regno
== E_PSEUDO_CCR_REGNUM
)
1030 unsigned char l
= rval
& 0xff;
1031 fprintf_filtered (file
, "\t");
1032 fprintf_filtered (file
, "I-%d ", (l
& 0x80) != 0);
1033 fprintf_filtered (file
, "UI-%d ", (l
& 0x40) != 0);
1034 fprintf_filtered (file
, "H-%d ", (l
& 0x20) != 0);
1035 fprintf_filtered (file
, "U-%d ", (l
& 0x10) != 0);
1040 fprintf_filtered (file
, "N-%d ", N
);
1041 fprintf_filtered (file
, "Z-%d ", Z
);
1042 fprintf_filtered (file
, "V-%d ", V
);
1043 fprintf_filtered (file
, "C-%d ", C
);
1045 fprintf_filtered (file
, "u> ");
1047 fprintf_filtered (file
, "u<= ");
1049 fprintf_filtered (file
, "u>= ");
1051 fprintf_filtered (file
, "u< ");
1053 fprintf_filtered (file
, "!= ");
1055 fprintf_filtered (file
, "== ");
1057 fprintf_filtered (file
, ">= ");
1059 fprintf_filtered (file
, "< ");
1060 if ((Z
| (N
^ V
)) == 0)
1061 fprintf_filtered (file
, "> ");
1062 if ((Z
| (N
^ V
)) == 1)
1063 fprintf_filtered (file
, "<= ");
1065 else if (regno
== E_PSEUDO_EXR_REGNUM
&& is_h8300smode (current_gdbarch
))
1068 unsigned char l
= rval
& 0xff;
1069 fprintf_filtered (file
, "\t");
1070 fprintf_filtered (file
, "T-%d - - - ", (l
& 0x80) != 0);
1071 fprintf_filtered (file
, "I2-%d ", (l
& 4) != 0);
1072 fprintf_filtered (file
, "I1-%d ", (l
& 2) != 0);
1073 fprintf_filtered (file
, "I0-%d", (l
& 1) != 0);
1075 fprintf_filtered (file
, "\n");
1079 h8300_print_registers_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
1080 struct frame_info
*frame
, int regno
, int cpregs
)
1084 for (regno
= E_R0_REGNUM
; regno
<= E_SP_REGNUM
; ++regno
)
1085 h8300_print_register (gdbarch
, file
, frame
, regno
);
1086 h8300_print_register (gdbarch
, file
, frame
, E_PSEUDO_CCR_REGNUM
);
1087 h8300_print_register (gdbarch
, file
, frame
, E_PC_REGNUM
);
1088 if (is_h8300smode (current_gdbarch
))
1090 h8300_print_register (gdbarch
, file
, frame
, E_PSEUDO_EXR_REGNUM
);
1091 if (is_h8300sxmode (current_gdbarch
))
1093 h8300_print_register (gdbarch
, file
, frame
, E_SBR_REGNUM
);
1094 h8300_print_register (gdbarch
, file
, frame
, E_VBR_REGNUM
);
1096 h8300_print_register (gdbarch
, file
, frame
, E_MACH_REGNUM
);
1097 h8300_print_register (gdbarch
, file
, frame
, E_MACL_REGNUM
);
1098 h8300_print_register (gdbarch
, file
, frame
, E_CYCLES_REGNUM
);
1099 h8300_print_register (gdbarch
, file
, frame
, E_TICKS_REGNUM
);
1100 h8300_print_register (gdbarch
, file
, frame
, E_INSTS_REGNUM
);
1104 h8300_print_register (gdbarch
, file
, frame
, E_CYCLES_REGNUM
);
1105 h8300_print_register (gdbarch
, file
, frame
, E_TICK_REGNUM
);
1106 h8300_print_register (gdbarch
, file
, frame
, E_INST_REGNUM
);
1111 if (regno
== E_CCR_REGNUM
)
1112 h8300_print_register (gdbarch
, file
, frame
, E_PSEUDO_CCR_REGNUM
);
1113 else if (regno
== E_PSEUDO_EXR_REGNUM
1114 && is_h8300smode (current_gdbarch
))
1115 h8300_print_register (gdbarch
, file
, frame
, E_PSEUDO_EXR_REGNUM
);
1117 h8300_print_register (gdbarch
, file
, frame
, regno
);
1121 static struct type
*
1122 h8300_register_type (struct gdbarch
*gdbarch
, int regno
)
1124 if (regno
< 0 || regno
>= gdbarch_num_regs (current_gdbarch
)
1125 + gdbarch_num_pseudo_regs (current_gdbarch
))
1126 internal_error (__FILE__
, __LINE__
,
1127 "h8300_register_type: illegal register number %d", regno
);
1133 return builtin_type_void_func_ptr
;
1136 return builtin_type_void_data_ptr
;
1138 if (regno
== E_PSEUDO_CCR_REGNUM
)
1139 return builtin_type_uint8
;
1140 else if (regno
== E_PSEUDO_EXR_REGNUM
)
1141 return builtin_type_uint8
;
1142 else if (is_h8300hmode (current_gdbarch
))
1143 return builtin_type_int32
;
1145 return builtin_type_int16
;
1151 h8300_pseudo_register_read (struct gdbarch
*gdbarch
,
1152 struct regcache
*regcache
, int regno
,
1155 if (regno
== E_PSEUDO_CCR_REGNUM
)
1156 regcache_raw_read (regcache
, E_CCR_REGNUM
, buf
);
1157 else if (regno
== E_PSEUDO_EXR_REGNUM
)
1158 regcache_raw_read (regcache
, E_EXR_REGNUM
, buf
);
1160 regcache_raw_read (regcache
, regno
, buf
);
1164 h8300_pseudo_register_write (struct gdbarch
*gdbarch
,
1165 struct regcache
*regcache
, int regno
,
1166 const gdb_byte
*buf
)
1168 if (regno
== E_PSEUDO_CCR_REGNUM
)
1169 regcache_raw_write (regcache
, E_CCR_REGNUM
, buf
);
1170 else if (regno
== E_PSEUDO_EXR_REGNUM
)
1171 regcache_raw_write (regcache
, E_EXR_REGNUM
, buf
);
1173 regcache_raw_write (regcache
, regno
, buf
);
1177 h8300_dbg_reg_to_regnum (int regno
)
1179 if (regno
== E_CCR_REGNUM
)
1180 return E_PSEUDO_CCR_REGNUM
;
1185 h8300s_dbg_reg_to_regnum (int regno
)
1187 if (regno
== E_CCR_REGNUM
)
1188 return E_PSEUDO_CCR_REGNUM
;
1189 if (regno
== E_EXR_REGNUM
)
1190 return E_PSEUDO_EXR_REGNUM
;
1194 const static unsigned char *
1195 h8300_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
1197 /*static unsigned char breakpoint[] = { 0x7A, 0xFF }; *//* ??? */
1198 static unsigned char breakpoint
[] = { 0x01, 0x80 }; /* Sleep */
1200 *lenptr
= sizeof (breakpoint
);
1205 h8300_print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
1206 struct frame_info
*frame
, const char *args
)
1208 fprintf_filtered (file
, "\
1209 No floating-point info available for this processor.\n");
1212 static struct gdbarch
*
1213 h8300_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1215 struct gdbarch_tdep
*tdep
= NULL
;
1216 struct gdbarch
*gdbarch
;
1218 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1220 return arches
->gdbarch
;
1223 tdep
= (struct gdbarch_tdep
*) xmalloc (sizeof (struct gdbarch_tdep
));
1226 if (info
.bfd_arch_info
->arch
!= bfd_arch_h8300
)
1229 gdbarch
= gdbarch_alloc (&info
, 0);
1231 switch (info
.bfd_arch_info
->mach
)
1233 case bfd_mach_h8300
:
1234 set_gdbarch_num_regs (gdbarch
, 13);
1235 set_gdbarch_num_pseudo_regs (gdbarch
, 1);
1236 set_gdbarch_ecoff_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1237 set_gdbarch_dwarf_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1238 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1239 set_gdbarch_stab_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1240 set_gdbarch_register_name (gdbarch
, h8300_register_name
);
1241 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1242 set_gdbarch_addr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1243 set_gdbarch_return_value (gdbarch
, h8300_return_value
);
1244 set_gdbarch_print_insn (gdbarch
, print_insn_h8300
);
1246 case bfd_mach_h8300h
:
1247 case bfd_mach_h8300hn
:
1248 set_gdbarch_num_regs (gdbarch
, 13);
1249 set_gdbarch_num_pseudo_regs (gdbarch
, 1);
1250 set_gdbarch_ecoff_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1251 set_gdbarch_dwarf_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1252 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1253 set_gdbarch_stab_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1254 set_gdbarch_register_name (gdbarch
, h8300_register_name
);
1255 if (info
.bfd_arch_info
->mach
!= bfd_mach_h8300hn
)
1257 set_gdbarch_ptr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1258 set_gdbarch_addr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1262 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1263 set_gdbarch_addr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1265 set_gdbarch_return_value (gdbarch
, h8300h_return_value
);
1266 set_gdbarch_print_insn (gdbarch
, print_insn_h8300h
);
1268 case bfd_mach_h8300s
:
1269 case bfd_mach_h8300sn
:
1270 set_gdbarch_num_regs (gdbarch
, 16);
1271 set_gdbarch_num_pseudo_regs (gdbarch
, 2);
1272 set_gdbarch_ecoff_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1273 set_gdbarch_dwarf_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1274 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1275 set_gdbarch_stab_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1276 set_gdbarch_register_name (gdbarch
, h8300s_register_name
);
1277 if (info
.bfd_arch_info
->mach
!= bfd_mach_h8300sn
)
1279 set_gdbarch_ptr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1280 set_gdbarch_addr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1284 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1285 set_gdbarch_addr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1287 set_gdbarch_return_value (gdbarch
, h8300h_return_value
);
1288 set_gdbarch_print_insn (gdbarch
, print_insn_h8300s
);
1290 case bfd_mach_h8300sx
:
1291 case bfd_mach_h8300sxn
:
1292 set_gdbarch_num_regs (gdbarch
, 18);
1293 set_gdbarch_num_pseudo_regs (gdbarch
, 2);
1294 set_gdbarch_ecoff_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1295 set_gdbarch_dwarf_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1296 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1297 set_gdbarch_stab_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1298 set_gdbarch_register_name (gdbarch
, h8300sx_register_name
);
1299 if (info
.bfd_arch_info
->mach
!= bfd_mach_h8300sxn
)
1301 set_gdbarch_ptr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1302 set_gdbarch_addr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1306 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1307 set_gdbarch_addr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1309 set_gdbarch_return_value (gdbarch
, h8300h_return_value
);
1310 set_gdbarch_print_insn (gdbarch
, print_insn_h8300s
);
1314 set_gdbarch_pseudo_register_read (gdbarch
, h8300_pseudo_register_read
);
1315 set_gdbarch_pseudo_register_write (gdbarch
, h8300_pseudo_register_write
);
1318 * Basic register fields and methods.
1321 set_gdbarch_sp_regnum (gdbarch
, E_SP_REGNUM
);
1322 set_gdbarch_pc_regnum (gdbarch
, E_PC_REGNUM
);
1323 set_gdbarch_register_type (gdbarch
, h8300_register_type
);
1324 set_gdbarch_print_registers_info (gdbarch
, h8300_print_registers_info
);
1325 set_gdbarch_print_float_info (gdbarch
, h8300_print_float_info
);
1330 set_gdbarch_skip_prologue (gdbarch
, h8300_skip_prologue
);
1332 /* Frame unwinder. */
1333 set_gdbarch_unwind_pc (gdbarch
, h8300_unwind_pc
);
1334 set_gdbarch_unwind_sp (gdbarch
, h8300_unwind_sp
);
1335 set_gdbarch_unwind_dummy_id (gdbarch
, h8300_unwind_dummy_id
);
1336 frame_base_set_default (gdbarch
, &h8300_frame_base
);
1341 /* Stack grows up. */
1342 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1344 set_gdbarch_breakpoint_from_pc (gdbarch
, h8300_breakpoint_from_pc
);
1345 set_gdbarch_push_dummy_call (gdbarch
, h8300_push_dummy_call
);
1347 set_gdbarch_char_signed (gdbarch
, 0);
1348 set_gdbarch_int_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1349 set_gdbarch_long_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1350 set_gdbarch_long_long_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
1351 set_gdbarch_double_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1352 set_gdbarch_long_double_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1354 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
1356 /* Hook in the DWARF CFI frame unwinder. */
1357 frame_unwind_append_sniffer (gdbarch
, dwarf2_frame_sniffer
);
1358 frame_unwind_append_sniffer (gdbarch
, h8300_frame_sniffer
);
1364 extern initialize_file_ftype _initialize_h8300_tdep
; /* -Wmissing-prototypes */
1367 _initialize_h8300_tdep (void)
1369 register_gdbarch_init (bfd_arch_h8300
, h8300_gdbarch_init
);
1373 is_h8300hmode (struct gdbarch
*gdbarch
)
1375 return gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sx
1376 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sxn
1377 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300s
1378 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sn
1379 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300h
1380 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300hn
;
1384 is_h8300smode (struct gdbarch
*gdbarch
)
1386 return gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sx
1387 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sxn
1388 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300s
1389 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sn
;
1393 is_h8300sxmode (struct gdbarch
*gdbarch
)
1395 return gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sx
1396 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sxn
;
1400 is_h8300_normal_mode (struct gdbarch
*gdbarch
)
1402 return gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sxn
1403 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sn
1404 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300hn
;