1 /* Target-machine dependent code for Renesas H8/300, for GDB.
3 Copyright (C) 1988-2024 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 Contributed by Steve Chamberlain
26 #include "arch-utils.h"
31 #include "dwarf2/frame.h"
32 #include "frame-base.h"
33 #include "frame-unwind.h"
37 E_R0_REGNUM
, E_ER0_REGNUM
= E_R0_REGNUM
, E_ARG0_REGNUM
= E_R0_REGNUM
,
38 E_RET0_REGNUM
= E_R0_REGNUM
,
39 E_R1_REGNUM
, E_ER1_REGNUM
= E_R1_REGNUM
, E_RET1_REGNUM
= E_R1_REGNUM
,
40 E_R2_REGNUM
, E_ER2_REGNUM
= E_R2_REGNUM
, E_ARGLAST_REGNUM
= E_R2_REGNUM
,
41 E_R3_REGNUM
, E_ER3_REGNUM
= E_R3_REGNUM
,
42 E_R4_REGNUM
, E_ER4_REGNUM
= E_R4_REGNUM
,
43 E_R5_REGNUM
, E_ER5_REGNUM
= E_R5_REGNUM
,
44 E_R6_REGNUM
, E_ER6_REGNUM
= E_R6_REGNUM
, E_FP_REGNUM
= E_R6_REGNUM
,
49 E_TICK_REGNUM
, E_EXR_REGNUM
= E_TICK_REGNUM
,
50 E_INST_REGNUM
, E_TICKS_REGNUM
= E_INST_REGNUM
,
58 #define H8300_MAX_NUM_REGS 18
60 #define E_PSEUDO_CCR_REGNUM(gdbarch) (gdbarch_num_regs (gdbarch))
61 #define E_PSEUDO_EXR_REGNUM(gdbarch) (gdbarch_num_regs (gdbarch)+1)
63 struct h8300_frame_cache
70 /* Flag showing that a frame has been created in the prologue code. */
73 /* Saved registers. */
74 CORE_ADDR saved_regs
[H8300_MAX_NUM_REGS
];
82 h8300_max_reg_size
= 4,
85 static int is_h8300hmode (struct gdbarch
*gdbarch
);
86 static int is_h8300smode (struct gdbarch
*gdbarch
);
87 static int is_h8300sxmode (struct gdbarch
*gdbarch
);
88 static int is_h8300_normal_mode (struct gdbarch
*gdbarch
);
90 #define BINWORD(gdbarch) ((is_h8300hmode (gdbarch) \
91 && !is_h8300_normal_mode (gdbarch)) \
92 ? h8300h_reg_size : h8300_reg_size)
96 /* Allocate and initialize a frame cache. */
99 h8300_init_frame_cache (struct gdbarch
*gdbarch
,
100 struct h8300_frame_cache
*cache
)
106 cache
->sp_offset
= 0;
109 /* Frameless until proven otherwise. */
112 /* Saved registers. We initialize these to -1 since zero is a valid
113 offset (that's where %fp is supposed to be stored). */
114 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
115 cache
->saved_regs
[i
] = -1;
118 #define IS_MOVB_RnRm(x) (((x) & 0xff88) == 0x0c88)
119 #define IS_MOVW_RnRm(x) (((x) & 0xff88) == 0x0d00)
120 #define IS_MOVL_RnRm(x) (((x) & 0xff88) == 0x0f80)
121 #define IS_MOVB_Rn16_SP(x) (((x) & 0xfff0) == 0x6ee0)
122 #define IS_MOVB_EXT(x) ((x) == 0x7860)
123 #define IS_MOVB_Rn24_SP(x) (((x) & 0xfff0) == 0x6aa0)
124 #define IS_MOVW_Rn16_SP(x) (((x) & 0xfff0) == 0x6fe0)
125 #define IS_MOVW_EXT(x) ((x) == 0x78e0)
126 #define IS_MOVW_Rn24_SP(x) (((x) & 0xfff0) == 0x6ba0)
127 /* Same instructions as mov.w, just prefixed with 0x0100. */
128 #define IS_MOVL_PRE(x) ((x) == 0x0100)
129 #define IS_MOVL_Rn16_SP(x) (((x) & 0xfff0) == 0x6fe0)
130 #define IS_MOVL_EXT(x) ((x) == 0x78e0)
131 #define IS_MOVL_Rn24_SP(x) (((x) & 0xfff0) == 0x6ba0)
133 #define IS_PUSHFP_MOVESPFP(x) ((x) == 0x6df60d76)
134 #define IS_PUSH_FP(x) ((x) == 0x01006df6)
135 #define IS_MOV_SP_FP(x) ((x) == 0x0ff6)
136 #define IS_SUB2_SP(x) ((x) == 0x1b87)
137 #define IS_SUB4_SP(x) ((x) == 0x1b97)
138 #define IS_ADD_IMM_SP(x) ((x) == 0x7a1f)
139 #define IS_SUB_IMM_SP(x) ((x) == 0x7a3f)
140 #define IS_SUBL4_SP(x) ((x) == 0x1acf)
141 #define IS_MOV_IMM_Rn(x) (((x) & 0xfff0) == 0x7905)
142 #define IS_SUB_RnSP(x) (((x) & 0xff0f) == 0x1907)
143 #define IS_ADD_RnSP(x) (((x) & 0xff0f) == 0x0907)
144 #define IS_PUSH(x) (((x) & 0xfff0) == 0x6df0)
146 /* If the instruction at PC is an argument register spill, return its
147 length. Otherwise, return zero.
149 An argument register spill is an instruction that moves an argument
150 from the register in which it was passed to the stack slot in which
151 it really lives. It is a byte, word, or longword move from an
152 argument register to a negative offset from the frame pointer.
154 CV, 2003-06-16: Or, in optimized code or when the `register' qualifier
155 is used, it could be a byte, word or long move to registers r3-r5. */
158 h8300_is_argument_spill (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
160 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
161 int w
= read_memory_unsigned_integer (pc
, 2, byte_order
);
163 if ((IS_MOVB_RnRm (w
) || IS_MOVW_RnRm (w
) || IS_MOVL_RnRm (w
))
164 && (w
& 0x70) <= 0x20 /* Rs is R0, R1 or R2 */
165 && (w
& 0x7) >= 0x3 && (w
& 0x7) <= 0x5) /* Rd is R3, R4 or R5 */
168 if (IS_MOVB_Rn16_SP (w
)
169 && 8 <= (w
& 0xf) && (w
& 0xf) <= 10) /* Rs is R0L, R1L, or R2L */
171 /* ... and d:16 is negative. */
172 if (read_memory_integer (pc
+ 2, 2, byte_order
) < 0)
175 else if (IS_MOVB_EXT (w
))
177 if (IS_MOVB_Rn24_SP (read_memory_unsigned_integer (pc
+ 2,
180 ULONGEST disp
= read_memory_unsigned_integer (pc
+ 4, 4, byte_order
);
182 /* ... and d:24 is negative. */
183 if ((disp
& 0x00800000) != 0)
187 else if (IS_MOVW_Rn16_SP (w
)
188 && (w
& 0xf) <= 2) /* Rs is R0, R1, or R2 */
190 /* ... and d:16 is negative. */
191 if (read_memory_integer (pc
+ 2, 2, byte_order
) < 0)
194 else if (IS_MOVW_EXT (w
))
196 if (IS_MOVW_Rn24_SP (read_memory_unsigned_integer (pc
+ 2,
199 ULONGEST disp
= read_memory_unsigned_integer (pc
+ 4, 4, byte_order
);
201 /* ... and d:24 is negative. */
202 if ((disp
& 0x00800000) != 0)
206 else if (IS_MOVL_PRE (w
))
208 int w2
= read_memory_integer (pc
+ 2, 2, byte_order
);
210 if (IS_MOVL_Rn16_SP (w2
)
211 && (w2
& 0xf) <= 2) /* Rs is ER0, ER1, or ER2 */
213 /* ... and d:16 is negative. */
214 if (read_memory_integer (pc
+ 4, 2, byte_order
) < 0)
217 else if (IS_MOVL_EXT (w2
))
219 if (IS_MOVL_Rn24_SP (read_memory_integer (pc
+ 4, 2, byte_order
)))
221 ULONGEST disp
= read_memory_unsigned_integer (pc
+ 6, 4,
224 /* ... and d:24 is negative. */
225 if ((disp
& 0x00800000) != 0)
234 /* Do a full analysis of the prologue at PC and update CACHE
235 accordingly. Bail out early if CURRENT_PC is reached. Return the
236 address where the analysis stopped.
238 We handle all cases that can be generated by gcc.
240 For allocating a stack frame:
261 For saving registers:
270 h8300_analyze_prologue (struct gdbarch
*gdbarch
,
271 CORE_ADDR pc
, CORE_ADDR current_pc
,
272 struct h8300_frame_cache
*cache
)
274 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
276 int regno
, i
, spill_size
;
278 cache
->sp_offset
= 0;
280 if (pc
>= current_pc
)
283 op
= read_memory_unsigned_integer (pc
, 4, byte_order
);
285 if (IS_PUSHFP_MOVESPFP (op
))
287 cache
->saved_regs
[E_FP_REGNUM
] = 0;
291 else if (IS_PUSH_FP (op
))
293 cache
->saved_regs
[E_FP_REGNUM
] = 0;
295 if (pc
>= current_pc
)
297 op
= read_memory_unsigned_integer (pc
, 2, byte_order
);
298 if (IS_MOV_SP_FP (op
))
305 while (pc
< current_pc
)
307 op
= read_memory_unsigned_integer (pc
, 2, byte_order
);
310 cache
->sp_offset
+= 2;
313 else if (IS_SUB4_SP (op
))
315 cache
->sp_offset
+= 4;
318 else if (IS_ADD_IMM_SP (op
))
320 cache
->sp_offset
+= -read_memory_integer (pc
+ 2, 2, byte_order
);
323 else if (IS_SUB_IMM_SP (op
))
325 cache
->sp_offset
+= read_memory_integer (pc
+ 2, 2, byte_order
);
328 else if (IS_SUBL4_SP (op
))
330 cache
->sp_offset
+= 4;
333 else if (IS_MOV_IMM_Rn (op
))
335 int offset
= read_memory_integer (pc
+ 2, 2, byte_order
);
337 op
= read_memory_unsigned_integer (pc
+ 4, 2, byte_order
);
338 if (IS_ADD_RnSP (op
) && (op
& 0x00f0) == regno
)
340 cache
->sp_offset
-= offset
;
343 else if (IS_SUB_RnSP (op
) && (op
& 0x00f0) == regno
)
345 cache
->sp_offset
+= offset
;
351 else if (IS_PUSH (op
))
354 cache
->sp_offset
+= 2;
355 cache
->saved_regs
[regno
] = cache
->sp_offset
;
358 else if (op
== 0x0100)
360 op
= read_memory_unsigned_integer (pc
+ 2, 2, byte_order
);
364 cache
->sp_offset
+= 4;
365 cache
->saved_regs
[regno
] = cache
->sp_offset
;
371 else if ((op
& 0xffcf) == 0x0100)
374 op1
= read_memory_unsigned_integer (pc
+ 2, 2, byte_order
);
377 /* Since the prefix is 0x01x0, this is not a simple pushm but a
378 stm.l reglist,@-sp */
379 i
= ((op
& 0x0030) >> 4) + 1;
380 regno
= op1
& 0x000f;
381 for (; i
> 0; regno
++, --i
)
383 cache
->sp_offset
+= 4;
384 cache
->saved_regs
[regno
] = cache
->sp_offset
;
395 /* Check for spilling an argument register to the stack frame.
396 This could also be an initializing store from non-prologue code,
397 but I don't think there's any harm in skipping that. */
398 while ((spill_size
= h8300_is_argument_spill (gdbarch
, pc
)) > 0
399 && pc
+ spill_size
<= current_pc
)
405 static struct h8300_frame_cache
*
406 h8300_frame_cache (const frame_info_ptr
&this_frame
, void **this_cache
)
408 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
409 struct h8300_frame_cache
*cache
;
411 CORE_ADDR current_pc
;
414 return (struct h8300_frame_cache
*) *this_cache
;
416 cache
= FRAME_OBSTACK_ZALLOC (struct h8300_frame_cache
);
417 h8300_init_frame_cache (gdbarch
, cache
);
420 /* In principle, for normal frames, %fp holds the frame pointer,
421 which holds the base address for the current stack frame.
422 However, for functions that don't need it, the frame pointer is
423 optional. For these "frameless" functions the frame pointer is
424 actually the frame pointer of the calling frame. */
426 cache
->base
= get_frame_register_unsigned (this_frame
, E_FP_REGNUM
);
427 if (cache
->base
== 0)
430 cache
->saved_regs
[E_PC_REGNUM
] = -BINWORD (gdbarch
);
432 cache
->pc
= get_frame_func (this_frame
);
433 current_pc
= get_frame_pc (this_frame
);
435 h8300_analyze_prologue (gdbarch
, cache
->pc
, current_pc
, cache
);
439 /* We didn't find a valid frame, which means that CACHE->base
440 currently holds the frame pointer for our calling frame. If
441 we're at the start of a function, or somewhere half-way its
442 prologue, the function's frame probably hasn't been fully
443 setup yet. Try to reconstruct the base address for the stack
444 frame by looking at the stack pointer. For truly "frameless"
445 functions this might work too. */
447 cache
->base
= get_frame_register_unsigned (this_frame
, E_SP_REGNUM
)
449 cache
->saved_sp
= cache
->base
+ BINWORD (gdbarch
);
450 cache
->saved_regs
[E_PC_REGNUM
] = 0;
454 cache
->saved_sp
= cache
->base
+ 2 * BINWORD (gdbarch
);
455 cache
->saved_regs
[E_PC_REGNUM
] = -BINWORD (gdbarch
);
458 /* Adjust all the saved registers such that they contain addresses
459 instead of offsets. */
460 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
461 if (cache
->saved_regs
[i
] != -1)
462 cache
->saved_regs
[i
] = cache
->base
- cache
->saved_regs
[i
];
468 h8300_frame_this_id (const frame_info_ptr
&this_frame
, void **this_cache
,
469 struct frame_id
*this_id
)
471 struct h8300_frame_cache
*cache
=
472 h8300_frame_cache (this_frame
, this_cache
);
474 /* This marks the outermost frame. */
475 if (cache
->base
== 0)
478 *this_id
= frame_id_build (cache
->saved_sp
, cache
->pc
);
481 static struct value
*
482 h8300_frame_prev_register (const frame_info_ptr
&this_frame
, void **this_cache
,
485 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
486 struct h8300_frame_cache
*cache
=
487 h8300_frame_cache (this_frame
, this_cache
);
489 gdb_assert (regnum
>= 0);
491 if (regnum
== E_SP_REGNUM
&& cache
->saved_sp
)
492 return frame_unwind_got_constant (this_frame
, regnum
, cache
->saved_sp
);
494 if (regnum
< gdbarch_num_regs (gdbarch
)
495 && cache
->saved_regs
[regnum
] != -1)
496 return frame_unwind_got_memory (this_frame
, regnum
,
497 cache
->saved_regs
[regnum
]);
499 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
502 static const struct frame_unwind h8300_frame_unwind
= {
505 default_frame_unwind_stop_reason
,
507 h8300_frame_prev_register
,
509 default_frame_sniffer
513 h8300_frame_base_address (const frame_info_ptr
&this_frame
, void **this_cache
)
515 struct h8300_frame_cache
*cache
= h8300_frame_cache (this_frame
, this_cache
);
519 static const struct frame_base h8300_frame_base
= {
521 h8300_frame_base_address
,
522 h8300_frame_base_address
,
523 h8300_frame_base_address
527 h8300_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
529 CORE_ADDR func_addr
= 0 , func_end
= 0;
531 if (find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
533 struct symtab_and_line sal
;
534 struct h8300_frame_cache cache
;
536 /* Found a function. */
537 sal
= find_pc_line (func_addr
, 0);
538 if (sal
.end
&& sal
.end
< func_end
)
539 /* Found a line number, use it as end of prologue. */
542 /* No useable line symbol. Use prologue parsing method. */
543 h8300_init_frame_cache (gdbarch
, &cache
);
544 return h8300_analyze_prologue (gdbarch
, func_addr
, func_end
, &cache
);
547 /* No function symbol -- just return the PC. */
548 return (CORE_ADDR
) pc
;
551 /* Function: push_dummy_call
552 Setup the function arguments for calling a function in the inferior.
553 In this discussion, a `word' is 16 bits on the H8/300s, and 32 bits
556 There are actually two ABI's here: -mquickcall (the default) and
557 -mno-quickcall. With -mno-quickcall, all arguments are passed on
558 the stack after the return address, word-aligned. With
559 -mquickcall, GCC tries to use r0 -- r2 to pass registers. Since
560 GCC doesn't indicate in the object file which ABI was used to
561 compile it, GDB only supports the default --- -mquickcall.
563 Here are the rules for -mquickcall, in detail:
565 Each argument, whether scalar or aggregate, is padded to occupy a
566 whole number of words. Arguments smaller than a word are padded at
567 the most significant end; those larger than a word are padded at
568 the least significant end.
570 The initial arguments are passed in r0 -- r2. Earlier arguments go in
571 lower-numbered registers. Multi-word arguments are passed in
572 consecutive registers, with the most significant end in the
573 lower-numbered register.
575 If an argument doesn't fit entirely in the remaining registers, it
576 is passed entirely on the stack. Stack arguments begin just after
577 the return address. Once an argument has overflowed onto the stack
578 this way, all subsequent arguments are passed on the stack.
580 The above rule has odd consequences. For example, on the h8/300s,
581 if a function takes two longs and an int as arguments:
582 - the first long will be passed in r0/r1,
583 - the second long will be passed entirely on the stack, since it
585 - and the int will be passed on the stack, even though it could fit
588 A weird exception: if an argument is larger than a word, but not a
589 whole number of words in length (before padding), it is passed on
590 the stack following the rules for stack arguments above, even if
591 there are sufficient registers available to hold it. Stranger
592 still, the argument registers are still `used up' --- even though
593 there's nothing in them.
595 So, for example, on the h8/300s, if a function expects a three-byte
596 structure and an int, the structure will go on the stack, and the
597 int will go in r2, not r0.
599 If the function returns an aggregate type (struct, union, or class)
600 by value, the caller must allocate space to hold the return value,
601 and pass the callee a pointer to this space as an invisible first
604 For varargs functions, the last fixed argument and all the variable
605 arguments are always passed on the stack. This means that calls to
606 varargs functions don't work properly unless there is a prototype
609 Basically, this ABI is not good, for the following reasons:
610 - You can't call vararg functions properly unless a prototype is in scope.
611 - Structure passing is inconsistent, to no purpose I can see.
612 - It often wastes argument registers, of which there are only three
616 h8300_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
617 struct regcache
*regcache
, CORE_ADDR bp_addr
,
618 int nargs
, struct value
**args
, CORE_ADDR sp
,
619 function_call_return_method return_method
,
620 CORE_ADDR struct_addr
)
622 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
623 int stack_alloc
= 0, stack_offset
= 0;
624 int wordsize
= BINWORD (gdbarch
);
625 int reg
= E_ARG0_REGNUM
;
628 /* First, make sure the stack is properly aligned. */
629 sp
= align_down (sp
, wordsize
);
631 /* Now make sure there's space on the stack for the arguments. We
632 may over-allocate a little here, but that won't hurt anything. */
633 for (argument
= 0; argument
< nargs
; argument
++)
634 stack_alloc
+= align_up (args
[argument
]->type ()->length (), wordsize
);
637 /* Now load as many arguments as possible into registers, and push
638 the rest onto the stack.
639 If we're returning a structure by value, then we must pass a
640 pointer to the buffer for the return value as an invisible first
642 if (return_method
== return_method_struct
)
643 regcache_cooked_write_unsigned (regcache
, reg
++, struct_addr
);
645 for (argument
= 0; argument
< nargs
; argument
++)
647 struct type
*type
= args
[argument
]->type ();
648 int len
= type
->length ();
649 char *contents
= (char *) args
[argument
]->contents ().data ();
651 /* Pad the argument appropriately. */
652 int padded_len
= align_up (len
, wordsize
);
653 /* Use std::vector here to get zero initialization. */
654 std::vector
<gdb_byte
> padded (padded_len
);
656 memcpy ((len
< wordsize
? padded
.data () + padded_len
- len
660 /* Could the argument fit in the remaining registers? */
661 if (padded_len
<= (E_ARGLAST_REGNUM
- reg
+ 1) * wordsize
)
663 /* Are we going to pass it on the stack anyway, for no good
665 if (len
> wordsize
&& len
% wordsize
)
667 /* I feel so unclean. */
668 write_memory (sp
+ stack_offset
, padded
.data (), padded_len
);
669 stack_offset
+= padded_len
;
671 /* That's right --- even though we passed the argument
672 on the stack, we consume the registers anyway! Love
674 reg
+= padded_len
/ wordsize
;
678 /* Heavens to Betsy --- it's really going in registers!
679 Note that on the h8/300s, there are gaps between the
680 registers in the register file. */
683 for (offset
= 0; offset
< padded_len
; offset
+= wordsize
)
686 = extract_unsigned_integer (&padded
[offset
],
687 wordsize
, byte_order
);
688 regcache_cooked_write_unsigned (regcache
, reg
++, word
);
694 /* It doesn't fit in registers! Onto the stack it goes. */
695 write_memory (sp
+ stack_offset
, padded
.data (), padded_len
);
696 stack_offset
+= padded_len
;
698 /* Once one argument has spilled onto the stack, all
699 subsequent arguments go on the stack. */
700 reg
= E_ARGLAST_REGNUM
+ 1;
704 /* Store return address. */
706 write_memory_unsigned_integer (sp
, wordsize
, byte_order
, bp_addr
);
708 /* Update stack pointer. */
709 regcache_cooked_write_unsigned (regcache
, E_SP_REGNUM
, sp
);
711 /* Return the new stack pointer minus the return address slot since
712 that's what DWARF2/GCC uses as the frame's CFA. */
713 return sp
+ wordsize
;
716 /* Function: extract_return_value
717 Figure out where in REGBUF the called function has left its return value.
718 Copy that into VALBUF. Be sure to account for CPU type. */
721 h8300_extract_return_value (struct type
*type
, struct regcache
*regcache
,
724 struct gdbarch
*gdbarch
= regcache
->arch ();
725 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
726 int len
= type
->length ();
733 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &c
);
734 store_unsigned_integer (valbuf
, len
, byte_order
, c
);
736 case 4: /* Needs two registers on plain H8/300 */
737 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &c
);
738 store_unsigned_integer (valbuf
, 2, byte_order
, c
);
739 regcache_cooked_read_unsigned (regcache
, E_RET1_REGNUM
, &c
);
740 store_unsigned_integer (valbuf
+ 2, 2, byte_order
, c
);
742 case 8: /* long long is now 8 bytes. */
743 if (type
->code () == TYPE_CODE_INT
)
745 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &addr
);
746 c
= read_memory_unsigned_integer ((CORE_ADDR
) addr
, len
, byte_order
);
747 store_unsigned_integer (valbuf
, len
, byte_order
, c
);
751 error (_("I don't know how this 8 byte value is returned."));
758 h8300h_extract_return_value (struct type
*type
, struct regcache
*regcache
,
761 struct gdbarch
*gdbarch
= regcache
->arch ();
762 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
765 switch (type
->length ())
770 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &c
);
771 store_unsigned_integer (valbuf
, type
->length (), byte_order
, c
);
773 case 8: /* long long is now 8 bytes. */
774 if (type
->code () == TYPE_CODE_INT
)
776 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &c
);
777 store_unsigned_integer (valbuf
, 4, byte_order
, c
);
778 regcache_cooked_read_unsigned (regcache
, E_RET1_REGNUM
, &c
);
779 store_unsigned_integer (valbuf
+ 4, 4, byte_order
, c
);
783 error (_("I don't know how this 8 byte value is returned."));
790 h8300_use_struct_convention (struct type
*value_type
)
792 /* Types of 1, 2 or 4 bytes are returned in R0/R1, everything else on the
795 if (value_type
->code () == TYPE_CODE_STRUCT
796 || value_type
->code () == TYPE_CODE_UNION
)
798 return !(value_type
->length () == 1
799 || value_type
->length () == 2
800 || value_type
->length () == 4);
804 h8300h_use_struct_convention (struct type
*value_type
)
806 /* Types of 1, 2 or 4 bytes are returned in R0, INT types of 8 bytes are
807 returned in R0/R1, everything else on the stack. */
808 if (value_type
->code () == TYPE_CODE_STRUCT
809 || value_type
->code () == TYPE_CODE_UNION
)
811 return !(value_type
->length () == 1
812 || value_type
->length () == 2
813 || value_type
->length () == 4
814 || (value_type
->length () == 8
815 && value_type
->code () == TYPE_CODE_INT
));
818 /* Function: store_return_value
819 Place the appropriate value in the appropriate registers.
820 Primarily used by the RETURN command. */
823 h8300_store_return_value (struct type
*type
, struct regcache
*regcache
,
824 const gdb_byte
*valbuf
)
826 struct gdbarch
*gdbarch
= regcache
->arch ();
827 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
830 switch (type
->length ())
833 case 2: /* short... */
834 val
= extract_unsigned_integer (valbuf
, type
->length (), byte_order
);
835 regcache_cooked_write_unsigned (regcache
, E_RET0_REGNUM
, val
);
837 case 4: /* long, float */
838 val
= extract_unsigned_integer (valbuf
, type
->length (), byte_order
);
839 regcache_cooked_write_unsigned (regcache
, E_RET0_REGNUM
,
840 (val
>> 16) & 0xffff);
841 regcache_cooked_write_unsigned (regcache
, E_RET1_REGNUM
, val
& 0xffff);
843 case 8: /* long long, double and long double
844 are all defined as 4 byte types so
845 far so this shouldn't happen. */
846 error (_("I don't know how to return an 8 byte value."));
852 h8300h_store_return_value (struct type
*type
, struct regcache
*regcache
,
853 const gdb_byte
*valbuf
)
855 struct gdbarch
*gdbarch
= regcache
->arch ();
856 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
859 switch (type
->length ())
863 case 4: /* long, float */
864 val
= extract_unsigned_integer (valbuf
, type
->length (), byte_order
);
865 regcache_cooked_write_unsigned (regcache
, E_RET0_REGNUM
, val
);
868 val
= extract_unsigned_integer (valbuf
, type
->length (), byte_order
);
869 regcache_cooked_write_unsigned (regcache
, E_RET0_REGNUM
,
870 (val
>> 32) & 0xffffffff);
871 regcache_cooked_write_unsigned (regcache
, E_RET1_REGNUM
,
877 static enum return_value_convention
878 h8300_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
879 struct type
*type
, struct regcache
*regcache
,
880 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
882 if (h8300_use_struct_convention (type
))
883 return RETURN_VALUE_STRUCT_CONVENTION
;
885 h8300_store_return_value (type
, regcache
, writebuf
);
887 h8300_extract_return_value (type
, regcache
, readbuf
);
888 return RETURN_VALUE_REGISTER_CONVENTION
;
891 static enum return_value_convention
892 h8300h_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
893 struct type
*type
, struct regcache
*regcache
,
894 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
896 if (h8300h_use_struct_convention (type
))
902 regcache_raw_read_unsigned (regcache
, E_R0_REGNUM
, &addr
);
903 read_memory (addr
, readbuf
, type
->length ());
906 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
909 h8300h_store_return_value (type
, regcache
, writebuf
);
911 h8300h_extract_return_value (type
, regcache
, readbuf
);
912 return RETURN_VALUE_REGISTER_CONVENTION
;
915 /* Implementation of 'register_sim_regno' gdbarch method. */
918 h8300_register_sim_regno (struct gdbarch
*gdbarch
, int regnum
)
920 /* Only makes sense to supply raw registers. */
921 gdb_assert (regnum
>= 0 && regnum
< gdbarch_num_regs (gdbarch
));
923 /* We hide the raw ccr from the user by making it nameless. Because
924 the default register_sim_regno hook returns
925 LEGACY_SIM_REGNO_IGNORE for unnamed registers, we need to
926 override it. The sim register numbering is compatible with
932 h8300_register_name_common (const char *regnames
[], int numregs
,
933 struct gdbarch
*gdbarch
, int regno
)
935 gdb_assert (numregs
== gdbarch_num_cooked_regs (gdbarch
));
936 return regnames
[regno
];
940 h8300_register_name (struct gdbarch
*gdbarch
, int regno
)
942 /* The register names change depending on which h8300 processor
944 static const char *register_names
[] = {
945 "r0", "r1", "r2", "r3", "r4", "r5", "r6",
946 "sp", "", "pc", "cycles", "tick", "inst",
947 "ccr", /* pseudo register */
949 return h8300_register_name_common(register_names
, ARRAY_SIZE(register_names
),
954 h8300h_register_name (struct gdbarch
*gdbarch
, int regno
)
956 static const char *register_names
[] = {
957 "er0", "er1", "er2", "er3", "er4", "er5", "er6",
958 "sp", "", "pc", "cycles", "tick", "inst",
959 "ccr", /* pseudo register */
961 return h8300_register_name_common(register_names
, ARRAY_SIZE(register_names
),
966 h8300s_register_name (struct gdbarch
*gdbarch
, int regno
)
968 static const char *register_names
[] = {
969 "er0", "er1", "er2", "er3", "er4", "er5", "er6",
970 "sp", "", "pc", "cycles", "", "tick", "inst",
972 "ccr", "exr" /* pseudo registers */
974 return h8300_register_name_common(register_names
, ARRAY_SIZE(register_names
),
979 h8300sx_register_name (struct gdbarch
*gdbarch
, int regno
)
981 static const char *register_names
[] = {
982 "er0", "er1", "er2", "er3", "er4", "er5", "er6",
983 "sp", "", "pc", "cycles", "", "tick", "inst",
984 "mach", "macl", "sbr", "vbr",
985 "ccr", "exr" /* pseudo registers */
987 return h8300_register_name_common(register_names
, ARRAY_SIZE(register_names
),
992 h8300_print_register (struct gdbarch
*gdbarch
, struct ui_file
*file
,
993 const frame_info_ptr
&frame
, int regno
)
996 const char *name
= gdbarch_register_name (gdbarch
, regno
);
1001 rval
= get_frame_register_signed (frame
, regno
);
1003 gdb_printf (file
, "%-14s ", name
);
1004 if ((regno
== E_PSEUDO_CCR_REGNUM (gdbarch
)) || \
1005 (regno
== E_PSEUDO_EXR_REGNUM (gdbarch
) && is_h8300smode (gdbarch
)))
1007 gdb_printf (file
, "0x%02x ", (unsigned char) rval
);
1008 print_longest (file
, 'u', 1, rval
);
1012 gdb_printf (file
, "0x%s ", phex ((ULONGEST
) rval
,
1013 BINWORD (gdbarch
)));
1014 print_longest (file
, 'd', 1, rval
);
1016 if (regno
== E_PSEUDO_CCR_REGNUM (gdbarch
))
1020 unsigned char l
= rval
& 0xff;
1021 gdb_printf (file
, "\t");
1022 gdb_printf (file
, "I-%d ", (l
& 0x80) != 0);
1023 gdb_printf (file
, "UI-%d ", (l
& 0x40) != 0);
1024 gdb_printf (file
, "H-%d ", (l
& 0x20) != 0);
1025 gdb_printf (file
, "U-%d ", (l
& 0x10) != 0);
1030 gdb_printf (file
, "N-%d ", N
);
1031 gdb_printf (file
, "Z-%d ", Z
);
1032 gdb_printf (file
, "V-%d ", V
);
1033 gdb_printf (file
, "C-%d ", C
);
1035 gdb_printf (file
, "u> ");
1037 gdb_printf (file
, "u<= ");
1039 gdb_printf (file
, "u>= ");
1041 gdb_printf (file
, "u< ");
1043 gdb_printf (file
, "!= ");
1045 gdb_printf (file
, "== ");
1047 gdb_printf (file
, ">= ");
1049 gdb_printf (file
, "< ");
1050 if ((Z
| (N
^ V
)) == 0)
1051 gdb_printf (file
, "> ");
1052 if ((Z
| (N
^ V
)) == 1)
1053 gdb_printf (file
, "<= ");
1055 else if (regno
== E_PSEUDO_EXR_REGNUM (gdbarch
) && is_h8300smode (gdbarch
))
1058 unsigned char l
= rval
& 0xff;
1059 gdb_printf (file
, "\t");
1060 gdb_printf (file
, "T-%d - - - ", (l
& 0x80) != 0);
1061 gdb_printf (file
, "I2-%d ", (l
& 4) != 0);
1062 gdb_printf (file
, "I1-%d ", (l
& 2) != 0);
1063 gdb_printf (file
, "I0-%d", (l
& 1) != 0);
1065 gdb_printf (file
, "\n");
1069 h8300_print_registers_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
1070 const frame_info_ptr
&frame
, int regno
, int cpregs
)
1074 for (regno
= E_R0_REGNUM
; regno
<= E_SP_REGNUM
; ++regno
)
1075 h8300_print_register (gdbarch
, file
, frame
, regno
);
1076 h8300_print_register (gdbarch
, file
, frame
,
1077 E_PSEUDO_CCR_REGNUM (gdbarch
));
1078 h8300_print_register (gdbarch
, file
, frame
, E_PC_REGNUM
);
1079 if (is_h8300smode (gdbarch
))
1081 h8300_print_register (gdbarch
, file
, frame
,
1082 E_PSEUDO_EXR_REGNUM (gdbarch
));
1083 if (is_h8300sxmode (gdbarch
))
1085 h8300_print_register (gdbarch
, file
, frame
, E_SBR_REGNUM
);
1086 h8300_print_register (gdbarch
, file
, frame
, E_VBR_REGNUM
);
1088 h8300_print_register (gdbarch
, file
, frame
, E_MACH_REGNUM
);
1089 h8300_print_register (gdbarch
, file
, frame
, E_MACL_REGNUM
);
1090 h8300_print_register (gdbarch
, file
, frame
, E_CYCLES_REGNUM
);
1091 h8300_print_register (gdbarch
, file
, frame
, E_TICKS_REGNUM
);
1092 h8300_print_register (gdbarch
, file
, frame
, E_INSTS_REGNUM
);
1096 h8300_print_register (gdbarch
, file
, frame
, E_CYCLES_REGNUM
);
1097 h8300_print_register (gdbarch
, file
, frame
, E_TICK_REGNUM
);
1098 h8300_print_register (gdbarch
, file
, frame
, E_INST_REGNUM
);
1103 if (regno
== E_CCR_REGNUM
)
1104 h8300_print_register (gdbarch
, file
, frame
,
1105 E_PSEUDO_CCR_REGNUM (gdbarch
));
1106 else if (regno
== E_PSEUDO_EXR_REGNUM (gdbarch
)
1107 && is_h8300smode (gdbarch
))
1108 h8300_print_register (gdbarch
, file
, frame
,
1109 E_PSEUDO_EXR_REGNUM (gdbarch
));
1111 h8300_print_register (gdbarch
, file
, frame
, regno
);
1115 static struct type
*
1116 h8300_register_type (struct gdbarch
*gdbarch
, int regno
)
1118 if (regno
< 0 || regno
>= gdbarch_num_cooked_regs (gdbarch
))
1119 internal_error (_("h8300_register_type: illegal register number %d"),
1126 return builtin_type (gdbarch
)->builtin_func_ptr
;
1129 return builtin_type (gdbarch
)->builtin_data_ptr
;
1131 if (regno
== E_PSEUDO_CCR_REGNUM (gdbarch
))
1132 return builtin_type (gdbarch
)->builtin_uint8
;
1133 else if (regno
== E_PSEUDO_EXR_REGNUM (gdbarch
))
1134 return builtin_type (gdbarch
)->builtin_uint8
;
1135 else if (is_h8300hmode (gdbarch
))
1136 return builtin_type (gdbarch
)->builtin_int32
;
1138 return builtin_type (gdbarch
)->builtin_int16
;
1143 /* Helpers for h8300_pseudo_register_read. We expose ccr/exr as
1144 pseudo-registers to users with smaller sizes than the corresponding
1145 raw registers. These helpers extend/narrow the values. */
1147 static enum register_status
1148 pseudo_from_raw_register (struct gdbarch
*gdbarch
, readable_regcache
*regcache
,
1149 gdb_byte
*buf
, int pseudo_regno
, int raw_regno
)
1151 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1152 enum register_status status
;
1155 status
= regcache
->raw_read (raw_regno
, &val
);
1156 if (status
== REG_VALID
)
1157 store_unsigned_integer (buf
,
1158 register_size (gdbarch
, pseudo_regno
),
1163 /* See pseudo_from_raw_register. */
1166 raw_from_pseudo_register (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
1167 const gdb_byte
*buf
, int raw_regno
, int pseudo_regno
)
1169 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1172 val
= extract_unsigned_integer (buf
, register_size (gdbarch
, pseudo_regno
),
1174 regcache_raw_write_unsigned (regcache
, raw_regno
, val
);
1177 static enum register_status
1178 h8300_pseudo_register_read (struct gdbarch
*gdbarch
,
1179 readable_regcache
*regcache
, int regno
,
1182 if (regno
== E_PSEUDO_CCR_REGNUM (gdbarch
))
1184 return pseudo_from_raw_register (gdbarch
, regcache
, buf
,
1185 regno
, E_CCR_REGNUM
);
1187 else if (regno
== E_PSEUDO_EXR_REGNUM (gdbarch
))
1189 return pseudo_from_raw_register (gdbarch
, regcache
, buf
,
1190 regno
, E_EXR_REGNUM
);
1193 return regcache
->raw_read (regno
, buf
);
1197 h8300_pseudo_register_write (struct gdbarch
*gdbarch
,
1198 struct regcache
*regcache
, int regno
,
1199 const gdb_byte
*buf
)
1201 if (regno
== E_PSEUDO_CCR_REGNUM (gdbarch
))
1202 raw_from_pseudo_register (gdbarch
, regcache
, buf
, E_CCR_REGNUM
, regno
);
1203 else if (regno
== E_PSEUDO_EXR_REGNUM (gdbarch
))
1204 raw_from_pseudo_register (gdbarch
, regcache
, buf
, E_EXR_REGNUM
, regno
);
1206 regcache
->raw_write (regno
, buf
);
1210 h8300_dbg_reg_to_regnum (struct gdbarch
*gdbarch
, int regno
)
1212 if (regno
== E_CCR_REGNUM
)
1213 return E_PSEUDO_CCR_REGNUM (gdbarch
);
1218 h8300s_dbg_reg_to_regnum (struct gdbarch
*gdbarch
, int regno
)
1220 if (regno
== E_CCR_REGNUM
)
1221 return E_PSEUDO_CCR_REGNUM (gdbarch
);
1222 if (regno
== E_EXR_REGNUM
)
1223 return E_PSEUDO_EXR_REGNUM (gdbarch
);
1227 /*static unsigned char breakpoint[] = { 0x7A, 0xFF }; *//* ??? */
1228 constexpr gdb_byte h8300_break_insn
[] = { 0x01, 0x80 }; /* Sleep */
1230 typedef BP_MANIPULATION (h8300_break_insn
) h8300_breakpoint
;
1232 static struct gdbarch
*
1233 h8300_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1235 struct gdbarch
*gdbarch
;
1237 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1239 return arches
->gdbarch
;
1241 if (info
.bfd_arch_info
->arch
!= bfd_arch_h8300
)
1244 gdbarch
= gdbarch_alloc (&info
, 0);
1246 set_gdbarch_register_sim_regno (gdbarch
, h8300_register_sim_regno
);
1248 switch (info
.bfd_arch_info
->mach
)
1250 case bfd_mach_h8300
:
1251 set_gdbarch_num_regs (gdbarch
, 13);
1252 set_gdbarch_num_pseudo_regs (gdbarch
, 1);
1253 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1254 set_gdbarch_stab_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1255 set_gdbarch_register_name (gdbarch
, h8300_register_name
);
1256 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1257 set_gdbarch_addr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1258 set_gdbarch_return_value (gdbarch
, h8300_return_value
);
1260 case bfd_mach_h8300h
:
1261 case bfd_mach_h8300hn
:
1262 set_gdbarch_num_regs (gdbarch
, 13);
1263 set_gdbarch_num_pseudo_regs (gdbarch
, 1);
1264 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1265 set_gdbarch_stab_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1266 set_gdbarch_register_name (gdbarch
, h8300h_register_name
);
1267 if (info
.bfd_arch_info
->mach
!= bfd_mach_h8300hn
)
1269 set_gdbarch_ptr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1270 set_gdbarch_addr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1274 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1275 set_gdbarch_addr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1277 set_gdbarch_return_value (gdbarch
, h8300h_return_value
);
1279 case bfd_mach_h8300s
:
1280 case bfd_mach_h8300sn
:
1281 set_gdbarch_num_regs (gdbarch
, 16);
1282 set_gdbarch_num_pseudo_regs (gdbarch
, 2);
1283 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1284 set_gdbarch_stab_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1285 set_gdbarch_register_name (gdbarch
, h8300s_register_name
);
1286 if (info
.bfd_arch_info
->mach
!= bfd_mach_h8300sn
)
1288 set_gdbarch_ptr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1289 set_gdbarch_addr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1293 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1294 set_gdbarch_addr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1296 set_gdbarch_return_value (gdbarch
, h8300h_return_value
);
1298 case bfd_mach_h8300sx
:
1299 case bfd_mach_h8300sxn
:
1300 set_gdbarch_num_regs (gdbarch
, 18);
1301 set_gdbarch_num_pseudo_regs (gdbarch
, 2);
1302 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1303 set_gdbarch_stab_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1304 set_gdbarch_register_name (gdbarch
, h8300sx_register_name
);
1305 if (info
.bfd_arch_info
->mach
!= bfd_mach_h8300sxn
)
1307 set_gdbarch_ptr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1308 set_gdbarch_addr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1312 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1313 set_gdbarch_addr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1315 set_gdbarch_return_value (gdbarch
, h8300h_return_value
);
1319 set_gdbarch_pseudo_register_read (gdbarch
, h8300_pseudo_register_read
);
1320 set_gdbarch_deprecated_pseudo_register_write (gdbarch
,
1321 h8300_pseudo_register_write
);
1324 * Basic register fields and methods.
1327 set_gdbarch_sp_regnum (gdbarch
, E_SP_REGNUM
);
1328 set_gdbarch_pc_regnum (gdbarch
, E_PC_REGNUM
);
1329 set_gdbarch_register_type (gdbarch
, h8300_register_type
);
1330 set_gdbarch_print_registers_info (gdbarch
, h8300_print_registers_info
);
1335 set_gdbarch_skip_prologue (gdbarch
, h8300_skip_prologue
);
1337 /* Frame unwinder. */
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_kind_from_pc (gdbarch
,
1347 h8300_breakpoint::kind_from_pc
);
1348 set_gdbarch_sw_breakpoint_from_kind (gdbarch
,
1349 h8300_breakpoint::bp_from_kind
);
1350 set_gdbarch_push_dummy_call (gdbarch
, h8300_push_dummy_call
);
1352 set_gdbarch_char_signed (gdbarch
, 0);
1353 set_gdbarch_int_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1354 set_gdbarch_long_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1355 set_gdbarch_long_long_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
1357 set_gdbarch_wchar_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1358 set_gdbarch_wchar_signed (gdbarch
, 0);
1360 set_gdbarch_double_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1361 set_gdbarch_double_format (gdbarch
, floatformats_ieee_single
);
1362 set_gdbarch_long_double_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1363 set_gdbarch_long_double_format (gdbarch
, floatformats_ieee_single
);
1365 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
1367 /* Hook in the DWARF CFI frame unwinder. */
1368 dwarf2_append_unwinders (gdbarch
);
1369 frame_unwind_append_unwinder (gdbarch
, &h8300_frame_unwind
);
1375 void _initialize_h8300_tdep ();
1377 _initialize_h8300_tdep ()
1379 gdbarch_register (bfd_arch_h8300
, h8300_gdbarch_init
);
1383 is_h8300hmode (struct gdbarch
*gdbarch
)
1385 return gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sx
1386 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sxn
1387 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300s
1388 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sn
1389 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300h
1390 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300hn
;
1394 is_h8300smode (struct gdbarch
*gdbarch
)
1396 return gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sx
1397 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sxn
1398 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300s
1399 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sn
;
1403 is_h8300sxmode (struct gdbarch
*gdbarch
)
1405 return gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sx
1406 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sxn
;
1410 is_h8300_normal_mode (struct gdbarch
*gdbarch
)
1412 return gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sxn
1413 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sn
1414 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300hn
;