1 /* Target-machine dependent code for Renesas H8/300, for GDB.
3 Copyright (C) 1988, 1990-1996, 1998-2003, 2005, 2007-2012 Free
4 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) (gdbarch_num_regs (gdbarch))
64 #define E_PSEUDO_EXR_REGNUM(gdbarch) (gdbarch_num_regs (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(gdbarch) ((is_h8300hmode (gdbarch) \
94 && !is_h8300_normal_mode (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_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
112 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, E_SP_REGNUM
);
113 return frame_id_build (sp
, get_frame_pc (this_frame
));
118 /* Allocate and initialize a frame cache. */
121 h8300_init_frame_cache (struct gdbarch
*gdbarch
,
122 struct h8300_frame_cache
*cache
)
128 cache
->sp_offset
= 0;
131 /* Frameless until proven otherwise. */
134 /* Saved registers. We initialize these to -1 since zero is a valid
135 offset (that's where %fp is supposed to be stored). */
136 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
137 cache
->saved_regs
[i
] = -1;
140 #define IS_MOVB_RnRm(x) (((x) & 0xff88) == 0x0c88)
141 #define IS_MOVW_RnRm(x) (((x) & 0xff88) == 0x0d00)
142 #define IS_MOVL_RnRm(x) (((x) & 0xff88) == 0x0f80)
143 #define IS_MOVB_Rn16_SP(x) (((x) & 0xfff0) == 0x6ee0)
144 #define IS_MOVB_EXT(x) ((x) == 0x7860)
145 #define IS_MOVB_Rn24_SP(x) (((x) & 0xfff0) == 0x6aa0)
146 #define IS_MOVW_Rn16_SP(x) (((x) & 0xfff0) == 0x6fe0)
147 #define IS_MOVW_EXT(x) ((x) == 0x78e0)
148 #define IS_MOVW_Rn24_SP(x) (((x) & 0xfff0) == 0x6ba0)
149 /* Same instructions as mov.w, just prefixed with 0x0100. */
150 #define IS_MOVL_PRE(x) ((x) == 0x0100)
151 #define IS_MOVL_Rn16_SP(x) (((x) & 0xfff0) == 0x6fe0)
152 #define IS_MOVL_EXT(x) ((x) == 0x78e0)
153 #define IS_MOVL_Rn24_SP(x) (((x) & 0xfff0) == 0x6ba0)
155 #define IS_PUSHFP_MOVESPFP(x) ((x) == 0x6df60d76)
156 #define IS_PUSH_FP(x) ((x) == 0x01006df6)
157 #define IS_MOV_SP_FP(x) ((x) == 0x0ff6)
158 #define IS_SUB2_SP(x) ((x) == 0x1b87)
159 #define IS_SUB4_SP(x) ((x) == 0x1b97)
160 #define IS_ADD_IMM_SP(x) ((x) == 0x7a1f)
161 #define IS_SUB_IMM_SP(x) ((x) == 0x7a3f)
162 #define IS_SUBL4_SP(x) ((x) == 0x1acf)
163 #define IS_MOV_IMM_Rn(x) (((x) & 0xfff0) == 0x7905)
164 #define IS_SUB_RnSP(x) (((x) & 0xff0f) == 0x1907)
165 #define IS_ADD_RnSP(x) (((x) & 0xff0f) == 0x0907)
166 #define IS_PUSH(x) (((x) & 0xfff0) == 0x6df0)
168 /* If the instruction at PC is an argument register spill, return its
169 length. Otherwise, return zero.
171 An argument register spill is an instruction that moves an argument
172 from the register in which it was passed to the stack slot in which
173 it really lives. It is a byte, word, or longword move from an
174 argument register to a negative offset from the frame pointer.
176 CV, 2003-06-16: Or, in optimized code or when the `register' qualifier
177 is used, it could be a byte, word or long move to registers r3-r5. */
180 h8300_is_argument_spill (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
182 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
183 int w
= read_memory_unsigned_integer (pc
, 2, byte_order
);
185 if ((IS_MOVB_RnRm (w
) || IS_MOVW_RnRm (w
) || IS_MOVL_RnRm (w
))
186 && (w
& 0x70) <= 0x20 /* Rs is R0, R1 or R2 */
187 && (w
& 0x7) >= 0x3 && (w
& 0x7) <= 0x5) /* Rd is R3, R4 or R5 */
190 if (IS_MOVB_Rn16_SP (w
)
191 && 8 <= (w
& 0xf) && (w
& 0xf) <= 10) /* Rs is R0L, R1L, or R2L */
193 /* ... and d:16 is negative. */
194 if (read_memory_integer (pc
+ 2, 2, byte_order
) < 0)
197 else if (IS_MOVB_EXT (w
))
199 if (IS_MOVB_Rn24_SP (read_memory_unsigned_integer (pc
+ 2,
202 LONGEST disp
= read_memory_integer (pc
+ 4, 4, byte_order
);
204 /* ... and d:24 is negative. */
205 if (disp
< 0 && disp
> 0xffffff)
209 else if (IS_MOVW_Rn16_SP (w
)
210 && (w
& 0xf) <= 2) /* Rs is R0, R1, or R2 */
212 /* ... and d:16 is negative. */
213 if (read_memory_integer (pc
+ 2, 2, byte_order
) < 0)
216 else if (IS_MOVW_EXT (w
))
218 if (IS_MOVW_Rn24_SP (read_memory_unsigned_integer (pc
+ 2,
221 LONGEST disp
= read_memory_integer (pc
+ 4, 4, byte_order
);
223 /* ... and d:24 is negative. */
224 if (disp
< 0 && disp
> 0xffffff)
228 else if (IS_MOVL_PRE (w
))
230 int w2
= read_memory_integer (pc
+ 2, 2, byte_order
);
232 if (IS_MOVL_Rn16_SP (w2
)
233 && (w2
& 0xf) <= 2) /* Rs is ER0, ER1, or ER2 */
235 /* ... and d:16 is negative. */
236 if (read_memory_integer (pc
+ 4, 2, byte_order
) < 0)
239 else if (IS_MOVL_EXT (w2
))
241 int w3
= read_memory_integer (pc
+ 4, 2, byte_order
);
243 if (IS_MOVL_Rn24_SP (read_memory_integer (pc
+ 4, 2, byte_order
)))
245 LONGEST disp
= read_memory_integer (pc
+ 6, 4, byte_order
);
247 /* ... and d:24 is negative. */
248 if (disp
< 0 && disp
> 0xffffff)
257 /* Do a full analysis of the prologue at PC and update CACHE
258 accordingly. Bail out early if CURRENT_PC is reached. Return the
259 address where the analysis stopped.
261 We handle all cases that can be generated by gcc.
263 For allocating a stack frame:
284 For saving registers:
293 h8300_analyze_prologue (struct gdbarch
*gdbarch
,
294 CORE_ADDR pc
, CORE_ADDR current_pc
,
295 struct h8300_frame_cache
*cache
)
297 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
299 int regno
, i
, spill_size
;
301 cache
->sp_offset
= 0;
303 if (pc
>= current_pc
)
306 op
= read_memory_unsigned_integer (pc
, 4, byte_order
);
308 if (IS_PUSHFP_MOVESPFP (op
))
310 cache
->saved_regs
[E_FP_REGNUM
] = 0;
314 else if (IS_PUSH_FP (op
))
316 cache
->saved_regs
[E_FP_REGNUM
] = 0;
318 if (pc
>= current_pc
)
320 op
= read_memory_unsigned_integer (pc
, 2, byte_order
);
321 if (IS_MOV_SP_FP (op
))
328 while (pc
< current_pc
)
330 op
= read_memory_unsigned_integer (pc
, 2, byte_order
);
333 cache
->sp_offset
+= 2;
336 else if (IS_SUB4_SP (op
))
338 cache
->sp_offset
+= 4;
341 else if (IS_ADD_IMM_SP (op
))
343 cache
->sp_offset
+= -read_memory_integer (pc
+ 2, 2, byte_order
);
346 else if (IS_SUB_IMM_SP (op
))
348 cache
->sp_offset
+= read_memory_integer (pc
+ 2, 2, byte_order
);
351 else if (IS_SUBL4_SP (op
))
353 cache
->sp_offset
+= 4;
356 else if (IS_MOV_IMM_Rn (op
))
358 int offset
= read_memory_integer (pc
+ 2, 2, byte_order
);
360 op
= read_memory_unsigned_integer (pc
+ 4, 2, byte_order
);
361 if (IS_ADD_RnSP (op
) && (op
& 0x00f0) == regno
)
363 cache
->sp_offset
-= offset
;
366 else if (IS_SUB_RnSP (op
) && (op
& 0x00f0) == regno
)
368 cache
->sp_offset
+= offset
;
374 else if (IS_PUSH (op
))
377 cache
->sp_offset
+= 2;
378 cache
->saved_regs
[regno
] = cache
->sp_offset
;
381 else if (op
== 0x0100)
383 op
= read_memory_unsigned_integer (pc
+ 2, 2, byte_order
);
387 cache
->sp_offset
+= 4;
388 cache
->saved_regs
[regno
] = cache
->sp_offset
;
394 else if ((op
& 0xffcf) == 0x0100)
397 op1
= read_memory_unsigned_integer (pc
+ 2, 2, byte_order
);
400 /* Since the prefix is 0x01x0, this is not a simple pushm but a
401 stm.l reglist,@-sp */
402 i
= ((op
& 0x0030) >> 4) + 1;
403 regno
= op1
& 0x000f;
404 for (; i
> 0; regno
++, --i
)
406 cache
->sp_offset
+= 4;
407 cache
->saved_regs
[regno
] = cache
->sp_offset
;
418 /* Check for spilling an argument register to the stack frame.
419 This could also be an initializing store from non-prologue code,
420 but I don't think there's any harm in skipping that. */
421 while ((spill_size
= h8300_is_argument_spill (gdbarch
, pc
)) > 0
422 && pc
+ spill_size
<= current_pc
)
428 static struct h8300_frame_cache
*
429 h8300_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
431 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
432 struct h8300_frame_cache
*cache
;
434 CORE_ADDR current_pc
;
439 cache
= FRAME_OBSTACK_ZALLOC (struct h8300_frame_cache
);
440 h8300_init_frame_cache (gdbarch
, cache
);
443 /* In principle, for normal frames, %fp holds the frame pointer,
444 which holds the base address for the current stack frame.
445 However, for functions that don't need it, the frame pointer is
446 optional. For these "frameless" functions the frame pointer is
447 actually the frame pointer of the calling frame. */
449 cache
->base
= get_frame_register_unsigned (this_frame
, E_FP_REGNUM
);
450 if (cache
->base
== 0)
453 cache
->saved_regs
[E_PC_REGNUM
] = -BINWORD (gdbarch
);
455 cache
->pc
= get_frame_func (this_frame
);
456 current_pc
= get_frame_pc (this_frame
);
458 h8300_analyze_prologue (gdbarch
, cache
->pc
, current_pc
, cache
);
462 /* We didn't find a valid frame, which means that CACHE->base
463 currently holds the frame pointer for our calling frame. If
464 we're at the start of a function, or somewhere half-way its
465 prologue, the function's frame probably hasn't been fully
466 setup yet. Try to reconstruct the base address for the stack
467 frame by looking at the stack pointer. For truly "frameless"
468 functions this might work too. */
470 cache
->base
= get_frame_register_unsigned (this_frame
, E_SP_REGNUM
)
472 cache
->saved_sp
= cache
->base
+ BINWORD (gdbarch
);
473 cache
->saved_regs
[E_PC_REGNUM
] = 0;
477 cache
->saved_sp
= cache
->base
+ 2 * BINWORD (gdbarch
);
478 cache
->saved_regs
[E_PC_REGNUM
] = -BINWORD (gdbarch
);
481 /* Adjust all the saved registers such that they contain addresses
482 instead of offsets. */
483 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
484 if (cache
->saved_regs
[i
] != -1)
485 cache
->saved_regs
[i
] = cache
->base
- cache
->saved_regs
[i
];
491 h8300_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
492 struct frame_id
*this_id
)
494 struct h8300_frame_cache
*cache
=
495 h8300_frame_cache (this_frame
, this_cache
);
497 /* This marks the outermost frame. */
498 if (cache
->base
== 0)
501 *this_id
= frame_id_build (cache
->saved_sp
, cache
->pc
);
504 static struct value
*
505 h8300_frame_prev_register (struct frame_info
*this_frame
, void **this_cache
,
508 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
509 struct h8300_frame_cache
*cache
=
510 h8300_frame_cache (this_frame
, this_cache
);
512 gdb_assert (regnum
>= 0);
514 if (regnum
== E_SP_REGNUM
&& cache
->saved_sp
)
515 return frame_unwind_got_constant (this_frame
, regnum
, cache
->saved_sp
);
517 if (regnum
< gdbarch_num_regs (gdbarch
)
518 && cache
->saved_regs
[regnum
] != -1)
519 return frame_unwind_got_memory (this_frame
, regnum
,
520 cache
->saved_regs
[regnum
]);
522 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
525 static const struct frame_unwind h8300_frame_unwind
= {
527 default_frame_unwind_stop_reason
,
529 h8300_frame_prev_register
,
531 default_frame_sniffer
535 h8300_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
537 struct h8300_frame_cache
*cache
= h8300_frame_cache (this_frame
, this_cache
);
541 static const struct frame_base h8300_frame_base
= {
543 h8300_frame_base_address
,
544 h8300_frame_base_address
,
545 h8300_frame_base_address
549 h8300_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
551 CORE_ADDR func_addr
= 0 , func_end
= 0;
553 if (find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
555 struct symtab_and_line sal
;
556 struct h8300_frame_cache cache
;
558 /* Found a function. */
559 sal
= find_pc_line (func_addr
, 0);
560 if (sal
.end
&& sal
.end
< func_end
)
561 /* Found a line number, use it as end of prologue. */
564 /* No useable line symbol. Use prologue parsing method. */
565 h8300_init_frame_cache (gdbarch
, &cache
);
566 return h8300_analyze_prologue (gdbarch
, func_addr
, func_end
, &cache
);
569 /* No function symbol -- just return the PC. */
570 return (CORE_ADDR
) pc
;
573 /* Function: push_dummy_call
574 Setup the function arguments for calling a function in the inferior.
575 In this discussion, a `word' is 16 bits on the H8/300s, and 32 bits
578 There are actually two ABI's here: -mquickcall (the default) and
579 -mno-quickcall. With -mno-quickcall, all arguments are passed on
580 the stack after the return address, word-aligned. With
581 -mquickcall, GCC tries to use r0 -- r2 to pass registers. Since
582 GCC doesn't indicate in the object file which ABI was used to
583 compile it, GDB only supports the default --- -mquickcall.
585 Here are the rules for -mquickcall, in detail:
587 Each argument, whether scalar or aggregate, is padded to occupy a
588 whole number of words. Arguments smaller than a word are padded at
589 the most significant end; those larger than a word are padded at
590 the least significant end.
592 The initial arguments are passed in r0 -- r2. Earlier arguments go in
593 lower-numbered registers. Multi-word arguments are passed in
594 consecutive registers, with the most significant end in the
595 lower-numbered register.
597 If an argument doesn't fit entirely in the remaining registers, it
598 is passed entirely on the stack. Stack arguments begin just after
599 the return address. Once an argument has overflowed onto the stack
600 this way, all subsequent arguments are passed on the stack.
602 The above rule has odd consequences. For example, on the h8/300s,
603 if a function takes two longs and an int as arguments:
604 - the first long will be passed in r0/r1,
605 - the second long will be passed entirely on the stack, since it
607 - and the int will be passed on the stack, even though it could fit
610 A weird exception: if an argument is larger than a word, but not a
611 whole number of words in length (before padding), it is passed on
612 the stack following the rules for stack arguments above, even if
613 there are sufficient registers available to hold it. Stranger
614 still, the argument registers are still `used up' --- even though
615 there's nothing in them.
617 So, for example, on the h8/300s, if a function expects a three-byte
618 structure and an int, the structure will go on the stack, and the
619 int will go in r2, not r0.
621 If the function returns an aggregate type (struct, union, or class)
622 by value, the caller must allocate space to hold the return value,
623 and pass the callee a pointer to this space as an invisible first
626 For varargs functions, the last fixed argument and all the variable
627 arguments are always passed on the stack. This means that calls to
628 varargs functions don't work properly unless there is a prototype
631 Basically, this ABI is not good, for the following reasons:
632 - You can't call vararg functions properly unless a prototype is in scope.
633 - Structure passing is inconsistent, to no purpose I can see.
634 - It often wastes argument registers, of which there are only three
638 h8300_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
639 struct regcache
*regcache
, CORE_ADDR bp_addr
,
640 int nargs
, struct value
**args
, CORE_ADDR sp
,
641 int struct_return
, CORE_ADDR struct_addr
)
643 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
644 int stack_alloc
= 0, stack_offset
= 0;
645 int wordsize
= BINWORD (gdbarch
);
646 int reg
= E_ARG0_REGNUM
;
649 /* First, make sure the stack is properly aligned. */
650 sp
= align_down (sp
, wordsize
);
652 /* Now make sure there's space on the stack for the arguments. We
653 may over-allocate a little here, but that won't hurt anything. */
654 for (argument
= 0; argument
< nargs
; argument
++)
655 stack_alloc
+= align_up (TYPE_LENGTH (value_type (args
[argument
])),
659 /* Now load as many arguments as possible into registers, and push
660 the rest onto the stack.
661 If we're returning a structure by value, then we must pass a
662 pointer to the buffer for the return value as an invisible first
665 regcache_cooked_write_unsigned (regcache
, reg
++, struct_addr
);
667 for (argument
= 0; argument
< nargs
; argument
++)
669 struct cleanup
*back_to
;
670 struct type
*type
= value_type (args
[argument
]);
671 int len
= TYPE_LENGTH (type
);
672 char *contents
= (char *) value_contents (args
[argument
]);
674 /* Pad the argument appropriately. */
675 int padded_len
= align_up (len
, wordsize
);
676 gdb_byte
*padded
= xmalloc (padded_len
);
677 back_to
= make_cleanup (xfree
, padded
);
679 memset (padded
, 0, padded_len
);
680 memcpy (len
< wordsize
? padded
+ padded_len
- len
: padded
,
683 /* Could the argument fit in the remaining registers? */
684 if (padded_len
<= (E_ARGLAST_REGNUM
- reg
+ 1) * wordsize
)
686 /* Are we going to pass it on the stack anyway, for no good
688 if (len
> wordsize
&& len
% wordsize
)
690 /* I feel so unclean. */
691 write_memory (sp
+ stack_offset
, padded
, padded_len
);
692 stack_offset
+= padded_len
;
694 /* That's right --- even though we passed the argument
695 on the stack, we consume the registers anyway! Love
697 reg
+= padded_len
/ wordsize
;
701 /* Heavens to Betsy --- it's really going in registers!
702 Note that on the h8/300s, there are gaps between the
703 registers in the register file. */
706 for (offset
= 0; offset
< padded_len
; offset
+= wordsize
)
709 = extract_unsigned_integer (padded
+ offset
,
710 wordsize
, byte_order
);
711 regcache_cooked_write_unsigned (regcache
, reg
++, word
);
717 /* It doesn't fit in registers! Onto the stack it goes. */
718 write_memory (sp
+ stack_offset
, padded
, padded_len
);
719 stack_offset
+= padded_len
;
721 /* Once one argument has spilled onto the stack, all
722 subsequent arguments go on the stack. */
723 reg
= E_ARGLAST_REGNUM
+ 1;
726 do_cleanups (back_to
);
729 /* Store return address. */
731 write_memory_unsigned_integer (sp
, wordsize
, byte_order
, bp_addr
);
733 /* Update stack pointer. */
734 regcache_cooked_write_unsigned (regcache
, E_SP_REGNUM
, sp
);
736 /* Return the new stack pointer minus the return address slot since
737 that's what DWARF2/GCC uses as the frame's CFA. */
738 return sp
+ wordsize
;
741 /* Function: extract_return_value
742 Figure out where in REGBUF the called function has left its return value.
743 Copy that into VALBUF. Be sure to account for CPU type. */
746 h8300_extract_return_value (struct type
*type
, struct regcache
*regcache
,
749 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
750 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
751 int len
= TYPE_LENGTH (type
);
754 switch (TYPE_LENGTH (type
))
758 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &c
);
759 store_unsigned_integer (valbuf
, TYPE_LENGTH (type
), byte_order
, c
);
761 case 4: /* Needs two registers on plain H8/300 */
762 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &c
);
763 store_unsigned_integer (valbuf
, 2, byte_order
, c
);
764 regcache_cooked_read_unsigned (regcache
, E_RET1_REGNUM
, &c
);
765 store_unsigned_integer ((void *)((char *) valbuf
+ 2), 2, byte_order
, c
);
767 case 8: /* long long is now 8 bytes. */
768 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
770 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &addr
);
771 c
= read_memory_unsigned_integer ((CORE_ADDR
) addr
,
772 TYPE_LENGTH (type
), byte_order
);
773 store_unsigned_integer (valbuf
, TYPE_LENGTH (type
), byte_order
, c
);
777 error (_("I don't know how this 8 byte value is returned."));
784 h8300h_extract_return_value (struct type
*type
, struct regcache
*regcache
,
787 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
788 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
791 switch (TYPE_LENGTH (type
))
796 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &c
);
797 store_unsigned_integer (valbuf
, TYPE_LENGTH (type
), byte_order
, c
);
799 case 8: /* long long is now 8 bytes. */
800 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
802 regcache_cooked_read_unsigned (regcache
, E_RET0_REGNUM
, &c
);
803 store_unsigned_integer (valbuf
, 4, byte_order
, c
);
804 regcache_cooked_read_unsigned (regcache
, E_RET1_REGNUM
, &c
);
805 store_unsigned_integer ((void *) ((char *) valbuf
+ 4), 4,
810 error (_("I don't know how this 8 byte value is returned."));
817 h8300_use_struct_convention (struct type
*value_type
)
819 /* Types of 1, 2 or 4 bytes are returned in R0/R1, everything else on the
822 if (TYPE_CODE (value_type
) == TYPE_CODE_STRUCT
823 || TYPE_CODE (value_type
) == TYPE_CODE_UNION
)
825 return !(TYPE_LENGTH (value_type
) == 1
826 || TYPE_LENGTH (value_type
) == 2
827 || TYPE_LENGTH (value_type
) == 4);
831 h8300h_use_struct_convention (struct type
*value_type
)
833 /* Types of 1, 2 or 4 bytes are returned in R0, INT types of 8 bytes are
834 returned in R0/R1, everything else on the stack. */
835 if (TYPE_CODE (value_type
) == TYPE_CODE_STRUCT
836 || TYPE_CODE (value_type
) == TYPE_CODE_UNION
)
838 return !(TYPE_LENGTH (value_type
) == 1
839 || TYPE_LENGTH (value_type
) == 2
840 || TYPE_LENGTH (value_type
) == 4
841 || (TYPE_LENGTH (value_type
) == 8
842 && TYPE_CODE (value_type
) == TYPE_CODE_INT
));
845 /* Function: store_return_value
846 Place the appropriate value in the appropriate registers.
847 Primarily used by the RETURN command. */
850 h8300_store_return_value (struct type
*type
, struct regcache
*regcache
,
853 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
854 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
857 switch (TYPE_LENGTH (type
))
860 case 2: /* short... */
861 val
= extract_unsigned_integer (valbuf
, TYPE_LENGTH (type
), byte_order
);
862 regcache_cooked_write_unsigned (regcache
, E_RET0_REGNUM
, val
);
864 case 4: /* long, float */
865 val
= extract_unsigned_integer (valbuf
, TYPE_LENGTH (type
), byte_order
);
866 regcache_cooked_write_unsigned (regcache
, E_RET0_REGNUM
,
867 (val
>> 16) & 0xffff);
868 regcache_cooked_write_unsigned (regcache
, E_RET1_REGNUM
, val
& 0xffff);
870 case 8: /* long long, double and long double
871 are all defined as 4 byte types so
872 far so this shouldn't happen. */
873 error (_("I don't know how to return an 8 byte value."));
879 h8300h_store_return_value (struct type
*type
, struct regcache
*regcache
,
882 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
883 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
886 switch (TYPE_LENGTH (type
))
890 case 4: /* long, float */
891 val
= extract_unsigned_integer (valbuf
, TYPE_LENGTH (type
), byte_order
);
892 regcache_cooked_write_unsigned (regcache
, E_RET0_REGNUM
, val
);
895 val
= extract_unsigned_integer (valbuf
, TYPE_LENGTH (type
), byte_order
);
896 regcache_cooked_write_unsigned (regcache
, E_RET0_REGNUM
,
897 (val
>> 32) & 0xffffffff);
898 regcache_cooked_write_unsigned (regcache
, E_RET1_REGNUM
,
904 static enum return_value_convention
905 h8300_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
906 struct type
*type
, struct regcache
*regcache
,
907 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
909 if (h8300_use_struct_convention (type
))
910 return RETURN_VALUE_STRUCT_CONVENTION
;
912 h8300_store_return_value (type
, regcache
, writebuf
);
914 h8300_extract_return_value (type
, regcache
, readbuf
);
915 return RETURN_VALUE_REGISTER_CONVENTION
;
918 static enum return_value_convention
919 h8300h_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
920 struct type
*type
, struct regcache
*regcache
,
921 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
923 if (h8300h_use_struct_convention (type
))
929 regcache_raw_read_unsigned (regcache
, E_R0_REGNUM
, &addr
);
930 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
933 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
936 h8300h_store_return_value (type
, regcache
, writebuf
);
938 h8300h_extract_return_value (type
, regcache
, readbuf
);
939 return RETURN_VALUE_REGISTER_CONVENTION
;
942 static struct cmd_list_element
*setmachinelist
;
945 h8300_register_name (struct gdbarch
*gdbarch
, int regno
)
947 /* The register names change depending on which h8300 processor
949 static char *register_names
[] = {
950 "r0", "r1", "r2", "r3", "r4", "r5", "r6",
951 "sp", "", "pc", "cycles", "tick", "inst",
952 "ccr", /* pseudo register */
955 || regno
>= (sizeof (register_names
) / sizeof (*register_names
)))
956 internal_error (__FILE__
, __LINE__
,
957 _("h8300_register_name: illegal register number %d"),
960 return register_names
[regno
];
964 h8300s_register_name (struct gdbarch
*gdbarch
, int regno
)
966 static char *register_names
[] = {
967 "er0", "er1", "er2", "er3", "er4", "er5", "er6",
968 "sp", "", "pc", "cycles", "", "tick", "inst",
970 "ccr", "exr" /* pseudo registers */
973 || regno
>= (sizeof (register_names
) / sizeof (*register_names
)))
974 internal_error (__FILE__
, __LINE__
,
975 _("h8300s_register_name: illegal register number %d"),
978 return register_names
[regno
];
982 h8300sx_register_name (struct gdbarch
*gdbarch
, int regno
)
984 static char *register_names
[] = {
985 "er0", "er1", "er2", "er3", "er4", "er5", "er6",
986 "sp", "", "pc", "cycles", "", "tick", "inst",
987 "mach", "macl", "sbr", "vbr",
988 "ccr", "exr" /* pseudo registers */
991 || regno
>= (sizeof (register_names
) / sizeof (*register_names
)))
992 internal_error (__FILE__
, __LINE__
,
993 _("h8300sx_register_name: illegal register number %d"),
996 return register_names
[regno
];
1000 h8300_print_register (struct gdbarch
*gdbarch
, struct ui_file
*file
,
1001 struct frame_info
*frame
, int regno
)
1004 const char *name
= gdbarch_register_name (gdbarch
, regno
);
1006 if (!name
|| !*name
)
1009 rval
= get_frame_register_signed (frame
, regno
);
1011 fprintf_filtered (file
, "%-14s ", name
);
1012 if ((regno
== E_PSEUDO_CCR_REGNUM (gdbarch
)) || \
1013 (regno
== E_PSEUDO_EXR_REGNUM (gdbarch
) && is_h8300smode (gdbarch
)))
1015 fprintf_filtered (file
, "0x%02x ", (unsigned char) rval
);
1016 print_longest (file
, 'u', 1, rval
);
1020 fprintf_filtered (file
, "0x%s ", phex ((ULONGEST
) rval
,
1021 BINWORD (gdbarch
)));
1022 print_longest (file
, 'd', 1, rval
);
1024 if (regno
== E_PSEUDO_CCR_REGNUM (gdbarch
))
1028 unsigned char l
= rval
& 0xff;
1029 fprintf_filtered (file
, "\t");
1030 fprintf_filtered (file
, "I-%d ", (l
& 0x80) != 0);
1031 fprintf_filtered (file
, "UI-%d ", (l
& 0x40) != 0);
1032 fprintf_filtered (file
, "H-%d ", (l
& 0x20) != 0);
1033 fprintf_filtered (file
, "U-%d ", (l
& 0x10) != 0);
1038 fprintf_filtered (file
, "N-%d ", N
);
1039 fprintf_filtered (file
, "Z-%d ", Z
);
1040 fprintf_filtered (file
, "V-%d ", V
);
1041 fprintf_filtered (file
, "C-%d ", C
);
1043 fprintf_filtered (file
, "u> ");
1045 fprintf_filtered (file
, "u<= ");
1047 fprintf_filtered (file
, "u>= ");
1049 fprintf_filtered (file
, "u< ");
1051 fprintf_filtered (file
, "!= ");
1053 fprintf_filtered (file
, "== ");
1055 fprintf_filtered (file
, ">= ");
1057 fprintf_filtered (file
, "< ");
1058 if ((Z
| (N
^ V
)) == 0)
1059 fprintf_filtered (file
, "> ");
1060 if ((Z
| (N
^ V
)) == 1)
1061 fprintf_filtered (file
, "<= ");
1063 else if (regno
== E_PSEUDO_EXR_REGNUM (gdbarch
) && is_h8300smode (gdbarch
))
1066 unsigned char l
= rval
& 0xff;
1067 fprintf_filtered (file
, "\t");
1068 fprintf_filtered (file
, "T-%d - - - ", (l
& 0x80) != 0);
1069 fprintf_filtered (file
, "I2-%d ", (l
& 4) != 0);
1070 fprintf_filtered (file
, "I1-%d ", (l
& 2) != 0);
1071 fprintf_filtered (file
, "I0-%d", (l
& 1) != 0);
1073 fprintf_filtered (file
, "\n");
1077 h8300_print_registers_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
1078 struct frame_info
*frame
, int regno
, int cpregs
)
1082 for (regno
= E_R0_REGNUM
; regno
<= E_SP_REGNUM
; ++regno
)
1083 h8300_print_register (gdbarch
, file
, frame
, regno
);
1084 h8300_print_register (gdbarch
, file
, frame
,
1085 E_PSEUDO_CCR_REGNUM (gdbarch
));
1086 h8300_print_register (gdbarch
, file
, frame
, E_PC_REGNUM
);
1087 if (is_h8300smode (gdbarch
))
1089 h8300_print_register (gdbarch
, file
, frame
,
1090 E_PSEUDO_EXR_REGNUM (gdbarch
));
1091 if (is_h8300sxmode (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
,
1113 E_PSEUDO_CCR_REGNUM (gdbarch
));
1114 else if (regno
== E_PSEUDO_EXR_REGNUM (gdbarch
)
1115 && is_h8300smode (gdbarch
))
1116 h8300_print_register (gdbarch
, file
, frame
,
1117 E_PSEUDO_EXR_REGNUM (gdbarch
));
1119 h8300_print_register (gdbarch
, file
, frame
, regno
);
1123 static struct type
*
1124 h8300_register_type (struct gdbarch
*gdbarch
, int regno
)
1126 if (regno
< 0 || regno
>= gdbarch_num_regs (gdbarch
)
1127 + gdbarch_num_pseudo_regs (gdbarch
))
1128 internal_error (__FILE__
, __LINE__
,
1129 _("h8300_register_type: illegal register number %d"),
1136 return builtin_type (gdbarch
)->builtin_func_ptr
;
1139 return builtin_type (gdbarch
)->builtin_data_ptr
;
1141 if (regno
== E_PSEUDO_CCR_REGNUM (gdbarch
))
1142 return builtin_type (gdbarch
)->builtin_uint8
;
1143 else if (regno
== E_PSEUDO_EXR_REGNUM (gdbarch
))
1144 return builtin_type (gdbarch
)->builtin_uint8
;
1145 else if (is_h8300hmode (gdbarch
))
1146 return builtin_type (gdbarch
)->builtin_int32
;
1148 return builtin_type (gdbarch
)->builtin_int16
;
1153 static enum register_status
1154 h8300_pseudo_register_read (struct gdbarch
*gdbarch
,
1155 struct regcache
*regcache
, int regno
,
1158 if (regno
== E_PSEUDO_CCR_REGNUM (gdbarch
))
1159 return regcache_raw_read (regcache
, E_CCR_REGNUM
, buf
);
1160 else if (regno
== E_PSEUDO_EXR_REGNUM (gdbarch
))
1161 return regcache_raw_read (regcache
, E_EXR_REGNUM
, buf
);
1163 return regcache_raw_read (regcache
, regno
, buf
);
1167 h8300_pseudo_register_write (struct gdbarch
*gdbarch
,
1168 struct regcache
*regcache
, int regno
,
1169 const gdb_byte
*buf
)
1171 if (regno
== E_PSEUDO_CCR_REGNUM (gdbarch
))
1172 regcache_raw_write (regcache
, E_CCR_REGNUM
, buf
);
1173 else if (regno
== E_PSEUDO_EXR_REGNUM (gdbarch
))
1174 regcache_raw_write (regcache
, E_EXR_REGNUM
, buf
);
1176 regcache_raw_write (regcache
, regno
, buf
);
1180 h8300_dbg_reg_to_regnum (struct gdbarch
*gdbarch
, int regno
)
1182 if (regno
== E_CCR_REGNUM
)
1183 return E_PSEUDO_CCR_REGNUM (gdbarch
);
1188 h8300s_dbg_reg_to_regnum (struct gdbarch
*gdbarch
, int regno
)
1190 if (regno
== E_CCR_REGNUM
)
1191 return E_PSEUDO_CCR_REGNUM (gdbarch
);
1192 if (regno
== E_EXR_REGNUM
)
1193 return E_PSEUDO_EXR_REGNUM (gdbarch
);
1197 const static unsigned char *
1198 h8300_breakpoint_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*pcptr
,
1201 /*static unsigned char breakpoint[] = { 0x7A, 0xFF }; *//* ??? */
1202 static unsigned char breakpoint
[] = { 0x01, 0x80 }; /* Sleep */
1204 *lenptr
= sizeof (breakpoint
);
1209 h8300_print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
1210 struct frame_info
*frame
, const char *args
)
1212 fprintf_filtered (file
, "\
1213 No floating-point info available for this processor.\n");
1216 static struct gdbarch
*
1217 h8300_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1219 struct gdbarch_tdep
*tdep
= NULL
;
1220 struct gdbarch
*gdbarch
;
1222 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1224 return arches
->gdbarch
;
1227 tdep
= (struct gdbarch_tdep
*) xmalloc (sizeof (struct gdbarch_tdep
));
1230 if (info
.bfd_arch_info
->arch
!= bfd_arch_h8300
)
1233 gdbarch
= gdbarch_alloc (&info
, 0);
1235 switch (info
.bfd_arch_info
->mach
)
1237 case bfd_mach_h8300
:
1238 set_gdbarch_num_regs (gdbarch
, 13);
1239 set_gdbarch_num_pseudo_regs (gdbarch
, 1);
1240 set_gdbarch_ecoff_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1241 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1242 set_gdbarch_stab_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1243 set_gdbarch_register_name (gdbarch
, h8300_register_name
);
1244 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1245 set_gdbarch_addr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1246 set_gdbarch_return_value (gdbarch
, h8300_return_value
);
1247 set_gdbarch_print_insn (gdbarch
, print_insn_h8300
);
1249 case bfd_mach_h8300h
:
1250 case bfd_mach_h8300hn
:
1251 set_gdbarch_num_regs (gdbarch
, 13);
1252 set_gdbarch_num_pseudo_regs (gdbarch
, 1);
1253 set_gdbarch_ecoff_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1254 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1255 set_gdbarch_stab_reg_to_regnum (gdbarch
, h8300_dbg_reg_to_regnum
);
1256 set_gdbarch_register_name (gdbarch
, h8300_register_name
);
1257 if (info
.bfd_arch_info
->mach
!= bfd_mach_h8300hn
)
1259 set_gdbarch_ptr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1260 set_gdbarch_addr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1264 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1265 set_gdbarch_addr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1267 set_gdbarch_return_value (gdbarch
, h8300h_return_value
);
1268 set_gdbarch_print_insn (gdbarch
, print_insn_h8300h
);
1270 case bfd_mach_h8300s
:
1271 case bfd_mach_h8300sn
:
1272 set_gdbarch_num_regs (gdbarch
, 16);
1273 set_gdbarch_num_pseudo_regs (gdbarch
, 2);
1274 set_gdbarch_ecoff_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1275 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1276 set_gdbarch_stab_reg_to_regnum (gdbarch
, h8300s_dbg_reg_to_regnum
);
1277 set_gdbarch_register_name (gdbarch
, h8300s_register_name
);
1278 if (info
.bfd_arch_info
->mach
!= bfd_mach_h8300sn
)
1280 set_gdbarch_ptr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1281 set_gdbarch_addr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1285 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1286 set_gdbarch_addr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1288 set_gdbarch_return_value (gdbarch
, h8300h_return_value
);
1289 set_gdbarch_print_insn (gdbarch
, print_insn_h8300s
);
1291 case bfd_mach_h8300sx
:
1292 case bfd_mach_h8300sxn
:
1293 set_gdbarch_num_regs (gdbarch
, 18);
1294 set_gdbarch_num_pseudo_regs (gdbarch
, 2);
1295 set_gdbarch_ecoff_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_dummy_id (gdbarch
, h8300_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_double_format (gdbarch
, floatformats_ieee_single
);
1353 set_gdbarch_long_double_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1354 set_gdbarch_long_double_format (gdbarch
, floatformats_ieee_single
);
1356 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
1358 /* Hook in the DWARF CFI frame unwinder. */
1359 dwarf2_append_unwinders (gdbarch
);
1360 frame_unwind_append_unwinder (gdbarch
, &h8300_frame_unwind
);
1366 extern initialize_file_ftype _initialize_h8300_tdep
; /* -Wmissing-prototypes */
1369 _initialize_h8300_tdep (void)
1371 register_gdbarch_init (bfd_arch_h8300
, h8300_gdbarch_init
);
1375 is_h8300hmode (struct gdbarch
*gdbarch
)
1377 return gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sx
1378 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sxn
1379 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300s
1380 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sn
1381 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300h
1382 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300hn
;
1386 is_h8300smode (struct gdbarch
*gdbarch
)
1388 return gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sx
1389 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sxn
1390 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300s
1391 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sn
;
1395 is_h8300sxmode (struct gdbarch
*gdbarch
)
1397 return gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sx
1398 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sxn
;
1402 is_h8300_normal_mode (struct gdbarch
*gdbarch
)
1404 return gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sxn
1405 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300sn
1406 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_h8300hn
;