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, CORE_ADDR lim, unsigned short* pword1)
278 read_memory (addr, buf, 2);
279 *pword1 = extract_signed_integer (buf, 2);
286 /* Examine the prologue of a function. `ip' points to the first instruction.
287 `limit' is the limit of the prologue (e.g. the addr of the first
288 linenumber, or perhaps the program counter if we're stepping through).
289 `frame_sp' is the stack pointer value in use in this frame.
290 `fsr' is a pointer to a frame_saved_regs structure into which we put
291 info about the registers saved by this frame.
292 `fi' is a struct frame_info pointer; we fill in various fields in it
293 to reflect the offsets of the arg pointer and the locals pointer. */
295 /* Any function with a frame looks like this
301 SAVED FP <-FP POINTS HERE
303 LOCALS1 <-SP POINTS HERE
307 h8300_examine_prologue (register CORE_ADDR ip, register CORE_ADDR limit,
308 CORE_ADDR after_prolog_fp, CORE_ADDR *fsr,
309 struct frame_info *fi)
311 register CORE_ADDR next_ip;
314 unsigned short insn_word;
315 /* Number of things pushed onto stack, starts at 2/4, 'cause the
316 PC is already there */
317 unsigned int reg_save_depth = BINWORD;
319 unsigned int auto_depth = 0; /* Number of bytes of autos */
321 char in_frame[11]; /* One for each reg */
325 memset (in_frame, 1, 11);
326 for (r = 0; r < 8; r++)
330 if (after_prolog_fp == 0)
332 after_prolog_fp = read_register (E_SP_REGNUM);
335 /* If the PC isn't valid, quit now. */
336 if (ip == 0 || ip & (h8300hmode ? ~0xffffff : ~0xffff))
339 next_ip = h8300_next_prologue_insn (ip, limit, &insn_word);
341 if (insn_word == 0x0100)
343 insn_word = read_memory_unsigned_integer (ip + 2, 2);
347 /* Skip over any fp push instructions */
348 fsr[E_FP_REGNUM] = after_prolog_fp;
349 while (next_ip && IS_PUSH_FP (insn_word))
351 ip = next_ip + adjust;
353 in_frame[insn_word & 0x7] = reg_save_depth;
354 next_ip = h8300_next_prologue_insn (ip, limit, &insn_word);
355 reg_save_depth += 2 + adjust;
358 /* Is this a move into the fp */
359 if (next_ip && IS_MOV_SP_FP (insn_word))
362 next_ip = h8300_next_prologue_insn (ip, limit, &insn_word);
366 /* Skip over any stack adjustment, happens either with a number of
367 sub#2,sp or a mov #x,r5 sub r5,sp */
369 if (next_ip && (IS_SUB2_SP (insn_word) || IS_SUB4_SP (insn_word)))
371 while (next_ip && (IS_SUB2_SP (insn_word) || IS_SUB4_SP (insn_word)))
373 auto_depth += IS_SUB2_SP (insn_word) ? 2 : 4;
375 next_ip = h8300_next_prologue_insn (ip, limit, &insn_word);
380 if (next_ip && IS_MOVK_R5 (insn_word))
383 next_ip = h8300_next_prologue_insn (ip, limit, &insn_word);
384 auto_depth += insn_word;
386 next_ip = h8300_next_prologue_insn (next_ip, limit, &insn_word);
387 auto_depth += insn_word;
389 if (next_ip && IS_SUBL_SP (insn_word))
392 auto_depth += read_memory_unsigned_integer (ip, 4);
395 next_ip = h8300_next_prologue_insn (ip, limit, &insn_word);
399 /* Now examine the push insns to determine where everything lives
407 if (insn_word == 0x0100)
410 next_ip = h8300_next_prologue_insn (ip, limit, &insn_word);
414 if (IS_PUSH (insn_word))
416 auto_depth += 2 + adjust;
417 fsr[insn_word & 0x7] = after_prolog_fp - auto_depth;
419 next_ip = h8300_next_prologue_insn (ip, limit, &insn_word);
423 /* Now check for push multiple insns. */
424 if (insn_word == 0x0110 || insn_word == 0x0120 || insn_word == 0x0130)
426 int count = ((insn_word >> 4) & 0xf) + 1;
430 next_ip = h8300_next_prologue_insn (ip, limit, &insn_word);
431 start = insn_word & 0x7;
433 for (i = start; i < start + count; i++)
436 fsr[i] = after_prolog_fp - auto_depth;
442 /* The args are always reffed based from the stack pointer */
443 fi->extra_info->args_pointer = after_prolog_fp;
444 /* Locals are always reffed based from the fp */
445 fi->extra_info->locals_pointer = after_prolog_fp;
446 /* The PC is at a known place */
447 fi->extra_info->from_pc =
448 read_memory_unsigned_integer (after_prolog_fp + BINWORD, BINWORD);
450 /* Rememeber any others too */
451 in_frame[E_PC_REGNUM] = 0;
454 /* We keep the old FP in the SP spot */
455 fsr[E_SP_REGNUM] = read_memory_unsigned_integer (fsr[E_FP_REGNUM], BINWORD);
457 fsr[E_SP_REGNUM] = after_prolog_fp + auto_depth;
463 h8300_frame_init_saved_regs (struct frame_info *fi)
465 CORE_ADDR func_addr, func_end;
467 if (!get_frame_saved_regs (fi))
469 frame_saved_regs_zalloc (fi);
471 /* Find the beginning of this function, so we can analyze its
473 if (find_pc_partial_function (get_frame_pc (fi), NULL, &func_addr, &func_end))
475 struct symtab_and_line sal = find_pc_line (func_addr, 0);
476 CORE_ADDR limit = (sal.end && sal.end < get_frame_pc (fi)) ? sal.end : get_frame_pc (fi);
477 /* This will fill in fields in fi. */
478 h8300_examine_prologue (func_addr, limit, fi->frame, get_frame_saved_regs (fi), fi);
480 /* Else we're out of luck (can't debug completely stripped code).
485 /* Given a GDB frame, determine the address of the calling function's
486 frame. This will be used to create a new GDB frame struct, and
487 then INIT_EXTRA_FRAME_INFO and DEPRECATED_INIT_FRAME_PC will be
488 called for the new frame.
490 For us, the frame address is its stack pointer value, so we look up
491 the function prologue to determine the caller's sp value, and return it. */
494 h8300_frame_chain (struct frame_info *thisframe)
496 if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (thisframe), thisframe->frame, thisframe->frame))
497 { /* initialize the from_pc now */
498 thisframe->extra_info->from_pc =
499 deprecated_read_register_dummy (get_frame_pc (thisframe), thisframe->frame,
501 return thisframe->frame;
503 return get_frame_saved_regs (thisframe)[E_SP_REGNUM];
506 /* Return the saved PC from this frame.
508 If the frame has a memory copy of SRP_REGNUM, use that. If not,
509 just use the register SRP_REGNUM itself. */
512 h8300_frame_saved_pc (struct frame_info *frame)
514 if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame), frame->frame, frame->frame))
515 return deprecated_read_register_dummy (get_frame_pc (frame), frame->frame,
518 return frame->extra_info->from_pc;
522 h8300_init_extra_frame_info (int fromleaf, struct frame_info *fi)
526 frame_extra_info_zalloc (fi, sizeof (struct frame_extra_info));
527 fi->extra_info->from_pc = 0;
528 fi->extra_info->args_pointer = 0; /* Unknown */
529 fi->extra_info->locals_pointer = 0; /* Unknown */
531 if (!get_frame_pc (fi))
534 deprecated_update_frame_pc_hack (fi, h8300_frame_saved_pc (fi->next));
536 h8300_frame_init_saved_regs (fi);
541 h8300_frame_locals_address (struct frame_info *fi)
543 if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), fi->frame, fi->frame))
544 return (CORE_ADDR) 0; /* Not sure what else to do... */
545 return fi->extra_info->locals_pointer;
548 /* Return the address of the argument block for the frame
549 described by FI. Returns 0 if the address is unknown. */
552 h8300_frame_args_address (struct frame_info *fi)
554 if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), fi->frame, fi->frame))
555 return (CORE_ADDR) 0; /* Not sure what else to do... */
556 return fi->extra_info->args_pointer;
559 /* Round N up or down to the nearest multiple of UNIT.
560 Evaluate N only once, UNIT several times.
561 UNIT must be a power of two. */
562 #define round_up(n, unit) (((n) + (unit) - 1) & -(unit))
563 #define round_down(n, unit) ((n) & -(unit))
565 /* Function: push_arguments
566 Setup the function arguments for calling a function in the inferior.
567 In this discussion, a `word' is 16 bits on the H8/300s, and 32 bits
570 There are actually two ABI's here: -mquickcall (the default) and
571 -mno-quickcall. With -mno-quickcall, all arguments are passed on
572 the stack after the return address, word-aligned. With
573 -mquickcall, GCC tries to use r0 -- r2 to pass registers. Since
574 GCC doesn't indicate in the object file which ABI was used to
575 compile it, GDB only supports the default --- -mquickcall.
577 Here are the rules for -mquickcall, in detail:
579 Each argument, whether scalar or aggregate, is padded to occupy a
580 whole number of words. Arguments smaller than a word are padded at
581 the most significant end; those larger than a word are padded at
582 the least significant end.
584 The initial arguments are passed in r0 -- r2. Earlier arguments go in
585 lower-numbered registers. Multi-word arguments are passed in
586 consecutive registers, with the most significant end in the
587 lower-numbered register.
589 If an argument doesn't fit entirely in the remaining registers, it
590 is passed entirely on the stack. Stack arguments begin just after
591 the return address. Once an argument has overflowed onto the stack
592 this way, all subsequent arguments are passed on the stack.
594 The above rule has odd consequences. For example, on the h8/300s,
595 if a function takes two longs and an int as arguments:
596 - the first long will be passed in r0/r1,
597 - the second long will be passed entirely on the stack, since it
599 - and the int will be passed on the stack, even though it could fit
602 A weird exception: if an argument is larger than a word, but not a
603 whole number of words in length (before padding), it is passed on
604 the stack following the rules for stack arguments above, even if
605 there are sufficient registers available to hold it. Stranger
606 still, the argument registers are still `used up' --- even though
607 there's nothing in them.
609 So, for example, on the h8/300s, if a function expects a three-byte
610 structure and an int, the structure will go on the stack, and the
611 int will go in r2, not r0.
613 If the function returns an aggregate type (struct, union, or class)
614 by value, the caller must allocate space to hold the return value,
615 and pass the callee a pointer to this space as an invisible first
618 For varargs functions, the last fixed argument and all the variable
619 arguments are always passed on the stack. This means that calls to
620 varargs functions don't work properly unless there is a prototype
623 Basically, this ABI is not good, for the following reasons:
624 - You can't call vararg functions properly unless a prototype is in scope.
625 - Structure passing is inconsistent, to no purpose I can see.
626 - It often wastes argument registers, of which there are only three
630 h8300_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
631 int struct_return, CORE_ADDR struct_addr)
633 int stack_align, stack_alloc, stack_offset;
634 int wordsize = BINWORD;
638 /* First, make sure the stack is properly aligned. */
639 sp = round_down (sp, wordsize);
641 /* Now make sure there's space on the stack for the arguments. We
642 may over-allocate a little here, but that won't hurt anything. */
644 for (argument = 0; argument < nargs; argument++)
645 stack_alloc += round_up (TYPE_LENGTH (VALUE_TYPE (args[argument])),
649 /* Now load as many arguments as possible into registers, and push
650 the rest onto the stack. */
654 /* If we're returning a structure by value, then we must pass a
655 pointer to the buffer for the return value as an invisible first
658 write_register (reg++, struct_addr);
660 for (argument = 0; argument < nargs; argument++)
662 struct type *type = VALUE_TYPE (args[argument]);
663 int len = TYPE_LENGTH (type);
664 char *contents = (char *) VALUE_CONTENTS (args[argument]);
666 /* Pad the argument appropriately. */
667 int padded_len = round_up (len, wordsize);
668 char *padded = alloca (padded_len);
670 memset (padded, 0, padded_len);
671 memcpy (len < wordsize ? padded + padded_len - len : padded,
674 /* Could the argument fit in the remaining registers? */
675 if (padded_len <= (E_ARGLAST_REGNUM - reg + 1) * wordsize)
677 /* Are we going to pass it on the stack anyway, for no good
679 if (len > wordsize && len % wordsize)
681 /* I feel so unclean. */
682 write_memory (sp + stack_offset, padded, padded_len);
683 stack_offset += padded_len;
685 /* That's right --- even though we passed the argument
686 on the stack, we consume the registers anyway! Love
688 reg += padded_len / wordsize;
692 /* Heavens to Betsy --- it's really going in registers!
693 It would be nice if we could use write_register_bytes
694 here, but on the h8/300s, there are gaps between
695 the registers in the register file. */
698 for (offset = 0; offset < padded_len; offset += wordsize)
700 ULONGEST word = extract_address (padded + offset, wordsize);
701 write_register (reg++, word);
707 /* It doesn't fit in registers! Onto the stack it goes. */
708 write_memory (sp + stack_offset, padded, padded_len);
709 stack_offset += padded_len;
711 /* Once one argument has spilled onto the stack, all
712 subsequent arguments go on the stack. */
713 reg = E_ARGLAST_REGNUM + 1;
720 /* Function: push_return_address
721 Setup the return address for a dummy frame, as called by
722 call_function_by_hand. Only necessary when you are using an
723 empty CALL_DUMMY, ie. the target will not actually be executing
724 a JSR/BSR instruction. */
727 h8300_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
729 unsigned char buf[4];
730 int wordsize = BINWORD;
733 store_unsigned_integer (buf, wordsize, CALL_DUMMY_ADDRESS ());
734 write_memory (sp, buf, wordsize);
738 /* Function: h8300_pop_frame
739 Restore the machine to the state it had before the current frame
740 was created. Usually used either by the "RETURN" command, or by
741 call_function_by_hand after the dummy_frame is finished. */
744 h8300_pop_frame (void)
747 struct frame_info *frame = get_current_frame ();
749 if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame), frame->frame, frame->frame))
751 generic_pop_dummy_frame ();
755 for (regno = 0; regno < 8; regno++)
757 /* Don't forget E_SP_REGNUM is a frame_saved_regs struct is the
758 actual value we want, not the address of the value we want. */
759 if (get_frame_saved_regs (frame)[regno] && regno != E_SP_REGNUM)
760 write_register (regno,
761 read_memory_integer (get_frame_saved_regs (frame)[regno],
763 else if (get_frame_saved_regs (frame)[regno] && regno == E_SP_REGNUM)
764 write_register (regno, frame->frame + 2 * BINWORD);
767 /* Don't forget to update the PC too! */
768 write_register (E_PC_REGNUM, frame->extra_info->from_pc);
770 flush_cached_frames ();
773 /* Function: extract_return_value
774 Figure out where in REGBUF the called function has left its return value.
775 Copy that into VALBUF. Be sure to account for CPU type. */
778 h8300_extract_return_value (struct type *type, char *regbuf, char *valbuf)
780 int wordsize = BINWORD;
781 int len = TYPE_LENGTH (type);
786 case 2: /* (short), (int) */
787 memcpy (valbuf, regbuf + REGISTER_BYTE (0) + (wordsize - len), len);
789 case 4: /* (long), (float) */
792 memcpy (valbuf, regbuf + REGISTER_BYTE (0), 4);
796 memcpy (valbuf, regbuf + REGISTER_BYTE (0), 2);
797 memcpy (valbuf + 2, regbuf + REGISTER_BYTE (1), 2);
800 case 8: /* (double) (doesn't seem to happen, which is good,
801 because this almost certainly isn't right. */
802 error ("I don't know how a double is returned.");
807 /* Function: store_return_value
808 Place the appropriate value in the appropriate registers.
809 Primarily used by the RETURN command. */
812 h8300_store_return_value (struct type *type, char *valbuf)
815 int wordsize = BINWORD;
816 int len = TYPE_LENGTH (type);
821 case 2: /* short, int */
822 regval = extract_address (valbuf, len);
823 write_register (0, regval);
825 case 4: /* long, float */
826 regval = extract_address (valbuf, len);
829 write_register (0, regval);
833 write_register (0, regval >> 16);
834 write_register (1, regval & 0xffff);
837 case 8: /* presumeably double, but doesn't seem to happen */
838 error ("I don't know how to return a double.");
843 static struct cmd_list_element *setmachinelist;
846 h8300_register_name (int regno)
848 /* The register names change depending on whether the h8300h processor
850 static char *h8300_register_names[] = {
851 "r0", "r1", "r2", "r3", "r4", "r5", "r6",
852 "sp", "ccr","pc","cycles", "tick", "inst", ""
854 static char *h8300s_register_names[] = {
855 "er0", "er1", "er2", "er3", "er4", "er5", "er6",
856 "sp", "ccr", "pc", "cycles", "exr", "tick", "inst"
858 char **register_names =
859 h8300smode ? h8300s_register_names : h8300_register_names;
860 if (regno < 0 || regno >= E_NUM_REGS)
861 internal_error (__FILE__, __LINE__,
862 "h8300_register_name: illegal register number %d", regno);
864 return register_names[regno];
868 h8300_print_register (struct gdbarch *gdbarch, struct ui_file *file,
869 struct frame_info *frame, int regno)
873 const char *name = h8300_register_name (regno);
878 /* FIXME: cagney/2002-10-22: The code below assumes that VAL is at
879 least 4 bytes (32 bits) in size and hence is large enough to hold
880 the largest h8300 register. Should instead be using ULONGEST and
881 the phex() functions. */
882 gdb_assert (sizeof (val) >= 4);
883 frame_read_unsigned_register (frame, regno, &rval);
886 fprintf_filtered (file, "%-14s ", name);
890 fprintf_filtered (file, "0x%08lx %-8ld", val, val);
892 fprintf_filtered (file, "0x%-8lx %-8ld", val, val);
897 fprintf_filtered (file, "0x%04lx %-4ld", val, val);
899 fprintf_filtered (file, "0x%-4lx %-4ld", val, val);
901 if (regno == E_CCR_REGNUM)
905 unsigned char b[h8300h_reg_size];
907 frame_register_read (deprecated_selected_frame, regno, b);
908 l = b[REGISTER_VIRTUAL_SIZE (E_CCR_REGNUM) - 1];
909 fprintf_filtered (file, "\t");
910 fprintf_filtered (file, "I-%d ", (l & 0x80) != 0);
911 fprintf_filtered (file, "UI-%d ", (l & 0x40) != 0);
912 fprintf_filtered (file, "H-%d ", (l & 0x20) != 0);
913 fprintf_filtered (file, "U-%d ", (l & 0x10) != 0);
918 fprintf_filtered (file, "N-%d ", N);
919 fprintf_filtered (file, "Z-%d ", Z);
920 fprintf_filtered (file, "V-%d ", V);
921 fprintf_filtered (file, "C-%d ", C);
923 fprintf_filtered (file, "u> ");
925 fprintf_filtered (file, "u<= ");
927 fprintf_filtered (file, "u>= ");
929 fprintf_filtered (file, "u< ");
931 fprintf_filtered (file, "!= ");
933 fprintf_filtered (file, "== ");
935 fprintf_filtered (file, ">= ");
937 fprintf_filtered (file, "< ");
938 if ((Z | (N ^ V)) == 0)
939 fprintf_filtered (file, "> ");
940 if ((Z | (N ^ V)) == 1)
941 fprintf_filtered (file, "<= ");
943 else if (regno == E_EXR_REGNUM && h8300smode)
946 unsigned char b[h8300h_reg_size];
948 frame_register_read (deprecated_selected_frame, regno, b);
949 l = b[REGISTER_VIRTUAL_SIZE (E_EXR_REGNUM) - 1];
950 fprintf_filtered (file, "\t");
951 fprintf_filtered (file, "T-%d - - - ", (l & 0x80) != 0);
952 fprintf_filtered (file, "I2-%d ", (l & 4) != 0);
953 fprintf_filtered (file, "I1-%d ", (l & 2) != 0);
954 fprintf_filtered (file, "I0-%d", (l & 1) != 0);
956 fprintf_filtered (file, "\n");
960 h8300_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
961 struct frame_info *frame, int regno, int cpregs)
964 for (regno = 0; regno < E_NUM_REGS; ++regno)
965 h8300_print_register (gdbarch, file, frame, regno);
967 h8300_print_register (gdbarch, file, frame, regno);
971 h8300_saved_pc_after_call (struct frame_info *ignore)
973 return read_memory_unsigned_integer (read_register (E_SP_REGNUM), BINWORD);
977 h8300_register_byte (int regno)
979 if (regno < 0 || regno >= E_NUM_REGS)
980 internal_error (__FILE__, __LINE__,
981 "h8300_register_byte: illegal register number %d", regno);
983 return regno * BINWORD;
987 h8300_register_raw_size (int regno)
989 if (regno < 0 || regno >= E_NUM_REGS)
990 internal_error (__FILE__, __LINE__,
991 "h8300_register_raw_size: illegal register number %d",
998 h8300_register_virtual_type (int regno)
1000 if (regno < 0 || regno >= E_NUM_REGS)
1001 internal_error (__FILE__, __LINE__,
1002 "h8300_register_virtual_type: illegal register number %d",
1006 builtin_type_unsigned_long : builtin_type_unsigned_short;
1010 h8300_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
1012 write_register (0, addr);
1016 h8300_use_struct_convention (int gcc_p, struct type *type)
1022 h8300_extract_struct_value_address (char *regbuf)
1024 return extract_address (regbuf + h8300_register_byte (E_ARG0_REGNUM),
1025 h8300_register_raw_size (E_ARG0_REGNUM));
1028 const static unsigned char *
1029 h8300_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
1031 /*static unsigned char breakpoint[] = { 0x7A, 0xFF };*/ /* ??? */
1032 static unsigned char breakpoint[] = { 0x01, 0x80 }; /* Sleep */
1034 *lenptr = sizeof (breakpoint);
1039 h8300_print_float_info (struct gdbarch *gdbarch, struct ui_file *file,
1040 struct frame_info *frame, const char *args)
1042 fprintf_filtered (file, "\
1043 No floating-point info available for this processor.\n");
1046 static struct gdbarch *
1047 h8300_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1049 static LONGEST call_dummy_words[1] = { 0 };
1050 struct gdbarch_tdep *tdep = NULL;
1051 struct gdbarch *gdbarch;
1053 arches = gdbarch_list_lookup_by_info (arches, &info);
1055 return arches->gdbarch;
1058 tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
1061 if (info.bfd_arch_info->arch != bfd_arch_h8300)
1064 switch (info.bfd_arch_info->mach)
1066 case bfd_mach_h8300:
1070 case bfd_mach_h8300h:
1074 case bfd_mach_h8300s:
1080 gdbarch = gdbarch_alloc (&info, 0);
1082 /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
1083 ready to unwind the PC first (see frame.c:get_prev_frame()). */
1084 set_gdbarch_deprecated_init_frame_pc (gdbarch, init_frame_pc_default);
1087 * Basic register fields and methods.
1090 set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
1091 set_gdbarch_num_pseudo_regs (gdbarch, 0);
1092 set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
1093 set_gdbarch_fp_regnum (gdbarch, E_FP_REGNUM);
1094 set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
1095 set_gdbarch_register_name (gdbarch, h8300_register_name);
1096 set_gdbarch_register_size (gdbarch, BINWORD);
1097 set_gdbarch_register_bytes (gdbarch, E_NUM_REGS * BINWORD);
1098 set_gdbarch_register_byte (gdbarch, h8300_register_byte);
1099 set_gdbarch_register_raw_size (gdbarch, h8300_register_raw_size);
1100 set_gdbarch_max_register_raw_size (gdbarch, h8300h_reg_size);
1101 set_gdbarch_register_virtual_size (gdbarch, h8300_register_raw_size);
1102 set_gdbarch_max_register_virtual_size (gdbarch, h8300h_reg_size);
1103 set_gdbarch_register_virtual_type (gdbarch, h8300_register_virtual_type);
1104 set_gdbarch_print_registers_info (gdbarch, h8300_print_registers_info);
1105 set_gdbarch_print_float_info (gdbarch, h8300_print_float_info);
1110 set_gdbarch_init_extra_frame_info (gdbarch, h8300_init_extra_frame_info);
1111 set_gdbarch_frame_init_saved_regs (gdbarch, h8300_frame_init_saved_regs);
1112 set_gdbarch_frame_chain (gdbarch, h8300_frame_chain);
1113 set_gdbarch_saved_pc_after_call (gdbarch, h8300_saved_pc_after_call);
1114 set_gdbarch_frame_saved_pc (gdbarch, h8300_frame_saved_pc);
1115 set_gdbarch_skip_prologue (gdbarch, h8300_skip_prologue);
1116 set_gdbarch_frame_args_address (gdbarch, h8300_frame_args_address);
1117 set_gdbarch_frame_locals_address (gdbarch, h8300_frame_locals_address);
1122 /* Stack grows up. */
1123 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1124 /* PC stops zero byte after a trap instruction
1125 (which means: exactly on trap instruction). */
1126 set_gdbarch_decr_pc_after_break (gdbarch, 0);
1127 /* This value is almost never non-zero... */
1128 set_gdbarch_function_start_offset (gdbarch, 0);
1129 /* This value is almost never non-zero... */
1130 set_gdbarch_frame_args_skip (gdbarch, 0);
1131 /* OK to default this value to 'unknown'. */
1132 set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
1133 set_gdbarch_frameless_function_invocation (gdbarch,
1134 frameless_look_for_prologue);
1139 * These values and methods are used when gdb calls a target function. */
1140 set_gdbarch_push_dummy_frame (gdbarch, generic_push_dummy_frame);
1141 set_gdbarch_push_return_address (gdbarch, h8300_push_return_address);
1142 set_gdbarch_deprecated_extract_return_value (gdbarch, h8300_extract_return_value);
1143 set_gdbarch_push_arguments (gdbarch, h8300_push_arguments);
1144 set_gdbarch_pop_frame (gdbarch, h8300_pop_frame);
1145 set_gdbarch_store_struct_return (gdbarch, h8300_store_struct_return);
1146 set_gdbarch_deprecated_store_return_value (gdbarch, h8300_store_return_value);
1147 set_gdbarch_deprecated_extract_struct_value_address (gdbarch, h8300_extract_struct_value_address);
1148 set_gdbarch_use_struct_convention (gdbarch, h8300_use_struct_convention);
1149 set_gdbarch_call_dummy_address (gdbarch, entry_point_address);
1150 set_gdbarch_call_dummy_start_offset (gdbarch, 0);
1151 set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
1152 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
1153 set_gdbarch_call_dummy_length (gdbarch, 0);
1154 set_gdbarch_call_dummy_p (gdbarch, 1);
1155 set_gdbarch_call_dummy_words (gdbarch, call_dummy_words);
1156 set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
1157 set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
1158 /* set_gdbarch_call_dummy_stack_adjust */
1159 set_gdbarch_fix_call_dummy (gdbarch, generic_fix_call_dummy);
1160 set_gdbarch_breakpoint_from_pc (gdbarch, h8300_breakpoint_from_pc);
1162 set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1163 set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1164 set_gdbarch_ptr_bit (gdbarch, BINWORD * TARGET_CHAR_BIT);
1165 set_gdbarch_addr_bit (gdbarch, BINWORD * TARGET_CHAR_BIT);
1167 /* set_gdbarch_stack_align (gdbarch, SOME_stack_align); */
1168 set_gdbarch_extra_stack_alignment_needed (gdbarch, 0);
1169 set_gdbarch_believe_pcc_promotion (gdbarch, 1);
1175 _initialize_h8300_tdep (void)
1177 tm_print_insn = gdb_print_insn_h8300;
1178 register_gdbarch_init (bfd_arch_h8300, h8300_gdbarch_init);