1 /* Target-machine dependent code for Hitachi H8/300, for GDB.
3 Copyright 1988, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998,
4 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 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, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
24 Contributed by Steve Chamberlain
32 #include "arch-utils.h"
37 #include "gdb_assert.h"
39 /* Extra info which is saved in each frame_info. */
40 struct frame_extra_info
43 CORE_ADDR args_pointer
;
44 CORE_ADDR locals_pointer
;
47 #define E_NUM_REGS (h8300smode ? 14 : 13)
53 h8300_max_reg_size
= 4,
55 #define BINWORD (h8300hmode ? h8300h_reg_size : h8300_reg_size)
59 E_R0_REGNUM
, E_ER0_REGNUM
= E_R0_REGNUM
, E_ARG0_REGNUM
= E_R0_REGNUM
,
60 E_R1_REGNUM
, E_ER1_REGNUM
= E_R1_REGNUM
,
61 E_R2_REGNUM
, E_ER2_REGNUM
= E_R2_REGNUM
, E_ARGLAST_REGNUM
= E_R2_REGNUM
,
62 E_R3_REGNUM
, E_ER3_REGNUM
= E_R3_REGNUM
,
63 E_R4_REGNUM
, E_ER4_REGNUM
= E_R4_REGNUM
,
64 E_R5_REGNUM
, E_ER5_REGNUM
= E_R5_REGNUM
,
65 E_R6_REGNUM
, E_ER6_REGNUM
= E_R6_REGNUM
, E_FP_REGNUM
= E_R6_REGNUM
,
70 E_TICK_REGNUM
, E_EXR_REGNUM
= E_TICK_REGNUM
,
71 E_INST_REGNUM
, E_TICKS_REGNUM
= E_INST_REGNUM
,
75 #define UNSIGNED_SHORT(X) ((X) & 0xffff)
77 #define IS_PUSH(x) ((x & 0xfff0)==0x6df0)
78 #define IS_PUSH_FP(x) (x == 0x6df6)
79 #define IS_MOVE_FP(x) (x == 0x0d76 || x == 0x0ff6)
80 #define IS_MOV_SP_FP(x) (x == 0x0d76 || x == 0x0ff6)
81 #define IS_SUB2_SP(x) (x==0x1b87)
82 #define IS_SUB4_SP(x) (x==0x1b97)
83 #define IS_SUBL_SP(x) (x==0x7a37)
84 #define IS_MOVK_R5(x) (x==0x7905)
85 #define IS_SUB_R5SP(x) (x==0x1957)
87 /* If the instruction at PC is an argument register spill, return its
88 length. Otherwise, return zero.
90 An argument register spill is an instruction that moves an argument
91 from the register in which it was passed to the stack slot in which
92 it really lives. It is a byte, word, or longword move from an
93 argument register to a negative offset from the frame pointer. */
96 h8300_is_argument_spill (CORE_ADDR pc
)
98 int w
= read_memory_unsigned_integer (pc
, 2);
100 if ((w
& 0xfff0) == 0x6ee0 /* mov.b Rs,@(d:16,er6) */
101 && 8 <= (w
& 0xf) && (w
& 0xf) <= 10) /* Rs is R0L, R1L, or R2L */
103 int w2
= read_memory_integer (pc
+ 2, 2);
105 /* ... and d:16 is negative. */
109 else if (w
== 0x7860)
111 int w2
= read_memory_integer (pc
+ 2, 2);
113 if ((w2
& 0xfff0) == 0x6aa0) /* mov.b Rs, @(d:24,er6) */
115 LONGEST disp
= read_memory_integer (pc
+ 4, 4);
117 /* ... and d:24 is negative. */
118 if (disp
< 0 && disp
> 0xffffff)
122 else if ((w
& 0xfff0) == 0x6fe0 /* mov.w Rs,@(d:16,er6) */
123 && (w
& 0xf) <= 2) /* Rs is R0, R1, or R2 */
125 int w2
= read_memory_integer (pc
+ 2, 2);
127 /* ... and d:16 is negative. */
131 else if (w
== 0x78e0)
133 int w2
= read_memory_integer (pc
+ 2, 2);
135 if ((w2
& 0xfff0) == 0x6ba0) /* mov.b Rs, @(d:24,er6) */
137 LONGEST disp
= read_memory_integer (pc
+ 4, 4);
139 /* ... and d:24 is negative. */
140 if (disp
< 0 && disp
> 0xffffff)
144 else if (w
== 0x0100)
146 int w2
= read_memory_integer (pc
+ 2, 2);
148 if ((w2
& 0xfff0) == 0x6fe0 /* mov.l Rs,@(d:16,er6) */
149 && (w2
& 0xf) <= 2) /* Rs is ER0, ER1, or ER2 */
151 int w3
= read_memory_integer (pc
+ 4, 2);
153 /* ... and d:16 is negative. */
157 else if (w2
== 0x78e0)
159 int w3
= read_memory_integer (pc
+ 4, 2);
161 if ((w3
& 0xfff0) == 0x6ba0) /* mov.l Rs, @(d:24,er6) */
163 LONGEST disp
= read_memory_integer (pc
+ 6, 4);
165 /* ... and d:24 is negative. */
166 if (disp
< 0 && disp
> 0xffffff)
176 h8300_skip_prologue (CORE_ADDR start_pc
)
181 /* Skip past all push and stm insns. */
184 w
= read_memory_unsigned_integer (start_pc
, 2);
185 /* First look for push insns. */
186 if (w
== 0x0100 || w
== 0x0110 || w
== 0x0120 || w
== 0x0130)
188 w
= read_memory_unsigned_integer (start_pc
+ 2, 2);
194 start_pc
+= 2 + adjust
;
195 w
= read_memory_unsigned_integer (start_pc
, 2);
202 /* Skip past a move to FP, either word or long sized */
203 w
= read_memory_unsigned_integer (start_pc
, 2);
206 w
= read_memory_unsigned_integer (start_pc
+ 2, 2);
212 start_pc
+= 2 + adjust
;
213 w
= read_memory_unsigned_integer (start_pc
, 2);
216 /* Check for loading either a word constant into r5;
217 long versions are handled by the SUBL_SP below. */
221 w
= read_memory_unsigned_integer (start_pc
, 2);
224 /* Now check for subtracting r5 from sp, word sized only. */
227 start_pc
+= 2 + adjust
;
228 w
= read_memory_unsigned_integer (start_pc
, 2);
231 /* Check for subs #2 and subs #4. */
232 while (IS_SUB2_SP (w
) || IS_SUB4_SP (w
))
234 start_pc
+= 2 + adjust
;
235 w
= read_memory_unsigned_integer (start_pc
, 2);
238 /* Check for a 32bit subtract. */
240 start_pc
+= 6 + adjust
;
242 /* Check for spilling an argument register to the stack frame.
243 This could also be an initializing store from non-prologue code,
244 but I don't think there's any harm in skipping that. */
247 int spill_size
= h8300_is_argument_spill (start_pc
);
250 start_pc
+= spill_size
;
257 gdb_print_insn_h8300 (bfd_vma memaddr
, disassemble_info
* info
)
260 return print_insn_h8300s (memaddr
, info
);
262 return print_insn_h8300h (memaddr
, info
);
264 return print_insn_h8300 (memaddr
, info
);
267 /* Fetch the instruction at ADDR, returning 0 if ADDR is beyond LIM or
268 is not the address of a valid instruction, the address of the next
269 instruction beyond ADDR otherwise. *PWORD1 receives the first word
270 of the instruction. */
273 h8300_next_prologue_insn (CORE_ADDR addr
,
275 unsigned short* pword1
)
280 read_memory (addr
, buf
, 2);
281 *pword1
= extract_signed_integer (buf
, 2);
288 /* Examine the prologue of a function. `ip' points to the first instruction.
289 `limit' is the limit of the prologue (e.g. the addr of the first
290 linenumber, or perhaps the program counter if we're stepping through).
291 `frame_sp' is the stack pointer value in use in this frame.
292 `fsr' is a pointer to a frame_saved_regs structure into which we put
293 info about the registers saved by this frame.
294 `fi' is a struct frame_info pointer; we fill in various fields in it
295 to reflect the offsets of the arg pointer and the locals pointer. */
297 /* Any function with a frame looks like this
303 SAVED FP <-FP POINTS HERE
305 LOCALS1 <-SP POINTS HERE
309 h8300_examine_prologue (register CORE_ADDR ip
, register CORE_ADDR limit
,
310 CORE_ADDR after_prolog_fp
, CORE_ADDR
*fsr
,
311 struct frame_info
*fi
)
313 register CORE_ADDR next_ip
;
316 unsigned short insn_word
;
317 /* Number of things pushed onto stack, starts at 2/4, 'cause the
318 PC is already there */
319 unsigned int reg_save_depth
= BINWORD
;
321 unsigned int auto_depth
= 0; /* Number of bytes of autos */
323 char in_frame
[11]; /* One for each reg */
327 memset (in_frame
, 1, 11);
328 for (r
= 0; r
< 8; r
++)
332 if (after_prolog_fp
== 0)
334 after_prolog_fp
= read_register (E_SP_REGNUM
);
337 /* If the PC isn't valid, quit now. */
338 if (ip
== 0 || ip
& (h8300hmode
? ~0xffffff : ~0xffff))
341 next_ip
= h8300_next_prologue_insn (ip
, limit
, &insn_word
);
343 if (insn_word
== 0x0100)
345 insn_word
= read_memory_unsigned_integer (ip
+ 2, 2);
349 /* Skip over any fp push instructions */
350 fsr
[E_FP_REGNUM
] = after_prolog_fp
;
351 while (next_ip
&& IS_PUSH_FP (insn_word
))
353 ip
= next_ip
+ adjust
;
355 in_frame
[insn_word
& 0x7] = reg_save_depth
;
356 next_ip
= h8300_next_prologue_insn (ip
, limit
, &insn_word
);
357 reg_save_depth
+= 2 + adjust
;
360 /* Is this a move into the fp */
361 if (next_ip
&& IS_MOV_SP_FP (insn_word
))
364 next_ip
= h8300_next_prologue_insn (ip
, limit
, &insn_word
);
368 /* Skip over any stack adjustment, happens either with a number of
369 sub#2,sp or a mov #x,r5 sub r5,sp */
371 if (next_ip
&& (IS_SUB2_SP (insn_word
) || IS_SUB4_SP (insn_word
)))
373 while (next_ip
&& (IS_SUB2_SP (insn_word
) || IS_SUB4_SP (insn_word
)))
375 auto_depth
+= IS_SUB2_SP (insn_word
) ? 2 : 4;
377 next_ip
= h8300_next_prologue_insn (ip
, limit
, &insn_word
);
382 if (next_ip
&& IS_MOVK_R5 (insn_word
))
385 next_ip
= h8300_next_prologue_insn (ip
, limit
, &insn_word
);
386 auto_depth
+= insn_word
;
388 next_ip
= h8300_next_prologue_insn (next_ip
, limit
, &insn_word
);
389 auto_depth
+= insn_word
;
391 if (next_ip
&& IS_SUBL_SP (insn_word
))
394 auto_depth
+= read_memory_unsigned_integer (ip
, 4);
397 next_ip
= h8300_next_prologue_insn (ip
, limit
, &insn_word
);
401 /* Now examine the push insns to determine where everything lives
409 if (insn_word
== 0x0100)
412 next_ip
= h8300_next_prologue_insn (ip
, limit
, &insn_word
);
416 if (IS_PUSH (insn_word
))
418 auto_depth
+= 2 + adjust
;
419 fsr
[insn_word
& 0x7] = after_prolog_fp
- auto_depth
;
421 next_ip
= h8300_next_prologue_insn (ip
, limit
, &insn_word
);
425 /* Now check for push multiple insns. */
426 if (insn_word
== 0x0110 || insn_word
== 0x0120 || insn_word
== 0x0130)
428 int count
= ((insn_word
>> 4) & 0xf) + 1;
432 next_ip
= h8300_next_prologue_insn (ip
, limit
, &insn_word
);
433 start
= insn_word
& 0x7;
435 for (i
= start
; i
< start
+ count
; i
++)
438 fsr
[i
] = after_prolog_fp
- auto_depth
;
444 /* The args are always reffed based from the stack pointer */
445 get_frame_extra_info (fi
)->args_pointer
= after_prolog_fp
;
446 /* Locals are always reffed based from the fp */
447 get_frame_extra_info (fi
)->locals_pointer
= after_prolog_fp
;
448 /* The PC is at a known place */
449 get_frame_extra_info (fi
)->from_pc
=
450 read_memory_unsigned_integer (after_prolog_fp
+ BINWORD
, BINWORD
);
452 /* Rememeber any others too */
453 in_frame
[E_PC_REGNUM
] = 0;
456 /* We keep the old FP in the SP spot */
457 fsr
[E_SP_REGNUM
] = read_memory_unsigned_integer (fsr
[E_FP_REGNUM
],
460 fsr
[E_SP_REGNUM
] = after_prolog_fp
+ auto_depth
;
466 h8300_frame_init_saved_regs (struct frame_info
*fi
)
468 CORE_ADDR func_addr
, func_end
;
470 if (!get_frame_saved_regs (fi
))
472 frame_saved_regs_zalloc (fi
);
474 /* Find the beginning of this function, so we can analyze its
476 if (find_pc_partial_function (get_frame_pc (fi
), NULL
,
477 &func_addr
, &func_end
))
479 struct symtab_and_line sal
= find_pc_line (func_addr
, 0);
480 CORE_ADDR limit
= (sal
.end
&& sal
.end
< get_frame_pc (fi
))
481 ? sal
.end
: get_frame_pc (fi
);
482 /* This will fill in fields in fi. */
483 h8300_examine_prologue (func_addr
, limit
, get_frame_base (fi
),
484 get_frame_saved_regs (fi
), fi
);
486 /* Else we're out of luck (can't debug completely stripped code).
491 /* Given a GDB frame, determine the address of the calling function's
492 frame. This will be used to create a new GDB frame struct, and
493 then DEPRECATED_INIT_EXTRA_FRAME_INFO and DEPRECATED_INIT_FRAME_PC
494 will be called for the new frame.
496 For us, the frame address is its stack pointer value, so we look up
497 the function prologue to determine the caller's sp value, and
501 h8300_frame_chain (struct frame_info
*thisframe
)
503 if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (thisframe
),
504 get_frame_base (thisframe
),
505 get_frame_base (thisframe
)))
506 { /* initialize the from_pc now */
507 get_frame_extra_info (thisframe
)->from_pc
=
508 deprecated_read_register_dummy (get_frame_pc (thisframe
),
509 get_frame_base (thisframe
),
511 return get_frame_base (thisframe
);
513 return get_frame_saved_regs (thisframe
)[E_SP_REGNUM
];
516 /* Return the saved PC from this frame.
518 If the frame has a memory copy of SRP_REGNUM, use that. If not,
519 just use the register SRP_REGNUM itself. */
522 h8300_frame_saved_pc (struct frame_info
*frame
)
524 if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame
),
525 get_frame_base (frame
),
526 get_frame_base (frame
)))
527 return deprecated_read_register_dummy (get_frame_pc (frame
),
528 get_frame_base (frame
),
531 return get_frame_extra_info (frame
)->from_pc
;
535 h8300_init_extra_frame_info (int fromleaf
, struct frame_info
*fi
)
537 if (!get_frame_extra_info (fi
))
539 frame_extra_info_zalloc (fi
, sizeof (struct frame_extra_info
));
540 get_frame_extra_info (fi
)->from_pc
= 0;
541 get_frame_extra_info (fi
)->args_pointer
= 0; /* Unknown */
542 get_frame_extra_info (fi
)->locals_pointer
= 0; /* Unknown */
544 if (!get_frame_pc (fi
))
546 if (get_next_frame (fi
))
547 deprecated_update_frame_pc_hack (fi
, h8300_frame_saved_pc (get_next_frame (fi
)));
549 h8300_frame_init_saved_regs (fi
);
554 h8300_frame_locals_address (struct frame_info
*fi
)
556 if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi
), get_frame_base (fi
),
557 get_frame_base (fi
)))
558 return (CORE_ADDR
) 0; /* Not sure what else to do... */
559 return get_frame_extra_info (fi
)->locals_pointer
;
562 /* Return the address of the argument block for the frame
563 described by FI. Returns 0 if the address is unknown. */
566 h8300_frame_args_address (struct frame_info
*fi
)
568 if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi
), get_frame_base (fi
),
569 get_frame_base (fi
)))
570 return (CORE_ADDR
) 0; /* Not sure what else to do... */
571 return get_frame_extra_info (fi
)->args_pointer
;
574 /* Round N up or down to the nearest multiple of UNIT.
575 Evaluate N only once, UNIT several times.
576 UNIT must be a power of two. */
577 #define round_up(n, unit) (((n) + (unit) - 1) & -(unit))
578 #define round_down(n, unit) ((n) & -(unit))
580 /* Function: push_arguments
581 Setup the function arguments for calling a function in the inferior.
582 In this discussion, a `word' is 16 bits on the H8/300s, and 32 bits
585 There are actually two ABI's here: -mquickcall (the default) and
586 -mno-quickcall. With -mno-quickcall, all arguments are passed on
587 the stack after the return address, word-aligned. With
588 -mquickcall, GCC tries to use r0 -- r2 to pass registers. Since
589 GCC doesn't indicate in the object file which ABI was used to
590 compile it, GDB only supports the default --- -mquickcall.
592 Here are the rules for -mquickcall, in detail:
594 Each argument, whether scalar or aggregate, is padded to occupy a
595 whole number of words. Arguments smaller than a word are padded at
596 the most significant end; those larger than a word are padded at
597 the least significant end.
599 The initial arguments are passed in r0 -- r2. Earlier arguments go in
600 lower-numbered registers. Multi-word arguments are passed in
601 consecutive registers, with the most significant end in the
602 lower-numbered register.
604 If an argument doesn't fit entirely in the remaining registers, it
605 is passed entirely on the stack. Stack arguments begin just after
606 the return address. Once an argument has overflowed onto the stack
607 this way, all subsequent arguments are passed on the stack.
609 The above rule has odd consequences. For example, on the h8/300s,
610 if a function takes two longs and an int as arguments:
611 - the first long will be passed in r0/r1,
612 - the second long will be passed entirely on the stack, since it
614 - and the int will be passed on the stack, even though it could fit
617 A weird exception: if an argument is larger than a word, but not a
618 whole number of words in length (before padding), it is passed on
619 the stack following the rules for stack arguments above, even if
620 there are sufficient registers available to hold it. Stranger
621 still, the argument registers are still `used up' --- even though
622 there's nothing in them.
624 So, for example, on the h8/300s, if a function expects a three-byte
625 structure and an int, the structure will go on the stack, and the
626 int will go in r2, not r0.
628 If the function returns an aggregate type (struct, union, or class)
629 by value, the caller must allocate space to hold the return value,
630 and pass the callee a pointer to this space as an invisible first
633 For varargs functions, the last fixed argument and all the variable
634 arguments are always passed on the stack. This means that calls to
635 varargs functions don't work properly unless there is a prototype
638 Basically, this ABI is not good, for the following reasons:
639 - You can't call vararg functions properly unless a prototype is in scope.
640 - Structure passing is inconsistent, to no purpose I can see.
641 - It often wastes argument registers, of which there are only three
645 h8300_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
646 int struct_return
, CORE_ADDR struct_addr
)
648 int stack_align
, stack_alloc
, stack_offset
;
649 int wordsize
= BINWORD
;
653 /* First, make sure the stack is properly aligned. */
654 sp
= round_down (sp
, wordsize
);
656 /* Now make sure there's space on the stack for the arguments. We
657 may over-allocate a little here, but that won't hurt anything. */
659 for (argument
= 0; argument
< nargs
; argument
++)
660 stack_alloc
+= round_up (TYPE_LENGTH (VALUE_TYPE (args
[argument
])),
664 /* Now load as many arguments as possible into registers, and push
665 the rest onto the stack. */
669 /* If we're returning a structure by value, then we must pass a
670 pointer to the buffer for the return value as an invisible first
673 write_register (reg
++, struct_addr
);
675 for (argument
= 0; argument
< nargs
; argument
++)
677 struct type
*type
= VALUE_TYPE (args
[argument
]);
678 int len
= TYPE_LENGTH (type
);
679 char *contents
= (char *) VALUE_CONTENTS (args
[argument
]);
681 /* Pad the argument appropriately. */
682 int padded_len
= round_up (len
, wordsize
);
683 char *padded
= alloca (padded_len
);
685 memset (padded
, 0, padded_len
);
686 memcpy (len
< wordsize
? padded
+ padded_len
- len
: padded
,
689 /* Could the argument fit in the remaining registers? */
690 if (padded_len
<= (E_ARGLAST_REGNUM
- reg
+ 1) * wordsize
)
692 /* Are we going to pass it on the stack anyway, for no good
694 if (len
> wordsize
&& len
% wordsize
)
696 /* I feel so unclean. */
697 write_memory (sp
+ stack_offset
, padded
, padded_len
);
698 stack_offset
+= padded_len
;
700 /* That's right --- even though we passed the argument
701 on the stack, we consume the registers anyway! Love
703 reg
+= padded_len
/ wordsize
;
707 /* Heavens to Betsy --- it's really going in registers!
708 It would be nice if we could use write_register_bytes
709 here, but on the h8/300s, there are gaps between
710 the registers in the register file. */
713 for (offset
= 0; offset
< padded_len
; offset
+= wordsize
)
715 ULONGEST word
= extract_unsigned_integer (padded
+ offset
,
717 write_register (reg
++, word
);
723 /* It doesn't fit in registers! Onto the stack it goes. */
724 write_memory (sp
+ stack_offset
, padded
, padded_len
);
725 stack_offset
+= padded_len
;
727 /* Once one argument has spilled onto the stack, all
728 subsequent arguments go on the stack. */
729 reg
= E_ARGLAST_REGNUM
+ 1;
736 /* Function: push_return_address
737 Setup the return address for a dummy frame, as called by
738 call_function_by_hand. Only necessary when you are using an
739 empty CALL_DUMMY, ie. the target will not actually be executing
740 a JSR/BSR instruction. */
743 h8300_push_return_address (CORE_ADDR pc
, CORE_ADDR sp
)
745 unsigned char buf
[4];
746 int wordsize
= BINWORD
;
749 store_unsigned_integer (buf
, wordsize
, CALL_DUMMY_ADDRESS ());
750 write_memory (sp
, buf
, wordsize
);
754 /* Function: h8300_pop_frame
755 Restore the machine to the state it had before the current frame
756 was created. Usually used either by the "RETURN" command, or by
757 call_function_by_hand after the dummy_frame is finished. */
760 h8300_pop_frame (void)
763 struct frame_info
*frame
= get_current_frame ();
765 if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame
),
766 get_frame_base (frame
),
767 get_frame_base (frame
)))
769 generic_pop_dummy_frame ();
773 for (regno
= 0; regno
< 8; regno
++)
775 /* Don't forget E_SP_REGNUM is a frame_saved_regs struct is the
776 actual value we want, not the address of the value we want. */
777 if (get_frame_saved_regs (frame
)[regno
] && regno
!= E_SP_REGNUM
)
778 write_register (regno
,
780 (get_frame_saved_regs (frame
)[regno
], BINWORD
));
781 else if (get_frame_saved_regs (frame
)[regno
] && regno
== E_SP_REGNUM
)
782 write_register (regno
, get_frame_base (frame
) + 2 * BINWORD
);
785 /* Don't forget to update the PC too! */
786 write_register (E_PC_REGNUM
, get_frame_extra_info (frame
)->from_pc
);
788 flush_cached_frames ();
791 /* Function: extract_return_value
792 Figure out where in REGBUF the called function has left its return value.
793 Copy that into VALBUF. Be sure to account for CPU type. */
796 h8300_extract_return_value (struct type
*type
, char *regbuf
, char *valbuf
)
798 int wordsize
= BINWORD
;
799 int len
= TYPE_LENGTH (type
);
804 case 2: /* (short), (int) */
805 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (0) + (wordsize
- len
), len
);
807 case 4: /* (long), (float) */
810 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (0), 4);
814 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (0), 2);
815 memcpy (valbuf
+ 2, regbuf
+ REGISTER_BYTE (1), 2);
818 case 8: /* (double) (doesn't seem to happen, which is good,
819 because this almost certainly isn't right.
820 FIXME: it will happen for h8sx... */
821 error ("I don't know how a double is returned.");
826 /* Function: store_return_value
827 Place the appropriate value in the appropriate registers.
828 Primarily used by the RETURN command. */
831 h8300_store_return_value (struct type
*type
, char *valbuf
)
834 int wordsize
= BINWORD
;
835 int len
= TYPE_LENGTH (type
);
840 case 2: /* short, int */
841 regval
= extract_unsigned_integer (valbuf
, len
);
842 write_register (0, regval
);
844 case 4: /* long, float */
845 regval
= extract_unsigned_integer (valbuf
, len
);
848 write_register (0, regval
);
852 write_register (0, regval
>> 16);
853 write_register (1, regval
& 0xffff);
856 case 8: /* presumeably double, but doesn't seem to happen */
857 error ("I don't know how to return a double.");
862 static struct cmd_list_element
*setmachinelist
;
865 h8300_register_name (int regno
)
867 /* The register names change depending on whether the h8300h processor
869 static char *h8300_register_names
[] = {
870 "r0", "r1", "r2", "r3", "r4", "r5", "r6",
871 "sp", "ccr","pc","cycles", "tick", "inst", ""
873 static char *h8300s_register_names
[] = {
874 "er0", "er1", "er2", "er3", "er4", "er5", "er6",
875 "sp", "ccr", "pc", "cycles", "exr", "tick", "inst"
877 char **register_names
=
878 h8300smode
? h8300s_register_names
: h8300_register_names
;
879 if (regno
< 0 || regno
>= E_NUM_REGS
)
880 internal_error (__FILE__
, __LINE__
,
881 "h8300_register_name: illegal register number %d", regno
);
883 return register_names
[regno
];
887 h8300_print_register (struct gdbarch
*gdbarch
, struct ui_file
*file
,
888 struct frame_info
*frame
, int regno
)
892 const char *name
= h8300_register_name (regno
);
897 /* FIXME: cagney/2002-10-22: The code below assumes that VAL is at
898 least 4 bytes (32 bits) in size and hence is large enough to hold
899 the largest h8300 register. Should instead be using ULONGEST and
900 the phex() functions. */
901 gdb_assert (sizeof (val
) >= 4);
902 frame_read_unsigned_register (frame
, regno
, &rval
);
905 fprintf_filtered (file
, "%-14s ", name
);
909 fprintf_filtered (file
, "0x%08lx %-8ld", val
, val
);
911 fprintf_filtered (file
, "0x%-8lx %-8ld", val
, val
);
916 fprintf_filtered (file
, "0x%04lx %-4ld", val
, val
);
918 fprintf_filtered (file
, "0x%-4lx %-4ld", val
, val
);
920 if (regno
== E_CCR_REGNUM
)
924 unsigned char b
[h8300h_reg_size
];
926 frame_register_read (deprecated_selected_frame
, regno
, b
);
927 l
= b
[REGISTER_VIRTUAL_SIZE (E_CCR_REGNUM
) - 1];
928 fprintf_filtered (file
, "\t");
929 fprintf_filtered (file
, "I-%d ", (l
& 0x80) != 0);
930 fprintf_filtered (file
, "UI-%d ", (l
& 0x40) != 0);
931 fprintf_filtered (file
, "H-%d ", (l
& 0x20) != 0);
932 fprintf_filtered (file
, "U-%d ", (l
& 0x10) != 0);
937 fprintf_filtered (file
, "N-%d ", N
);
938 fprintf_filtered (file
, "Z-%d ", Z
);
939 fprintf_filtered (file
, "V-%d ", V
);
940 fprintf_filtered (file
, "C-%d ", C
);
942 fprintf_filtered (file
, "u> ");
944 fprintf_filtered (file
, "u<= ");
946 fprintf_filtered (file
, "u>= ");
948 fprintf_filtered (file
, "u< ");
950 fprintf_filtered (file
, "!= ");
952 fprintf_filtered (file
, "== ");
954 fprintf_filtered (file
, ">= ");
956 fprintf_filtered (file
, "< ");
957 if ((Z
| (N
^ V
)) == 0)
958 fprintf_filtered (file
, "> ");
959 if ((Z
| (N
^ V
)) == 1)
960 fprintf_filtered (file
, "<= ");
962 else if (regno
== E_EXR_REGNUM
&& h8300smode
)
965 unsigned char b
[h8300h_reg_size
];
967 frame_register_read (deprecated_selected_frame
, regno
, b
);
968 l
= b
[REGISTER_VIRTUAL_SIZE (E_EXR_REGNUM
) - 1];
969 fprintf_filtered (file
, "\t");
970 fprintf_filtered (file
, "T-%d - - - ", (l
& 0x80) != 0);
971 fprintf_filtered (file
, "I2-%d ", (l
& 4) != 0);
972 fprintf_filtered (file
, "I1-%d ", (l
& 2) != 0);
973 fprintf_filtered (file
, "I0-%d", (l
& 1) != 0);
975 fprintf_filtered (file
, "\n");
979 h8300_print_registers_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
980 struct frame_info
*frame
, int regno
, int cpregs
)
983 for (regno
= 0; regno
< E_NUM_REGS
; ++regno
)
984 h8300_print_register (gdbarch
, file
, frame
, regno
);
986 h8300_print_register (gdbarch
, file
, frame
, regno
);
990 h8300_saved_pc_after_call (struct frame_info
*ignore
)
992 return read_memory_unsigned_integer (read_register (E_SP_REGNUM
), BINWORD
);
996 h8300_register_byte (int regno
)
998 if (regno
< 0 || regno
>= E_NUM_REGS
)
999 internal_error (__FILE__
, __LINE__
,
1000 "h8300_register_byte: illegal register number %d", regno
);
1002 return regno
* BINWORD
;
1006 h8300_register_raw_size (int regno
)
1008 if (regno
< 0 || regno
>= E_NUM_REGS
)
1009 internal_error (__FILE__
, __LINE__
,
1010 "h8300_register_raw_size: illegal register number %d",
1016 static struct type
*
1017 h8300_register_virtual_type (int regno
)
1019 if (regno
< 0 || regno
>= E_NUM_REGS
)
1020 internal_error (__FILE__
, __LINE__
,
1021 "h8300_register_virtual_type: illegal register number %d",
1025 builtin_type_unsigned_long
: builtin_type_unsigned_short
;
1029 h8300_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
1031 write_register (0, addr
);
1035 h8300_use_struct_convention (int gcc_p
, struct type
*type
)
1041 h8300_extract_struct_value_address (char *regbuf
)
1044 extract_unsigned_integer (regbuf
+ h8300_register_byte (E_ARG0_REGNUM
),
1045 h8300_register_raw_size (E_ARG0_REGNUM
));
1048 const static unsigned char *
1049 h8300_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
1051 /*static unsigned char breakpoint[] = { 0x7A, 0xFF };*/ /* ??? */
1052 static unsigned char breakpoint
[] = { 0x01, 0x80 }; /* Sleep */
1054 *lenptr
= sizeof (breakpoint
);
1059 h8300_print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
1060 struct frame_info
*frame
, const char *args
)
1062 fprintf_filtered (file
, "\
1063 No floating-point info available for this processor.\n");
1066 static struct gdbarch
*
1067 h8300_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1069 static LONGEST call_dummy_words
[1] = { 0 };
1070 struct gdbarch_tdep
*tdep
= NULL
;
1071 struct gdbarch
*gdbarch
;
1073 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1075 return arches
->gdbarch
;
1078 tdep
= (struct gdbarch_tdep
*) xmalloc (sizeof (struct gdbarch_tdep
));
1081 if (info
.bfd_arch_info
->arch
!= bfd_arch_h8300
)
1084 switch (info
.bfd_arch_info
->mach
)
1086 case bfd_mach_h8300
:
1091 case bfd_mach_h8300h
:
1092 case bfd_mach_h8300hn
:
1097 case bfd_mach_h8300s
:
1098 case bfd_mach_h8300sn
:
1103 case bfd_mach_h8300sx
:
1110 gdbarch
= gdbarch_alloc (&info
, 0);
1112 /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
1113 ready to unwind the PC first (see frame.c:get_prev_frame()). */
1114 set_gdbarch_deprecated_init_frame_pc (gdbarch
, init_frame_pc_default
);
1117 * Basic register fields and methods.
1120 set_gdbarch_num_regs (gdbarch
, E_NUM_REGS
);
1121 set_gdbarch_num_pseudo_regs (gdbarch
, 0);
1122 set_gdbarch_sp_regnum (gdbarch
, E_SP_REGNUM
);
1123 set_gdbarch_deprecated_fp_regnum (gdbarch
, E_FP_REGNUM
);
1124 set_gdbarch_pc_regnum (gdbarch
, E_PC_REGNUM
);
1125 set_gdbarch_register_name (gdbarch
, h8300_register_name
);
1126 set_gdbarch_deprecated_register_size (gdbarch
, BINWORD
);
1127 set_gdbarch_deprecated_register_bytes (gdbarch
, E_NUM_REGS
* BINWORD
);
1128 set_gdbarch_register_byte (gdbarch
, h8300_register_byte
);
1129 set_gdbarch_register_raw_size (gdbarch
, h8300_register_raw_size
);
1130 set_gdbarch_deprecated_max_register_raw_size (gdbarch
, h8300h_reg_size
);
1131 set_gdbarch_register_virtual_size (gdbarch
, h8300_register_raw_size
);
1132 set_gdbarch_deprecated_max_register_virtual_size (gdbarch
, h8300h_reg_size
);
1133 set_gdbarch_register_virtual_type (gdbarch
, h8300_register_virtual_type
);
1134 set_gdbarch_print_registers_info (gdbarch
, h8300_print_registers_info
);
1135 set_gdbarch_print_float_info (gdbarch
, h8300_print_float_info
);
1140 set_gdbarch_deprecated_frame_init_saved_regs (gdbarch
,
1141 h8300_frame_init_saved_regs
);
1142 set_gdbarch_deprecated_init_extra_frame_info (gdbarch
,
1143 h8300_init_extra_frame_info
);
1144 set_gdbarch_deprecated_frame_chain (gdbarch
, h8300_frame_chain
);
1145 set_gdbarch_deprecated_saved_pc_after_call (gdbarch
,
1146 h8300_saved_pc_after_call
);
1147 set_gdbarch_deprecated_frame_saved_pc (gdbarch
, h8300_frame_saved_pc
);
1148 set_gdbarch_skip_prologue (gdbarch
, h8300_skip_prologue
);
1149 set_gdbarch_frame_args_address (gdbarch
, h8300_frame_args_address
);
1150 set_gdbarch_frame_locals_address (gdbarch
, h8300_frame_locals_address
);
1155 /* Stack grows up. */
1156 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1157 /* PC stops zero byte after a trap instruction
1158 (which means: exactly on trap instruction). */
1159 set_gdbarch_decr_pc_after_break (gdbarch
, 0);
1160 /* This value is almost never non-zero... */
1161 set_gdbarch_function_start_offset (gdbarch
, 0);
1162 /* This value is almost never non-zero... */
1163 set_gdbarch_frame_args_skip (gdbarch
, 0);
1164 /* OK to default this value to 'unknown'. */
1165 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
1166 set_gdbarch_frameless_function_invocation (gdbarch
,
1167 frameless_look_for_prologue
);
1172 * These values and methods are used when gdb calls a target function. */
1173 set_gdbarch_deprecated_push_return_address (gdbarch
,
1174 h8300_push_return_address
);
1175 set_gdbarch_deprecated_extract_return_value (gdbarch
,
1176 h8300_extract_return_value
);
1177 set_gdbarch_deprecated_push_arguments (gdbarch
, h8300_push_arguments
);
1178 set_gdbarch_deprecated_pop_frame (gdbarch
, h8300_pop_frame
);
1179 set_gdbarch_deprecated_store_struct_return (gdbarch
,
1180 h8300_store_struct_return
);
1181 set_gdbarch_deprecated_store_return_value (gdbarch
,
1182 h8300_store_return_value
);
1183 set_gdbarch_deprecated_extract_struct_value_address
1184 (gdbarch
, h8300_extract_struct_value_address
);
1185 set_gdbarch_use_struct_convention (gdbarch
, h8300_use_struct_convention
);
1186 set_gdbarch_deprecated_call_dummy_words (gdbarch
, call_dummy_words
);
1187 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch
, 0);
1188 set_gdbarch_breakpoint_from_pc (gdbarch
, h8300_breakpoint_from_pc
);
1190 set_gdbarch_int_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1191 set_gdbarch_long_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1192 set_gdbarch_ptr_bit (gdbarch
, BINWORD
* TARGET_CHAR_BIT
);
1193 set_gdbarch_addr_bit (gdbarch
, BINWORD
* TARGET_CHAR_BIT
);
1195 /* set_gdbarch_stack_align (gdbarch, SOME_stack_align); */
1196 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
1198 /* Should be using push_dummy_call. */
1199 set_gdbarch_deprecated_dummy_write_sp (gdbarch
, deprecated_write_sp
);
1205 _initialize_h8300_tdep (void)
1207 deprecated_tm_print_insn
= gdb_print_insn_h8300
;
1208 register_gdbarch_init (bfd_arch_h8300
, h8300_gdbarch_init
);