1 /* Target-machine dependent code for Renesas H8/300, for GDB.
3 Copyright (C) 1988-2022 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
27 #include "arch-utils.h"
32 #include "dwarf2/frame.h"
33 #include "frame-base.h"
34 #include "frame-unwind.h"
38 E_R0_REGNUM
, E_ER0_REGNUM
= E_R0_REGNUM
, E_ARG0_REGNUM
= E_R0_REGNUM
,
39 E_RET0_REGNUM
= E_R0_REGNUM
,
40 E_R1_REGNUM
, E_ER1_REGNUM
= E_R1_REGNUM
, E_RET1_REGNUM
= E_R1_REGNUM
,
41 E_R2_REGNUM
, E_ER2_REGNUM
= E_R2_REGNUM
, E_ARGLAST_REGNUM
= E_R2_REGNUM
,
42 E_R3_REGNUM
, E_ER3_REGNUM
= E_R3_REGNUM
,
43 E_R4_REGNUM
, E_ER4_REGNUM
= E_R4_REGNUM
,
44 E_R5_REGNUM
, E_ER5_REGNUM
= E_R5_REGNUM
,
45 E_R6_REGNUM
, E_ER6_REGNUM
= E_R6_REGNUM
, E_FP_REGNUM
= E_R6_REGNUM
,
50 E_TICK_REGNUM
, E_EXR_REGNUM
= E_TICK_REGNUM
,
51 E_INST_REGNUM
, E_TICKS_REGNUM
= E_INST_REGNUM
,
59 #define H8300_MAX_NUM_REGS 18
61 #define E_PSEUDO_CCR_REGNUM(gdbarch) (gdbarch_num_regs (gdbarch))
62 #define E_PSEUDO_EXR_REGNUM(gdbarch) (gdbarch_num_regs (gdbarch)+1)
64 struct h8300_frame_cache
71 /* Flag showing that a frame has been created in the prologue code. */
74 /* Saved registers. */
75 CORE_ADDR saved_regs
[H8300_MAX_NUM_REGS
];
83 h8300_max_reg_size
= 4,
86 static int is_h8300hmode (struct gdbarch
*gdbarch
);
87 static int is_h8300smode (struct gdbarch
*gdbarch
);
88 static int is_h8300sxmode (struct gdbarch
*gdbarch
);
89 static int is_h8300_normal_mode (struct gdbarch
*gdbarch
);
91 #define BINWORD(gdbarch) ((is_h8300hmode (gdbarch) \
92 && !is_h8300_normal_mode (gdbarch)) \
93 ? h8300h_reg_size : h8300_reg_size)
97 /* Allocate and initialize a frame cache. */
100 h8300_init_frame_cache (struct gdbarch
*gdbarch
,
101 struct h8300_frame_cache
*cache
)
107 cache
->sp_offset
= 0;
110 /* Frameless until proven otherwise. */
113 /* Saved registers. We initialize these to -1 since zero is a valid
114 offset (that's where %fp is supposed to be stored). */
115 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
116 cache
->saved_regs
[i
] = -1;
119 #define IS_MOVB_RnRm(x) (((x) & 0xff88) == 0x0c88)
120 #define IS_MOVW_RnRm(x) (((x) & 0xff88) == 0x0d00)
121 #define IS_MOVL_RnRm(x) (((x) & 0xff88) == 0x0f80)
122 #define IS_MOVB_Rn16_SP(x) (((x) & 0xfff0) == 0x6ee0)
123 #define IS_MOVB_EXT(x) ((x) == 0x7860)
124 #define IS_MOVB_Rn24_SP(x) (((x) & 0xfff0) == 0x6aa0)
125 #define IS_MOVW_Rn16_SP(x) (((x) & 0xfff0) == 0x6fe0)
126 #define IS_MOVW_EXT(x) ((x) == 0x78e0)
127 #define IS_MOVW_Rn24_SP(x) (((x) & 0xfff0) == 0x6ba0)
128 /* Same instructions as mov.w, just prefixed with 0x0100. */
129 #define IS_MOVL_PRE(x) ((x) == 0x0100)
130 #define IS_MOVL_Rn16_SP(x) (((x) & 0xfff0) == 0x6fe0)
131 #define IS_MOVL_EXT(x) ((x) == 0x78e0)
132 #define IS_MOVL_Rn24_SP(x) (((x) & 0xfff0) == 0x6ba0)
134 #define IS_PUSHFP_MOVESPFP(x) ((x) == 0x6df60d76)
135 #define IS_PUSH_FP(x) ((x) == 0x01006df6)
136 #define IS_MOV_SP_FP(x) ((x) == 0x0ff6)
137 #define IS_SUB2_SP(x) ((x) == 0x1b87)
138 #define IS_SUB4_SP(x) ((x) == 0x1b97)
139 #define IS_ADD_IMM_SP(x) ((x) == 0x7a1f)
140 #define IS_SUB_IMM_SP(x) ((x) == 0x7a3f)
141 #define IS_SUBL4_SP(x) ((x) == 0x1acf)
142 #define IS_MOV_IMM_Rn(x) (((x) & 0xfff0) == 0x7905)
143 #define IS_SUB_RnSP(x) (((x) & 0xff0f) == 0x1907)
144 #define IS_ADD_RnSP(x) (((x) & 0xff0f) == 0x0907)
145 #define IS_PUSH(x) (((x) & 0xfff0) == 0x6df0)
147 /* If the instruction at PC is an argument register spill, return its
148 length. Otherwise, return zero.
150 An argument register spill is an instruction that moves an argument
151 from the register in which it was passed to the stack slot in which
152 it really lives. It is a byte, word, or longword move from an
153 argument register to a negative offset from the frame pointer.
155 CV, 2003-06-16: Or, in optimized code or when the `register' qualifier
156 is used, it could be a byte, word or long move to registers r3-r5. */
159 h8300_is_argument_spill (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
161 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
162 int w
= read_memory_unsigned_integer (pc
, 2, byte_order
);
164 if ((IS_MOVB_RnRm (w
) || IS_MOVW_RnRm (w
) || IS_MOVL_RnRm (w
))
165 && (w
& 0x70) <= 0x20 /* Rs is R0, R1 or R2 */
166 && (w
& 0x7) >= 0x3 && (w
& 0x7) <= 0x5) /* Rd is R3, R4 or R5 */
169 if (IS_MOVB_Rn16_SP (w
)
170 && 8 <= (w
& 0xf) && (w
& 0xf) <= 10) /* Rs is R0L, R1L, or R2L */
172 /* ... and d:16 is negative. */
173 if (read_memory_integer (pc
+ 2, 2, byte_order
) < 0)
176 else if (IS_MOVB_EXT (w
))
178 if (IS_MOVB_Rn24_SP (read_memory_unsigned_integer (pc
+ 2,
181 ULONGEST disp
= read_memory_unsigned_integer (pc
+ 4, 4, byte_order
);
183 /* ... and d:24 is negative. */
184 if ((disp
& 0x00800000) != 0)
188 else if (IS_MOVW_Rn16_SP (w
)
189 && (w
& 0xf) <= 2) /* Rs is R0, R1, or R2 */
191 /* ... and d:16 is negative. */
192 if (read_memory_integer (pc
+ 2, 2, byte_order
) < 0)
195 else if (IS_MOVW_EXT (w
))
197 if (IS_MOVW_Rn24_SP (read_memory_unsigned_integer (pc
+ 2,
200 ULONGEST disp
= read_memory_unsigned_integer (pc
+ 4, 4, byte_order
);
202 /* ... and d:24 is negative. */
203 if ((disp
& 0x00800000) != 0)
207 else if (IS_MOVL_PRE (w
))
209 int w2
= read_memory_integer (pc
+ 2, 2, byte_order
);
211 if (IS_MOVL_Rn16_SP (w2
)
212 && (w2
& 0xf) <= 2) /* Rs is ER0, ER1, or ER2 */
214 /* ... and d:16 is negative. */
215 if (read_memory_integer (pc
+ 4, 2, byte_order
) < 0)
218 else if (IS_MOVL_EXT (w2
))
220 if (IS_MOVL_Rn24_SP (read_memory_integer (pc
+ 4, 2, byte_order
)))
222 ULONGEST disp
= read_memory_unsigned_integer (pc
+ 6, 4,
225 /* ... and d:24 is negative. */
226 if ((disp
& 0x00800000) != 0)
235 /* Do a full analysis of the prologue at PC and update CACHE
236 accordingly. Bail out early if CURRENT_PC is reached. Return the
237 address where the analysis stopped.
239 We handle all cases that can be generated by gcc.
241 For allocating a stack frame:
262 For saving registers:
271 h8300_analyze_prologue (struct gdbarch
*gdbarch
,
272 CORE_ADDR pc
, CORE_ADDR current_pc
,
273 struct h8300_frame_cache
*cache
)
275 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
277 int regno
, i
, spill_size
;
279 cache
->sp_offset
= 0;
281 if (pc
>= current_pc
)
284 op
= read_memory_unsigned_integer (pc
, 4, byte_order
);
286 if (IS_PUSHFP_MOVESPFP (op
))
288 cache
->saved_regs
[E_FP_REGNUM
] = 0;
292 else if (IS_PUSH_FP (op
))
294 cache
->saved_regs
[E_FP_REGNUM
] = 0;
296 if (pc
>= current_pc
)
298 op
= read_memory_unsigned_integer (pc
, 2, byte_order
);
299 if (IS_MOV_SP_FP (op
))
306 while (pc
< current_pc
)
308 op
= read_memory_unsigned_integer (pc
, 2, byte_order
);
311 cache
->sp_offset
+= 2;
314 else if (IS_SUB4_SP (op
))
316 cache
->sp_offset
+= 4;
319 else if (IS_ADD_IMM_SP (op
))
321 cache
->sp_offset
+= -read_memory_integer (pc
+ 2, 2, byte_order
);
324 else if (IS_SUB_IMM_SP (op
))
326 cache
->sp_offset
+= read_memory_integer (pc
+ 2, 2, byte_order
);
329 else if (IS_SUBL4_SP (op
))
331 cache
->sp_offset
+= 4;
334 else if (IS_MOV_IMM_Rn (op
))
336 int offset
= read_memory_integer (pc
+ 2, 2, byte_order
);
338 op
= read_memory_unsigned_integer (pc
+ 4, 2, byte_order
);
339 if (IS_ADD_RnSP (op
) && (op
& 0x00f0) == regno
)
341 cache
->sp_offset
-= offset
;
344 else if (IS_SUB_RnSP (op
) && (op
& 0x00f0) == regno
)
346 cache
->sp_offset
+= offset
;
352 else if (IS_PUSH (op
))
355 cache
->sp_offset
+= 2;
356 cache
->saved_regs
[regno
] = cache
->sp_offset
;
359 else if (op
== 0x0100)
361 op
= read_memory_unsigned_integer (pc
+ 2, 2, byte_order
);
365 cache
->sp_offset
+= 4;
366 cache
->saved_regs
[regno
] = cache
->sp_offset
;
372 else if ((op
& 0xffcf) == 0x0100)
375 op1
= read_memory_unsigned_integer (pc
+ 2, 2, byte_order
);
378 /* Since the prefix is 0x01x0, this is not a simple pushm but a
379 stm.l reglist,@-sp */
380 i
= ((op
& 0x0030) >> 4) + 1;
381 regno
= op1
& 0x000f;
382 for (; i
> 0; regno
++, --i
)
384 cache
->sp_offset
+= 4;
385 cache
->saved_regs
[regno
] = cache
->sp_offset
;
396 /* Check for spilling an argument register to the stack frame.
397 This could also be an initializing store from non-prologue code,
398 but I don't think there's any harm in skipping that. */
399 while ((spill_size
= h8300_is_argument_spill (gdbarch
, pc
)) > 0
400 && pc
+ spill_size
<= current_pc
)
406 static struct h8300_frame_cache
*
407 h8300_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
409 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
410 struct h8300_frame_cache
*cache
;
412 CORE_ADDR current_pc
;
415 return (struct h8300_frame_cache
*) *this_cache
;
417 cache
= FRAME_OBSTACK_ZALLOC (struct h8300_frame_cache
);
418 h8300_init_frame_cache (gdbarch
, cache
);
421 /* In principle, for normal frames, %fp holds the frame pointer,
422 which holds the base address for the current stack frame.
423 However, for functions that don't need it, the frame pointer is
424 optional. For these "frameless" functions the frame pointer is
425 actually the frame pointer of the calling frame. */
427 cache
->base
= get_frame_register_unsigned (this_frame
, E_FP_REGNUM
);
428 if (cache
->base
== 0)
431 cache
->saved_regs
[E_PC_REGNUM
] = -BINWORD (gdbarch
);
433 cache
->pc
= get_frame_func (this_frame
);
434 current_pc
= get_frame_pc (this_frame
);
436 h8300_analyze_prologue (gdbarch
, cache
->pc
, current_pc
, cache
);
440 /* We didn't find a valid frame, which means that CACHE->base
441 currently holds the frame pointer for our calling frame. If
442 we're at the start of a function, or somewhere half-way its
443 prologue, the function's frame probably hasn't been fully
444 setup yet. Try to reconstruct the base address for the stack
445 frame by looking at the stack pointer. For truly "frameless"
446 functions this might work too. */
448 cache
->base
= get_frame_register_unsigned (this_frame
, E_SP_REGNUM
)
450 cache
->saved_sp
= cache
->base
+ BINWORD (gdbarch
);
451 cache
->saved_regs
[E_PC_REGNUM
] = 0;
455 cache
->saved_sp
= cache
->base
+ 2 * BINWORD (gdbarch
);
456 cache
->saved_regs
[E_PC_REGNUM
] = -BINWORD (gdbarch
);
459 /* Adjust all the saved registers such that they contain addresses
460 instead of offsets. */
461 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
462 if (cache
->saved_regs
[i
] != -1)
463 cache
->saved_regs
[i
] = cache
->base
- cache
->saved_regs
[i
];
469 h8300_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
470 struct frame_id
*this_id
)
472 struct h8300_frame_cache
*cache
=
473 h8300_frame_cache (this_frame
, this_cache
);
475 /* This marks the outermost frame. */
476 if (cache
->base
== 0)
479 *this_id
= frame_id_build (cache
->saved_sp
, cache
->pc
);
482 static struct value
*
483 h8300_frame_prev_register (struct frame_info
*this_frame
, void **this_cache
,
486 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
487 struct h8300_frame_cache
*cache
=
488 h8300_frame_cache (this_frame
, this_cache
);
490 gdb_assert (regnum
>= 0);
492 if (regnum
== E_SP_REGNUM
&& cache
->saved_sp
)
493 return frame_unwind_got_constant (this_frame
, regnum
, cache
->saved_sp
);
495 if (regnum
< gdbarch_num_regs (gdbarch
)
496 && cache
->saved_regs
[regnum
] != -1)
497 return frame_unwind_got_memory (this_frame
, regnum
,
498 cache
->saved_regs
[regnum
]);
500 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
503 static const struct frame_unwind h8300_frame_unwind
= {
506 default_frame_unwind_stop_reason
,
508 h8300_frame_prev_register
,
510 default_frame_sniffer
514 h8300_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
516 struct h8300_frame_cache
*cache
= h8300_frame_cache (this_frame
, this_cache
);
520 static const struct frame_base h8300_frame_base
= {
522 h8300_frame_base_address
,
523 h8300_frame_base_address
,
524 h8300_frame_base_address
528 h8300_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
530 CORE_ADDR func_addr
= 0 , func_end
= 0;
532 if (find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
534 struct symtab_and_line sal
;
535 struct h8300_frame_cache cache
;
537 /* Found a function. */
538 sal
= find_pc_line (func_addr
, 0);
539 if (sal
.end
&& sal
.end
< func_end
)
540 /* Found a line number, use it as end of prologue. */
543 /* No useable line symbol. Use prologue parsing method. */
544 h8300_init_frame_cache (gdbarch
, &cache
);
545 return h8300_analyze_prologue (gdbarch
, func_addr
, func_end
, &cache
);
548 /* No function symbol -- just return the PC. */
549 return (CORE_ADDR
) pc
;
552 /* Function: push_dummy_call
553 Setup the function arguments for calling a function in the inferior.
554 In this discussion, a `word' is 16 bits on the H8/300s, and 32 bits
557 There are actually two ABI's here: -mquickcall (the default) and
558 -mno-quickcall. With -mno-quickcall, all arguments are passed on
559 the stack after the return address, word-aligned. With
560 -mquickcall, GCC tries to use r0 -- r2 to pass registers. Since
561 GCC doesn't indicate in the object file which ABI was used to
562 compile it, GDB only supports the default --- -mquickcall.
564 Here are the rules for -mquickcall, in detail:
566 Each argument, whether scalar or aggregate, is padded to occupy a
567 whole number of words. Arguments smaller than a word are padded at
568 the most significant end; those larger than a word are padded at
569 the least significant end.
571 The initial arguments are passed in r0 -- r2. Earlier arguments go in
572 lower-numbered registers. Multi-word arguments are passed in
573 consecutive registers, with the most significant end in the
574 lower-numbered register.
576 If an argument doesn't fit entirely in the remaining registers, it
577 is passed entirely on the stack. Stack arguments begin just after
578 the return address. Once an argument has overflowed onto the stack
579 this way, all subsequent arguments are passed on the stack.
581 The above rule has odd consequences. For example, on the h8/300s,
582 if a function takes two longs and an int as arguments:
583 - the first long will be passed in r0/r1,
584 - the second long will be passed entirely on the stack, since it
586 - and the int will be passed on the stack, even though it could fit
589 A weird exception: if an argument is larger than a word, but not a
590 whole number of words in length (before padding), it is passed on
591 the stack following the rules for stack arguments above, even if
592 there are sufficient registers available to hold it. Stranger
593 still, the argument registers are still `used up' --- even though
594 there's nothing in them.
596 So, for example, on the h8/300s, if a function expects a three-byte
597 structure and an int, the structure will go on the stack, and the
598 int will go in r2, not r0.
600 If the function returns an aggregate type (struct, union, or class)
601 by value, the caller must allocate space to hold the return value,
602 and pass the callee a pointer to this space as an invisible first
605 For varargs functions, the last fixed argument and all the variable
606 arguments are always passed on the stack. This means that calls to
607 varargs functions don't work properly unless there is a prototype
610 Basically, this ABI is not good, for the following reasons:
611 - You can't call vararg functions properly unless a prototype is in scope.
612 - Structure passing is inconsistent, to no purpose I can see.
613 - It often wastes argument registers, of which there are only three
617 h8300_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
618 struct regcache
*regcache
, CORE_ADDR bp_addr
,
619 int nargs
, struct value
**args
, CORE_ADDR sp
,
620 function_call_return_method return_method
,
621 CORE_ADDR struct_addr
)
623 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
624 int stack_alloc
= 0, stack_offset
= 0;
625 int wordsize
= BINWORD (gdbarch
);
626 int reg
= E_ARG0_REGNUM
;
629 /* First, make sure the stack is properly aligned. */
630 sp
= align_down (sp
, wordsize
);
632 /* Now make sure there's space on the stack for the arguments. We
633 may over-allocate a little here, but that won't hurt anything. */
634 for (argument
= 0; argument
< nargs
; argument
++)
635 stack_alloc
+= align_up (value_type (args
[argument
])->length (), wordsize
);
638 /* Now load as many arguments as possible into registers, and push
639 the rest onto the stack.
640 If we're returning a structure by value, then we must pass a
641 pointer to the buffer for the return value as an invisible first
643 if (return_method
== return_method_struct
)
644 regcache_cooked_write_unsigned (regcache
, reg
++, struct_addr
);
646 for (argument
= 0; argument
< nargs
; argument
++)
648 struct type
*type
= value_type (args
[argument
]);
649 int len
= type
->length ();
650 char *contents
= (char *) value_contents (args
[argument
]).data ();
652 /* Pad the argument appropriately. */
653 int padded_len
= align_up (len
, wordsize
);
654 /* Use std::vector here to get zero initialization. */
655 std::vector
<gdb_byte
> padded (padded_len
);
657 memcpy ((len
< wordsize
? padded
.data () + padded_len
- len
661 /* Could the argument fit in the remaining registers? */
662 if (padded_len
<= (E_ARGLAST_REGNUM
- reg
+ 1) * wordsize
)
664 /* Are we going to pass it on the stack anyway, for no good
666 if (len
> wordsize
&& len
% wordsize
)
668 /* I feel so unclean. */
669 write_memory (sp
+ stack_offset
, padded
.data (), padded_len
);
670 stack_offset
+= padded_len
;
672 /* That's right --- even though we passed the argument
673 on the stack, we consume the registers anyway! Love
675 reg
+= padded_len
/ wordsize
;
679 /* Heavens to Betsy --- it's really going in registers!
680 Note that on the h8/300s, there are gaps between the
681 registers in the register file. */
684 for (offset
= 0; offset
< padded_len
; offset
+= wordsize
)
687 = extract_unsigned_integer (&padded
[offset
],
688 wordsize
, byte_order
);
689 regcache_cooked_write_unsigned (regcache
, reg
++, word
);
695 /* It doesn't fit in registers! Onto the stack it goes. */
696 write_memory (sp
+ stack_offset
, padded
.data (), padded_len
);
697 stack_offset
+= padded_len
;
699 /* Once one argument has spilled onto the stack, all
700 subsequent arguments go on the stack. */
701 reg
= E_ARGLAST_REGNUM
+ 1;
705 /* Store return address. */
707 write_memory_unsigned_integer (sp
, wordsize
, byte_order
, bp_addr
);
709 /* Update stack pointer. */
710 regcache_cooked_write_unsigned (regcache
, E_SP_REGNUM
, sp
);
712 /* Return the new stack pointer minus the return address slot since
713 that's what DWARF2/GCC uses as the frame's CFA. */
714 return sp
+ wordsize
;
717 /* Function: extract_return_value
718 Figure out where in REGBUF the called function has left its return value.
719 Copy that into VALBUF. Be sure to account for CPU type. */
722 h8300_extract_return_value (struct type
*type
, struct regcache
*regcache
,
725 struct gdbarch
*gdbarch
= regcache
->arch ();
726 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
727 int len
= type
->length ();
734 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &c
);
735 store_unsigned_integer (valbuf
, len
, byte_order
, c
);
737 case 4: /* Needs two registers on plain H8/300 */
738 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &c
);
739 store_unsigned_integer (valbuf
, 2, byte_order
, c
);
740 regcache_cooked_read_unsigned (regcache
, E_RET1_REGNUM
, &c
);
741 store_unsigned_integer (valbuf
+ 2, 2, byte_order
, c
);
743 case 8: /* long long is now 8 bytes. */
744 if (type
->code () == TYPE_CODE_INT
)
746 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &addr
);
747 c
= read_memory_unsigned_integer ((CORE_ADDR
) addr
, len
, byte_order
);
748 store_unsigned_integer (valbuf
, len
, byte_order
, c
);
752 error (_("I don't know how this 8 byte value is returned."));
759 h8300h_extract_return_value (struct type
*type
, struct regcache
*regcache
,
762 struct gdbarch
*gdbarch
= regcache
->arch ();
763 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
766 switch (type
->length ())
771 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &c
);
772 store_unsigned_integer (valbuf
, type
->length (), byte_order
, c
);
774 case 8: /* long long is now 8 bytes. */
775 if (type
->code () == TYPE_CODE_INT
)
777 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &c
);
778 store_unsigned_integer (valbuf
, 4, byte_order
, c
);
779 regcache_cooked_read_unsigned (regcache
, E_RET1_REGNUM
, &c
);
780 store_unsigned_integer (valbuf
+ 4, 4, byte_order
, c
);
784 error (_("I don't know how this 8 byte value is returned."));
791 h8300_use_struct_convention (struct type
*value_type
)
793 /* Types of 1, 2 or 4 bytes are returned in R0/R1, everything else on the
796 if (value_type
->code () == TYPE_CODE_STRUCT
797 || value_type
->code () == TYPE_CODE_UNION
)
799 return !(value_type
->length () == 1
800 || value_type
->length () == 2
801 || value_type
->length () == 4);
805 h8300h_use_struct_convention (struct type
*value_type
)
807 /* Types of 1, 2 or 4 bytes are returned in R0, INT types of 8 bytes are
808 returned in R0/R1, everything else on the stack. */
809 if (value_type
->code () == TYPE_CODE_STRUCT
810 || value_type
->code () == TYPE_CODE_UNION
)
812 return !(value_type
->length () == 1
813 || value_type
->length () == 2
814 || value_type
->length () == 4
815 || (value_type
->length () == 8
816 && value_type
->code () == TYPE_CODE_INT
));
819 /* Function: store_return_value
820 Place the appropriate value in the appropriate registers.
821 Primarily used by the RETURN command. */
824 h8300_store_return_value (struct type
*type
, struct regcache
*regcache
,
825 const gdb_byte
*valbuf
)
827 struct gdbarch
*gdbarch
= regcache
->arch ();
828 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
831 switch (type
->length ())
834 case 2: /* short... */
835 val
= extract_unsigned_integer (valbuf
, type
->length (), byte_order
);
836 regcache_cooked_write_unsigned (regcache
, E_RET0_REGNUM
, val
);
838 case 4: /* long, float */
839 val
= extract_unsigned_integer (valbuf
, type
->length (), byte_order
);
840 regcache_cooked_write_unsigned (regcache
, E_RET0_REGNUM
,
841 (val
>> 16) & 0xffff);
842 regcache_cooked_write_unsigned (regcache
, E_RET1_REGNUM
, val
& 0xffff);
844 case 8: /* long long, double and long double
845 are all defined as 4 byte types so
846 far so this shouldn't happen. */
847 error (_("I don't know how to return an 8 byte value."));
853 h8300h_store_return_value (struct type
*type
, struct regcache
*regcache
,
854 const gdb_byte
*valbuf
)
856 struct gdbarch
*gdbarch
= regcache
->arch ();
857 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
860 switch (type
->length ())
864 case 4: /* long, float */
865 val
= extract_unsigned_integer (valbuf
, type
->length (), byte_order
);
866 regcache_cooked_write_unsigned (regcache
, E_RET0_REGNUM
, val
);
869 val
= extract_unsigned_integer (valbuf
, type
->length (), byte_order
);
870 regcache_cooked_write_unsigned (regcache
, E_RET0_REGNUM
,
871 (val
>> 32) & 0xffffffff);
872 regcache_cooked_write_unsigned (regcache
, E_RET1_REGNUM
,
878 static enum return_value_convention
879 h8300_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
880 struct type
*type
, struct regcache
*regcache
,
881 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
883 if (h8300_use_struct_convention (type
))
884 return RETURN_VALUE_STRUCT_CONVENTION
;
886 h8300_store_return_value (type
, regcache
, writebuf
);
888 h8300_extract_return_value (type
, regcache
, readbuf
);
889 return RETURN_VALUE_REGISTER_CONVENTION
;
892 static enum return_value_convention
893 h8300h_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
894 struct type
*type
, struct regcache
*regcache
,
895 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
897 if (h8300h_use_struct_convention (type
))
903 regcache_raw_read_unsigned (regcache
, E_R0_REGNUM
, &addr
);
904 read_memory (addr
, readbuf
, type
->length ());
907 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
910 h8300h_store_return_value (type
, regcache
, writebuf
);
912 h8300h_extract_return_value (type
, regcache
, readbuf
);
913 return RETURN_VALUE_REGISTER_CONVENTION
;
916 /* Implementation of 'register_sim_regno' gdbarch method. */
919 h8300_register_sim_regno (struct gdbarch
*gdbarch
, int regnum
)
921 /* Only makes sense to supply raw registers. */
922 gdb_assert (regnum
>= 0 && regnum
< gdbarch_num_regs (gdbarch
));
924 /* We hide the raw ccr from the user by making it nameless. Because
925 the default register_sim_regno hook returns
926 LEGACY_SIM_REGNO_IGNORE for unnamed registers, we need to
927 override it. The sim register numbering is compatible with
933 h8300_register_name_common (const char *regnames
[], int numregs
,
934 struct gdbarch
*gdbarch
, int regno
)
938 internal_error (__FILE__
, __LINE__
,
939 _("h8300_register_name_common: illegal register number %d"),
942 return regnames
[regno
];
946 h8300_register_name (struct gdbarch
*gdbarch
, int regno
)
948 /* The register names change depending on which h8300 processor
950 static const char *register_names
[] = {
951 "r0", "r1", "r2", "r3", "r4", "r5", "r6",
952 "sp", "", "pc", "cycles", "tick", "inst",
953 "ccr", /* pseudo register */
955 return h8300_register_name_common(register_names
, ARRAY_SIZE(register_names
),
960 h8300h_register_name (struct gdbarch
*gdbarch
, int regno
)
962 static const char *register_names
[] = {
963 "er0", "er1", "er2", "er3", "er4", "er5", "er6",
964 "sp", "", "pc", "cycles", "tick", "inst",
965 "ccr", /* pseudo register */
967 return h8300_register_name_common(register_names
, ARRAY_SIZE(register_names
),
972 h8300s_register_name (struct gdbarch
*gdbarch
, int regno
)
974 static const char *register_names
[] = {
975 "er0", "er1", "er2", "er3", "er4", "er5", "er6",
976 "sp", "", "pc", "cycles", "", "tick", "inst",
978 "ccr", "exr" /* pseudo registers */
980 return h8300_register_name_common(register_names
, ARRAY_SIZE(register_names
),
985 h8300sx_register_name (struct gdbarch
*gdbarch
, int regno
)
987 static const 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 */
993 return h8300_register_name_common(register_names
, ARRAY_SIZE(register_names
),
998 h8300_print_register (struct gdbarch
*gdbarch
, struct ui_file
*file
,
999 struct frame_info
*frame
, int regno
)
1002 const char *name
= gdbarch_register_name (gdbarch
, regno
);
1004 if (!name
|| !*name
)
1007 rval
= get_frame_register_signed (frame
, regno
);
1009 gdb_printf (file
, "%-14s ", name
);
1010 if ((regno
== E_PSEUDO_CCR_REGNUM (gdbarch
)) || \
1011 (regno
== E_PSEUDO_EXR_REGNUM (gdbarch
) && is_h8300smode (gdbarch
)))
1013 gdb_printf (file
, "0x%02x ", (unsigned char) rval
);
1014 print_longest (file
, 'u', 1, rval
);
1018 gdb_printf (file
, "0x%s ", phex ((ULONGEST
) rval
,
1019 BINWORD (gdbarch
)));
1020 print_longest (file
, 'd', 1, rval
);
1022 if (regno
== E_PSEUDO_CCR_REGNUM (gdbarch
))
1026 unsigned char l
= rval
& 0xff;
1027 gdb_printf (file
, "\t");
1028 gdb_printf (file
, "I-%d ", (l
& 0x80) != 0);
1029 gdb_printf (file
, "UI-%d ", (l
& 0x40) != 0);
1030 gdb_printf (file
, "H-%d ", (l
& 0x20) != 0);
1031 gdb_printf (file
, "U-%d ", (l
& 0x10) != 0);
1036 gdb_printf (file
, "N-%d ", N
);
1037 gdb_printf (file
, "Z-%d ", Z
);
1038 gdb_printf (file
, "V-%d ", V
);
1039 gdb_printf (file
, "C-%d ", C
);
1041 gdb_printf (file
, "u> ");
1043 gdb_printf (file
, "u<= ");
1045 gdb_printf (file
, "u>= ");
1047 gdb_printf (file
, "u< ");
1049 gdb_printf (file
, "!= ");
1051 gdb_printf (file
, "== ");
1053 gdb_printf (file
, ">= ");
1055 gdb_printf (file
, "< ");
1056 if ((Z
| (N
^ V
)) == 0)
1057 gdb_printf (file
, "> ");
1058 if ((Z
| (N
^ V
)) == 1)
1059 gdb_printf (file
, "<= ");
1061 else if (regno
== E_PSEUDO_EXR_REGNUM (gdbarch
) && is_h8300smode (gdbarch
))
1064 unsigned char l
= rval
& 0xff;
1065 gdb_printf (file
, "\t");
1066 gdb_printf (file
, "T-%d - - - ", (l
& 0x80) != 0);
1067 gdb_printf (file
, "I2-%d ", (l
& 4) != 0);
1068 gdb_printf (file
, "I1-%d ", (l
& 2) != 0);
1069 gdb_printf (file
, "I0-%d", (l
& 1) != 0);
1071 gdb_printf (file
, "\n");
1075 h8300_print_registers_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
1076 struct frame_info
*frame
, int regno
, int cpregs
)
1080 for (regno
= E_R0_REGNUM
; regno
<= E_SP_REGNUM
; ++regno
)
1081 h8300_print_register (gdbarch
, file
, frame
, regno
);
1082 h8300_print_register (gdbarch
, file
, frame
,
1083 E_PSEUDO_CCR_REGNUM (gdbarch
));
1084 h8300_print_register (gdbarch
, file
, frame
, E_PC_REGNUM
);
1085 if (is_h8300smode (gdbarch
))
1087 h8300_print_register (gdbarch
, file
, frame
,
1088 E_PSEUDO_EXR_REGNUM (gdbarch
));
1089 if (is_h8300sxmode (gdbarch
))
1091 h8300_print_register (gdbarch
, file
, frame
, E_SBR_REGNUM
);
1092 h8300_print_register (gdbarch
, file
, frame
, E_VBR_REGNUM
);
1094 h8300_print_register (gdbarch
, file
, frame
, E_MACH_REGNUM
);
1095 h8300_print_register (gdbarch
, file
, frame
, E_MACL_REGNUM
);
1096 h8300_print_register (gdbarch
, file
, frame
, E_CYCLES_REGNUM
);
1097 h8300_print_register (gdbarch
, file
, frame
, E_TICKS_REGNUM
);
1098 h8300_print_register (gdbarch
, file
, frame
, E_INSTS_REGNUM
);
1102 h8300_print_register (gdbarch
, file
, frame
, E_CYCLES_REGNUM
);
1103 h8300_print_register (gdbarch
, file
, frame
, E_TICK_REGNUM
);
1104 h8300_print_register (gdbarch
, file
, frame
, E_INST_REGNUM
);
1109 if (regno
== E_CCR_REGNUM
)
1110 h8300_print_register (gdbarch
, file
, frame
,
1111 E_PSEUDO_CCR_REGNUM (gdbarch
));
1112 else if (regno
== E_PSEUDO_EXR_REGNUM (gdbarch
)
1113 && is_h8300smode (gdbarch
))
1114 h8300_print_register (gdbarch
, file
, frame
,
1115 E_PSEUDO_EXR_REGNUM (gdbarch
));
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_cooked_regs (gdbarch
))
1125 internal_error (__FILE__
, __LINE__
,
1126 _("h8300_register_type: illegal register number %d"),
1133 return builtin_type (gdbarch
)->builtin_func_ptr
;
1136 return builtin_type (gdbarch
)->builtin_data_ptr
;
1138 if (regno
== E_PSEUDO_CCR_REGNUM (gdbarch
))
1139 return builtin_type (gdbarch
)->builtin_uint8
;
1140 else if (regno
== E_PSEUDO_EXR_REGNUM (gdbarch
))
1141 return builtin_type (gdbarch
)->builtin_uint8
;
1142 else if (is_h8300hmode (gdbarch
))
1143 return builtin_type (gdbarch
)->builtin_int32
;
1145 return builtin_type (gdbarch
)->builtin_int16
;
1150 /* Helpers for h8300_pseudo_register_read. We expose ccr/exr as
1151 pseudo-registers to users with smaller sizes than the corresponding
1152 raw registers. These helpers extend/narrow the values. */
1154 static enum register_status
1155 pseudo_from_raw_register (struct gdbarch
*gdbarch
, readable_regcache
*regcache
,
1156 gdb_byte
*buf
, int pseudo_regno
, int raw_regno
)
1158 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1159 enum register_status status
;
1162 status
= regcache
->raw_read (raw_regno
, &val
);
1163 if (status
== REG_VALID
)
1164 store_unsigned_integer (buf
,
1165 register_size (gdbarch
, pseudo_regno
),
1170 /* See pseudo_from_raw_register. */
1173 raw_from_pseudo_register (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
1174 const gdb_byte
*buf
, int raw_regno
, int pseudo_regno
)
1176 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1179 val
= extract_unsigned_integer (buf
, register_size (gdbarch
, pseudo_regno
),
1181 regcache_raw_write_unsigned (regcache
, raw_regno
, val
);
1184 static enum register_status
1185 h8300_pseudo_register_read (struct gdbarch
*gdbarch
,
1186 readable_regcache
*regcache
, int regno
,
1189 if (regno
== E_PSEUDO_CCR_REGNUM (gdbarch
))
1191 return pseudo_from_raw_register (gdbarch
, regcache
, buf
,
1192 regno
, E_CCR_REGNUM
);
1194 else if (regno
== E_PSEUDO_EXR_REGNUM (gdbarch
))
1196 return pseudo_from_raw_register (gdbarch
, regcache
, buf
,
1197 regno
, E_EXR_REGNUM
);
1200 return regcache
->raw_read (regno
, buf
);
1204 h8300_pseudo_register_write (struct gdbarch
*gdbarch
,
1205 struct regcache
*regcache
, int regno
,
1206 const gdb_byte
*buf
)
1208 if (regno
== E_PSEUDO_CCR_REGNUM (gdbarch
))
1209 raw_from_pseudo_register (gdbarch
, regcache
, buf
, E_CCR_REGNUM
, regno
);
1210 else if (regno
== E_PSEUDO_EXR_REGNUM (gdbarch
))
1211 raw_from_pseudo_register (gdbarch
, regcache
, buf
, E_EXR_REGNUM
, regno
);
1213 regcache
->raw_write (regno
, buf
);
1217 h8300_dbg_reg_to_regnum (struct gdbarch
*gdbarch
, int regno
)
1219 if (regno
== E_CCR_REGNUM
)
1220 return E_PSEUDO_CCR_REGNUM (gdbarch
);
1225 h8300s_dbg_reg_to_regnum (struct gdbarch
*gdbarch
, int regno
)
1227 if (regno
== E_CCR_REGNUM
)
1228 return E_PSEUDO_CCR_REGNUM (gdbarch
);
1229 if (regno
== E_EXR_REGNUM
)
1230 return E_PSEUDO_EXR_REGNUM (gdbarch
);
1234 /*static unsigned char breakpoint[] = { 0x7A, 0xFF }; *//* ??? */
1235 constexpr gdb_byte h8300_break_insn
[] = { 0x01, 0x80 }; /* Sleep */
1237 typedef BP_MANIPULATION (h8300_break_insn
) h8300_breakpoint
;
1239 static struct gdbarch
*
1240 h8300_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1242 struct gdbarch
*gdbarch
;
1244 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1246 return arches
->gdbarch
;
1248 if (info
.bfd_arch_info
->arch
!= bfd_arch_h8300
)
1251 gdbarch
= gdbarch_alloc (&info
, 0);
1253 set_gdbarch_register_sim_regno (gdbarch
, h8300_register_sim_regno
);
1255 switch (info
.bfd_arch_info
->mach
)
1257 case bfd_mach_h8300
:
1258 set_gdbarch_num_regs (gdbarch
, 13);
1259 set_gdbarch_num_pseudo_regs (gdbarch
, 1);
1260 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1261 set_gdbarch_stab_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1262 set_gdbarch_register_name (gdbarch
, h8300_register_name
);
1263 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1264 set_gdbarch_addr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1265 set_gdbarch_return_value (gdbarch
, h8300_return_value
);
1267 case bfd_mach_h8300h
:
1268 case bfd_mach_h8300hn
:
1269 set_gdbarch_num_regs (gdbarch
, 13);
1270 set_gdbarch_num_pseudo_regs (gdbarch
, 1);
1271 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1272 set_gdbarch_stab_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1273 set_gdbarch_register_name (gdbarch
, h8300h_register_name
);
1274 if (info
.bfd_arch_info
->mach
!= bfd_mach_h8300hn
)
1276 set_gdbarch_ptr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1277 set_gdbarch_addr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1281 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1282 set_gdbarch_addr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1284 set_gdbarch_return_value (gdbarch
, h8300h_return_value
);
1286 case bfd_mach_h8300s
:
1287 case bfd_mach_h8300sn
:
1288 set_gdbarch_num_regs (gdbarch
, 16);
1289 set_gdbarch_num_pseudo_regs (gdbarch
, 2);
1290 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1291 set_gdbarch_stab_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1292 set_gdbarch_register_name (gdbarch
, h8300s_register_name
);
1293 if (info
.bfd_arch_info
->mach
!= bfd_mach_h8300sn
)
1295 set_gdbarch_ptr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1296 set_gdbarch_addr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1300 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1301 set_gdbarch_addr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1303 set_gdbarch_return_value (gdbarch
, h8300h_return_value
);
1305 case bfd_mach_h8300sx
:
1306 case bfd_mach_h8300sxn
:
1307 set_gdbarch_num_regs (gdbarch
, 18);
1308 set_gdbarch_num_pseudo_regs (gdbarch
, 2);
1309 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1310 set_gdbarch_stab_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1311 set_gdbarch_register_name (gdbarch
, h8300sx_register_name
);
1312 if (info
.bfd_arch_info
->mach
!= bfd_mach_h8300sxn
)
1314 set_gdbarch_ptr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1315 set_gdbarch_addr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1319 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1320 set_gdbarch_addr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1322 set_gdbarch_return_value (gdbarch
, h8300h_return_value
);
1326 set_gdbarch_pseudo_register_read (gdbarch
, h8300_pseudo_register_read
);
1327 set_gdbarch_pseudo_register_write (gdbarch
, h8300_pseudo_register_write
);
1330 * Basic register fields and methods.
1333 set_gdbarch_sp_regnum (gdbarch
, E_SP_REGNUM
);
1334 set_gdbarch_pc_regnum (gdbarch
, E_PC_REGNUM
);
1335 set_gdbarch_register_type (gdbarch
, h8300_register_type
);
1336 set_gdbarch_print_registers_info (gdbarch
, h8300_print_registers_info
);
1341 set_gdbarch_skip_prologue (gdbarch
, h8300_skip_prologue
);
1343 /* Frame unwinder. */
1344 frame_base_set_default (gdbarch
, &h8300_frame_base
);
1349 /* Stack grows up. */
1350 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1352 set_gdbarch_breakpoint_kind_from_pc (gdbarch
,
1353 h8300_breakpoint::kind_from_pc
);
1354 set_gdbarch_sw_breakpoint_from_kind (gdbarch
,
1355 h8300_breakpoint::bp_from_kind
);
1356 set_gdbarch_push_dummy_call (gdbarch
, h8300_push_dummy_call
);
1358 set_gdbarch_char_signed (gdbarch
, 0);
1359 set_gdbarch_int_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1360 set_gdbarch_long_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1361 set_gdbarch_long_long_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
1363 set_gdbarch_wchar_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1364 set_gdbarch_wchar_signed (gdbarch
, 0);
1366 set_gdbarch_double_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1367 set_gdbarch_double_format (gdbarch
, floatformats_ieee_single
);
1368 set_gdbarch_long_double_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1369 set_gdbarch_long_double_format (gdbarch
, floatformats_ieee_single
);
1371 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
1373 /* Hook in the DWARF CFI frame unwinder. */
1374 dwarf2_append_unwinders (gdbarch
);
1375 frame_unwind_append_unwinder (gdbarch
, &h8300_frame_unwind
);
1381 void _initialize_h8300_tdep ();
1383 _initialize_h8300_tdep ()
1385 gdbarch_register (bfd_arch_h8300
, h8300_gdbarch_init
);
1389 is_h8300hmode (struct gdbarch
*gdbarch
)
1391 return gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sx
1392 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sxn
1393 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300s
1394 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sn
1395 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300h
1396 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300hn
;
1400 is_h8300smode (struct gdbarch
*gdbarch
)
1402 return gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sx
1403 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sxn
1404 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300s
1405 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sn
;
1409 is_h8300sxmode (struct gdbarch
*gdbarch
)
1411 return gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sx
1412 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sxn
;
1416 is_h8300_normal_mode (struct gdbarch
*gdbarch
)
1418 return gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sxn
1419 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sn
1420 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300hn
;