1 /* Target-dependent code for Mitsubishi D10V, for GDB.
2 Copyright (C) 1996, 1997 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20 /* Contributed by Martin Hunt, hunt@cygnus.com */
29 #include "gdb_string.h"
36 struct frame_extra_info
43 /* these are the addresses the D10V-EVA board maps data */
44 /* and instruction memory to. */
46 #define DMEM_START 0x0000000
47 #define IMEM_START 0x1000000
48 #define STACK_START 0x0007ffe
50 /* d10v register naming conventions */
52 #define ARG1_REGNUM R0_REGNUM
54 #define RET1_REGNUM R0_REGNUM
58 extern void _initialize_d10v_tdep
PARAMS ((void));
60 static void d10v_eva_prepare_to_trace
PARAMS ((void));
62 static void d10v_eva_get_trace_data
PARAMS ((void));
64 static int prologue_find_regs
PARAMS ((unsigned short op
, struct frame_info
*fi
, CORE_ADDR addr
));
66 extern void d10v_frame_init_saved_regs
PARAMS ((struct frame_info
*));
68 static void do_d10v_pop_frame
PARAMS ((struct frame_info
*fi
));
71 extern void remote_d10v_translate_xfer_address
PARAMS ((CORE_ADDR gdb_addr
, int gdb_len
, CORE_ADDR
*rem_addr
, int *rem_len
));
74 d10v_frame_chain_valid (chain
, frame
)
76 struct frame_info
*frame
; /* not used here */
78 return ((chain
) != 0 && (frame
) != 0 && (frame
)->pc
> IMEM_START
);
82 /* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of
83 EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc
84 and TYPE is the type (which is known to be struct, union or array).
86 The d10v returns anything less than 8 bytes in size in
90 d10v_use_struct_convention (gcc_p
, type
)
94 return (TYPE_LENGTH (type
) > 8);
99 d10v_breakpoint_from_pc (pcptr
, lenptr
)
103 static unsigned char breakpoint
[] = {0x2f, 0x90, 0x5e, 0x00};
104 *lenptr
= sizeof (breakpoint
);
109 d10v_register_name (reg_nr
)
112 static char *register_names
[] = {
113 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
114 "r8", "r9", "r10","r11","r12", "r13", "r14","r15",
115 "psw","bpsw","pc","bpc", "cr4", "cr5", "cr6", "rpt_c",
116 "rpt_s","rpt_e", "mod_s", "mod_e", "cr12", "cr13", "iba", "cr15",
117 "imap0","imap1","dmap","a0", "a1"
121 if (reg_nr
>= (sizeof (register_names
) / sizeof (*register_names
)))
123 return register_names
[reg_nr
];
127 /* Index within `registers' of the first byte of the space for
131 d10v_register_byte (reg_nr
)
134 if (reg_nr
> A0_REGNUM
)
135 return ((reg_nr
- A0_REGNUM
) * 8 + (A0_REGNUM
* 2));
140 /* Number of bytes of storage in the actual machine representation for
144 d10v_register_raw_size (reg_nr
)
147 if (reg_nr
>= A0_REGNUM
)
153 /* Number of bytes of storage in the program's representation
157 d10v_register_virtual_size (reg_nr
)
160 if (reg_nr
>= A0_REGNUM
)
162 else if (reg_nr
== PC_REGNUM
|| reg_nr
== SP_REGNUM
)
168 /* Return the GDB type object for the "standard" data type
169 of data in register N. */
172 d10v_register_virtual_type (reg_nr
)
175 if (reg_nr
>= A0_REGNUM
)
176 return builtin_type_long_long
;
177 else if (reg_nr
== PC_REGNUM
|| reg_nr
== SP_REGNUM
)
178 return builtin_type_long
;
180 return builtin_type_short
;
183 /* convert $pc and $sp to/from virtual addresses */
185 d10v_register_convertible (nr
)
188 return ((nr
) == PC_REGNUM
|| (nr
) == SP_REGNUM
);
192 d10v_register_convert_to_virtual (regnum
, type
, from
, to
)
198 ULONGEST x
= extract_unsigned_integer (from
, REGISTER_RAW_SIZE (regnum
));
199 if (regnum
== PC_REGNUM
)
200 x
= (x
<< 2) | IMEM_START
;
203 store_unsigned_integer (to
, TYPE_LENGTH (type
), x
);
207 d10v_register_convert_to_raw (type
, regnum
, from
, to
)
213 ULONGEST x
= extract_unsigned_integer (from
, TYPE_LENGTH (type
));
215 if (regnum
== PC_REGNUM
)
217 store_unsigned_integer (to
, 2, x
);
225 return ((x
) | DMEM_START
);
232 return (((x
) << 2) | IMEM_START
);
239 return (((x
) & 0x3000000) == DMEM_START
);
246 return (((x
) & 0x3000000) == IMEM_START
);
251 d10v_convert_iaddr_to_raw (x
)
254 return (((x
) >> 2) & 0xffff);
258 d10v_convert_daddr_to_raw(x
)
261 return ((x
) & 0xffff);
264 /* Store the address of the place in which to copy the structure the
265 subroutine will return. This is called from call_function.
267 We store structs through a pointer passed in the first Argument
271 d10v_store_struct_return (addr
, sp
)
275 write_register (ARG1_REGNUM
, (addr
));
278 /* Write into appropriate registers a function return value
279 of type TYPE, given in virtual format.
281 Things always get returned in RET1_REGNUM, RET2_REGNUM, ... */
284 d10v_store_return_value (type
,valbuf
)
288 write_register_bytes (REGISTER_BYTE (RET1_REGNUM
),
293 /* Extract from an array REGBUF containing the (raw) register state
294 the address in which a function should return its structure value,
295 as a CORE_ADDR (or an expression that can be used as one). */
298 d10v_extract_struct_value_address (regbuf
)
301 return (extract_address ((regbuf
) + REGISTER_BYTE (ARG1_REGNUM
),
302 REGISTER_RAW_SIZE (ARG1_REGNUM
))
307 d10v_frame_saved_pc (frame
)
308 struct frame_info
*frame
;
310 return ((frame
)->extra_info
->return_pc
);
314 d10v_frame_args_address (fi
)
315 struct frame_info
*fi
;
321 d10v_frame_locals_address (fi
)
322 struct frame_info
*fi
;
327 /* Immediately after a function call, return the saved pc. We can't
328 use frame->return_pc beause that is determined by reading R13 off
329 the stack and that may not be written yet. */
332 d10v_saved_pc_after_call (frame
)
333 struct frame_info
*frame
;
335 return ((read_register(LR_REGNUM
) << 2)
339 /* Discard from the stack the innermost frame, restoring all saved
345 generic_pop_current_frame (do_d10v_pop_frame
);
349 do_d10v_pop_frame (fi
)
350 struct frame_info
*fi
;
357 /* fill out fsr with the address of where each */
358 /* register was stored in the frame */
359 d10v_frame_init_saved_regs (fi
);
361 /* now update the current registers with the old values */
362 for (regnum
= A0_REGNUM
; regnum
< A0_REGNUM
+2 ; regnum
++)
364 if (fi
->saved_regs
[regnum
])
366 read_memory (fi
->saved_regs
[regnum
], raw_buffer
, REGISTER_RAW_SIZE(regnum
));
367 write_register_bytes (REGISTER_BYTE (regnum
), raw_buffer
, REGISTER_RAW_SIZE(regnum
));
370 for (regnum
= 0; regnum
< SP_REGNUM
; regnum
++)
372 if (fi
->saved_regs
[regnum
])
374 write_register (regnum
, read_memory_unsigned_integer (fi
->saved_regs
[regnum
], REGISTER_RAW_SIZE(regnum
)));
377 if (fi
->saved_regs
[PSW_REGNUM
])
379 write_register (PSW_REGNUM
, read_memory_unsigned_integer (fi
->saved_regs
[PSW_REGNUM
], REGISTER_RAW_SIZE(PSW_REGNUM
)));
382 write_register (PC_REGNUM
, read_register (LR_REGNUM
));
383 write_register (SP_REGNUM
, fp
+ fi
->extra_info
->size
);
384 target_store_registers (-1);
385 flush_cached_frames ();
393 if ((op
& 0x7E1F) == 0x6C1F)
397 if ((op
& 0x7E3F) == 0x6E1F)
401 if ((op
& 0x7FE1) == 0x01E1)
413 if ((op
& 0x7E1F) == 0x681E)
417 if ((op
& 0x7E3F) == 0x3A1E)
424 d10v_skip_prologue (pc
)
428 unsigned short op1
, op2
;
429 CORE_ADDR func_addr
, func_end
;
430 struct symtab_and_line sal
;
432 /* If we have line debugging information, then the end of the */
433 /* prologue should the first assembly instruction of the first source line */
434 if (find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
436 sal
= find_pc_line (func_addr
, 0);
437 if ( sal
.end
&& sal
.end
< func_end
)
441 if (target_read_memory (pc
, (char *)&op
, 4))
442 return pc
; /* Can't access it -- assume no prologue. */
446 op
= (unsigned long)read_memory_integer (pc
, 4);
447 if ((op
& 0xC0000000) == 0xC0000000)
449 /* long instruction */
450 if ( ((op
& 0x3FFF0000) != 0x01FF0000) && /* add3 sp,sp,n */
451 ((op
& 0x3F0F0000) != 0x340F0000) && /* st rn, @(offset,sp) */
452 ((op
& 0x3F1F0000) != 0x350F0000)) /* st2w rn, @(offset,sp) */
457 /* short instructions */
458 if ((op
& 0xC0000000) == 0x80000000)
460 op2
= (op
& 0x3FFF8000) >> 15;
465 op1
= (op
& 0x3FFF8000) >> 15;
468 if (check_prologue(op1
))
470 if (!check_prologue(op2
))
472 /* if the previous opcode was really part of the prologue */
473 /* and not just a NOP, then we want to break after both instructions */
487 /* Given a GDB frame, determine the address of the calling function's frame.
488 This will be used to create a new GDB frame struct, and then
489 INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
493 d10v_frame_chain (fi
)
494 struct frame_info
*fi
;
496 d10v_frame_init_saved_regs (fi
);
498 if (fi
->extra_info
->return_pc
== IMEM_START
499 || inside_entry_file (fi
->extra_info
->return_pc
))
502 if (!fi
->saved_regs
[FP_REGNUM
])
504 if (!fi
->saved_regs
[SP_REGNUM
]
505 || fi
->saved_regs
[SP_REGNUM
] == STACK_START
)
508 return fi
->saved_regs
[SP_REGNUM
];
511 if (!read_memory_unsigned_integer(fi
->saved_regs
[FP_REGNUM
],
512 REGISTER_RAW_SIZE(FP_REGNUM
)))
515 return D10V_MAKE_DADDR (read_memory_unsigned_integer (fi
->saved_regs
[FP_REGNUM
],
516 REGISTER_RAW_SIZE (FP_REGNUM
)));
519 static int next_addr
, uses_frame
;
522 prologue_find_regs (op
, fi
, addr
)
524 struct frame_info
*fi
;
530 if ((op
& 0x7E1F) == 0x6C1F)
532 n
= (op
& 0x1E0) >> 5;
534 fi
->saved_regs
[n
] = next_addr
;
539 else if ((op
& 0x7E3F) == 0x6E1F)
541 n
= (op
& 0x1E0) >> 5;
543 fi
->saved_regs
[n
] = next_addr
;
544 fi
->saved_regs
[n
+1] = next_addr
+2;
549 if ((op
& 0x7FE1) == 0x01E1)
551 n
= (op
& 0x1E) >> 1;
570 if ((op
& 0x7E1F) == 0x681E)
572 n
= (op
& 0x1E0) >> 5;
573 fi
->saved_regs
[n
] = next_addr
;
578 if ((op
& 0x7E3F) == 0x3A1E)
580 n
= (op
& 0x1E0) >> 5;
581 fi
->saved_regs
[n
] = next_addr
;
582 fi
->saved_regs
[n
+1] = next_addr
+2;
589 /* Put here the code to store, into fi->saved_regs, the addresses of
590 the saved registers of frame described by FRAME_INFO. This
591 includes special registers such as pc and fp saved in special ways
592 in the stack frame. sp is even more special: the address we return
593 for it IS the sp for the next frame. */
596 d10v_frame_init_saved_regs (fi
)
597 struct frame_info
*fi
;
601 unsigned short op1
, op2
;
605 memset (fi
->saved_regs
, 0, SIZEOF_FRAME_SAVED_REGS
);
608 pc
= get_pc_function_start (fi
->pc
);
613 op
= (unsigned long)read_memory_integer (pc
, 4);
614 if ((op
& 0xC0000000) == 0xC0000000)
616 /* long instruction */
617 if ((op
& 0x3FFF0000) == 0x01FF0000)
620 short n
= op
& 0xFFFF;
623 else if ((op
& 0x3F0F0000) == 0x340F0000)
625 /* st rn, @(offset,sp) */
626 short offset
= op
& 0xFFFF;
627 short n
= (op
>> 20) & 0xF;
628 fi
->saved_regs
[n
] = next_addr
+ offset
;
630 else if ((op
& 0x3F1F0000) == 0x350F0000)
632 /* st2w rn, @(offset,sp) */
633 short offset
= op
& 0xFFFF;
634 short n
= (op
>> 20) & 0xF;
635 fi
->saved_regs
[n
] = next_addr
+ offset
;
636 fi
->saved_regs
[n
+1] = next_addr
+ offset
+ 2;
643 /* short instructions */
644 if ((op
& 0xC0000000) == 0x80000000)
646 op2
= (op
& 0x3FFF8000) >> 15;
651 op1
= (op
& 0x3FFF8000) >> 15;
654 if (!prologue_find_regs(op1
, fi
, pc
) || !prologue_find_regs(op2
, fi
, pc
))
660 fi
->extra_info
->size
= -next_addr
;
663 fp
= D10V_MAKE_DADDR (read_register(SP_REGNUM
));
665 for (i
=0; i
<NUM_REGS
-1; i
++)
666 if (fi
->saved_regs
[i
])
668 fi
->saved_regs
[i
] = fp
- (next_addr
- fi
->saved_regs
[i
]);
671 if (fi
->saved_regs
[LR_REGNUM
])
673 CORE_ADDR return_pc
= read_memory_unsigned_integer (fi
->saved_regs
[LR_REGNUM
], REGISTER_RAW_SIZE (LR_REGNUM
));
674 fi
->extra_info
->return_pc
= D10V_MAKE_IADDR (return_pc
);
678 fi
->extra_info
->return_pc
= D10V_MAKE_IADDR (read_register(LR_REGNUM
));
681 /* th SP is not normally (ever?) saved, but check anyway */
682 if (!fi
->saved_regs
[SP_REGNUM
])
684 /* if the FP was saved, that means the current FP is valid, */
685 /* otherwise, it isn't being used, so we use the SP instead */
687 fi
->saved_regs
[SP_REGNUM
] = read_register(FP_REGNUM
) + fi
->extra_info
->size
;
690 fi
->saved_regs
[SP_REGNUM
] = fp
+ fi
->extra_info
->size
;
691 fi
->extra_info
->frameless
= 1;
692 fi
->saved_regs
[FP_REGNUM
] = 0;
698 d10v_init_extra_frame_info (fromleaf
, fi
)
700 struct frame_info
*fi
;
702 fi
->extra_info
= (struct frame_extra_info
*)
703 frame_obstack_alloc (sizeof (struct frame_extra_info
));
704 frame_saved_regs_zalloc (fi
);
706 fi
->extra_info
->frameless
= 0;
707 fi
->extra_info
->size
= 0;
708 fi
->extra_info
->return_pc
= 0;
710 /* The call dummy doesn't save any registers on the stack, so we can
712 if (PC_IN_CALL_DUMMY (fi
->pc
, fi
->frame
, fi
->frame
))
718 d10v_frame_init_saved_regs (fi
);
723 show_regs (args
, from_tty
)
728 printf_filtered ("PC=%04x (0x%x) PSW=%04x RPT_S=%04x RPT_E=%04x RPT_C=%04x\n",
729 read_register (PC_REGNUM
), D10V_MAKE_IADDR (read_register (PC_REGNUM
)),
730 read_register (PSW_REGNUM
),
734 printf_filtered ("R0-R7 %04x %04x %04x %04x %04x %04x %04x %04x\n",
743 printf_filtered ("R8-R15 %04x %04x %04x %04x %04x %04x %04x %04x\n",
752 printf_filtered ("IMAP0 %04x IMAP1 %04x DMAP %04x\n",
753 read_register (IMAP0_REGNUM
),
754 read_register (IMAP1_REGNUM
),
755 read_register (DMAP_REGNUM
));
756 printf_filtered ("A0-A1");
757 for (a
= A0_REGNUM
; a
<= A0_REGNUM
+ 1; a
++)
759 char num
[MAX_REGISTER_RAW_SIZE
];
761 printf_filtered (" ");
762 read_register_gen (a
, (char *)&num
);
763 for (i
= 0; i
< MAX_REGISTER_RAW_SIZE
; i
++)
765 printf_filtered ("%02x", (num
[i
] & 0xff));
768 printf_filtered ("\n");
779 save_pid
= inferior_pid
;
781 pc
= (int) read_register (PC_REGNUM
);
782 inferior_pid
= save_pid
;
783 retval
= D10V_MAKE_IADDR (pc
);
788 d10v_write_pc (val
, pid
)
794 save_pid
= inferior_pid
;
796 write_register (PC_REGNUM
, D10V_CONVERT_IADDR_TO_RAW (val
));
797 inferior_pid
= save_pid
;
803 return (D10V_MAKE_DADDR (read_register (SP_REGNUM
)));
810 write_register (SP_REGNUM
, D10V_CONVERT_DADDR_TO_RAW (val
));
817 write_register (FP_REGNUM
, D10V_CONVERT_DADDR_TO_RAW (val
));
823 return (D10V_MAKE_DADDR (read_register(FP_REGNUM
)));
826 /* Function: push_return_address (pc)
827 Set up the return address for the inferior function call.
828 Needed for targets where we don't actually execute a JSR/BSR instruction */
831 d10v_push_return_address (pc
, sp
)
835 write_register (LR_REGNUM
, D10V_CONVERT_IADDR_TO_RAW (CALL_DUMMY_ADDRESS ()));
840 /* When arguments must be pushed onto the stack, they go on in reverse
841 order. The below implements a FILO (stack) to do this. */
846 struct stack_item
*prev
;
850 static struct stack_item
*push_stack_item
PARAMS ((struct stack_item
*prev
, void *contents
, int len
));
851 static struct stack_item
*
852 push_stack_item (prev
, contents
, len
)
853 struct stack_item
*prev
;
857 struct stack_item
*si
;
858 si
= xmalloc (sizeof (struct stack_item
));
859 si
->data
= xmalloc (len
);
862 memcpy (si
->data
, contents
, len
);
866 static struct stack_item
*pop_stack_item
PARAMS ((struct stack_item
*si
));
867 static struct stack_item
*
869 struct stack_item
*si
;
871 struct stack_item
*dead
= si
;
880 d10v_push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
)
885 CORE_ADDR struct_addr
;
888 int regnum
= ARG1_REGNUM
;
889 struct stack_item
*si
= NULL
;
891 /* Fill in registers and arg lists */
892 for (i
= 0; i
< nargs
; i
++)
894 value_ptr arg
= args
[i
];
895 struct type
*type
= check_typedef (VALUE_TYPE (arg
));
896 char *contents
= VALUE_CONTENTS (arg
);
897 int len
= TYPE_LENGTH (type
);
898 /* printf ("push: type=%d len=%d\n", type->code, len); */
899 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
901 /* pointers require special handling - first convert and
903 long val
= extract_signed_integer (contents
, len
);
905 if (TYPE_TARGET_TYPE (type
)
906 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
))
908 /* function pointer */
909 val
= D10V_CONVERT_IADDR_TO_RAW (val
);
911 else if (D10V_IADDR_P (val
))
913 /* also function pointer! */
914 val
= D10V_CONVERT_DADDR_TO_RAW (val
);
921 if (regnum
<= ARGN_REGNUM
)
922 write_register (regnum
++, val
& 0xffff);
926 /* arg will go onto stack */
927 store_address (ptr
, 2, val
& 0xffff);
928 si
= push_stack_item (si
, ptr
, 2);
933 int aligned_regnum
= (regnum
+ 1) & ~1;
934 if (len
<= 2 && regnum
<= ARGN_REGNUM
)
935 /* fits in a single register, do not align */
937 long val
= extract_unsigned_integer (contents
, len
);
938 write_register (regnum
++, val
);
940 else if (len
<= (ARGN_REGNUM
- aligned_regnum
+ 1) * 2)
941 /* value fits in remaining registers, store keeping left
945 regnum
= aligned_regnum
;
946 for (b
= 0; b
< (len
& ~1); b
+= 2)
948 long val
= extract_unsigned_integer (&contents
[b
], 2);
949 write_register (regnum
++, val
);
953 long val
= extract_unsigned_integer (&contents
[b
], 1);
954 write_register (regnum
++, (val
<< 8));
959 /* arg will go onto stack */
960 regnum
= ARGN_REGNUM
+ 1;
961 si
= push_stack_item (si
, contents
, len
);
968 sp
= (sp
- si
->len
) & ~1;
969 write_memory (sp
, si
->data
, si
->len
);
970 si
= pop_stack_item (si
);
977 /* Given a return value in `regbuf' with a type `valtype',
978 extract and copy its value into `valbuf'. */
981 d10v_extract_return_value (type
, regbuf
, valbuf
)
983 char regbuf
[REGISTER_BYTES
];
987 /* printf("RET: TYPE=%d len=%d r%d=0x%x\n",type->code, TYPE_LENGTH (type), RET1_REGNUM - R0_REGNUM, (int) extract_unsigned_integer (regbuf + REGISTER_BYTE(RET1_REGNUM), REGISTER_RAW_SIZE (RET1_REGNUM))); */
988 if (TYPE_CODE (type
) == TYPE_CODE_PTR
989 && TYPE_TARGET_TYPE (type
)
990 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
))
992 /* pointer to function */
995 snum
= extract_address (regbuf
+ REGISTER_BYTE (RET1_REGNUM
), REGISTER_RAW_SIZE (RET1_REGNUM
));
996 store_address ( valbuf
, 4, D10V_MAKE_IADDR(snum
));
998 else if (TYPE_CODE(type
) == TYPE_CODE_PTR
)
1000 /* pointer to data */
1003 snum
= extract_address (regbuf
+ REGISTER_BYTE (RET1_REGNUM
), REGISTER_RAW_SIZE (RET1_REGNUM
));
1004 store_address ( valbuf
, 4, D10V_MAKE_DADDR(snum
));
1008 len
= TYPE_LENGTH (type
);
1011 unsigned short c
= extract_unsigned_integer (regbuf
+ REGISTER_BYTE (RET1_REGNUM
), REGISTER_RAW_SIZE (RET1_REGNUM
));
1012 store_unsigned_integer (valbuf
, 1, c
);
1014 else if ((len
& 1) == 0)
1015 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (RET1_REGNUM
), len
);
1018 /* For return values of odd size, the first byte is in the
1019 least significant part of the first register. The
1020 remaining bytes in remaining registers. Interestingly,
1021 when such values are passed in, the last byte is in the
1022 most significant byte of that same register - wierd. */
1023 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (RET1_REGNUM
) + 1, len
);
1028 /* The following code implements access to, and display of, the D10V's
1029 instruction trace buffer. The buffer consists of 64K or more
1030 4-byte words of data, of which each words includes an 8-bit count,
1031 an 8-bit segment number, and a 16-bit instruction address.
1033 In theory, the trace buffer is continuously capturing instruction
1034 data that the CPU presents on its "debug bus", but in practice, the
1035 ROMified GDB stub only enables tracing when it continues or steps
1036 the program, and stops tracing when the program stops; so it
1037 actually works for GDB to read the buffer counter out of memory and
1038 then read each trace word. The counter records where the tracing
1039 stops, but there is no record of where it started, so we remember
1040 the PC when we resumed and then search backwards in the trace
1041 buffer for a word that includes that address. This is not perfect,
1042 because you will miss trace data if the resumption PC is the target
1043 of a branch. (The value of the buffer counter is semi-random, any
1044 trace data from a previous program stop is gone.) */
1046 /* The address of the last word recorded in the trace buffer. */
1048 #define DBBC_ADDR (0xd80000)
1050 /* The base of the trace buffer, at least for the "Board_0". */
1052 #define TRACE_BUFFER_BASE (0xf40000)
1054 static void trace_command
PARAMS ((char *, int));
1056 static void untrace_command
PARAMS ((char *, int));
1058 static void trace_info
PARAMS ((char *, int));
1060 static void tdisassemble_command
PARAMS ((char *, int));
1062 static void display_trace
PARAMS ((int, int));
1064 /* True when instruction traces are being collected. */
1068 /* Remembered PC. */
1070 static CORE_ADDR last_pc
;
1072 /* True when trace output should be displayed whenever program stops. */
1074 static int trace_display
;
1076 /* True when trace listing should include source lines. */
1078 static int default_trace_show_source
= 1;
1080 struct trace_buffer
{
1087 trace_command (args
, from_tty
)
1091 /* Clear the host-side trace buffer, allocating space if needed. */
1092 trace_data
.size
= 0;
1093 if (trace_data
.counts
== NULL
)
1094 trace_data
.counts
= (short *) xmalloc (65536 * sizeof(short));
1095 if (trace_data
.addrs
== NULL
)
1096 trace_data
.addrs
= (CORE_ADDR
*) xmalloc (65536 * sizeof(CORE_ADDR
));
1100 printf_filtered ("Tracing is now on.\n");
1104 untrace_command (args
, from_tty
)
1110 printf_filtered ("Tracing is now off.\n");
1114 trace_info (args
, from_tty
)
1120 if (trace_data
.size
)
1122 printf_filtered ("%d entries in trace buffer:\n", trace_data
.size
);
1124 for (i
= 0; i
< trace_data
.size
; ++i
)
1126 printf_filtered ("%d: %d instruction%s at 0x%x\n",
1127 i
, trace_data
.counts
[i
],
1128 (trace_data
.counts
[i
] == 1 ? "" : "s"),
1129 trace_data
.addrs
[i
]);
1133 printf_filtered ("No entries in trace buffer.\n");
1135 printf_filtered ("Tracing is currently %s.\n", (tracing
? "on" : "off"));
1138 /* Print the instruction at address MEMADDR in debugged memory,
1139 on STREAM. Returns length of the instruction, in bytes. */
1142 print_insn (memaddr
, stream
)
1146 /* If there's no disassembler, something is very wrong. */
1147 if (tm_print_insn
== NULL
)
1150 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
1151 tm_print_insn_info
.endian
= BFD_ENDIAN_BIG
;
1153 tm_print_insn_info
.endian
= BFD_ENDIAN_LITTLE
;
1154 return (*tm_print_insn
) (memaddr
, &tm_print_insn_info
);
1158 d10v_eva_prepare_to_trace ()
1163 last_pc
= read_register (PC_REGNUM
);
1166 /* Collect trace data from the target board and format it into a form
1167 more useful for display. */
1170 d10v_eva_get_trace_data ()
1172 int count
, i
, j
, oldsize
;
1173 int trace_addr
, trace_seg
, trace_cnt
, next_cnt
;
1174 unsigned int last_trace
, trace_word
, next_word
;
1175 unsigned int *tmpspace
;
1180 tmpspace
= xmalloc (65536 * sizeof(unsigned int));
1182 last_trace
= read_memory_unsigned_integer (DBBC_ADDR
, 2) << 2;
1184 /* Collect buffer contents from the target, stopping when we reach
1185 the word recorded when execution resumed. */
1188 while (last_trace
> 0)
1192 read_memory_unsigned_integer (TRACE_BUFFER_BASE
+ last_trace
, 4);
1193 trace_addr
= trace_word
& 0xffff;
1195 /* Ignore an apparently nonsensical entry. */
1196 if (trace_addr
== 0xffd5)
1198 tmpspace
[count
++] = trace_word
;
1199 if (trace_addr
== last_pc
)
1205 /* Move the data to the host-side trace buffer, adjusting counts to
1206 include the last instruction executed and transforming the address
1207 into something that GDB likes. */
1209 for (i
= 0; i
< count
; ++i
)
1211 trace_word
= tmpspace
[i
];
1212 next_word
= ((i
== 0) ? 0 : tmpspace
[i
- 1]);
1213 trace_addr
= trace_word
& 0xffff;
1214 next_cnt
= (next_word
>> 24) & 0xff;
1215 j
= trace_data
.size
+ count
- i
- 1;
1216 trace_data
.addrs
[j
] = (trace_addr
<< 2) + 0x1000000;
1217 trace_data
.counts
[j
] = next_cnt
+ 1;
1220 oldsize
= trace_data
.size
;
1221 trace_data
.size
+= count
;
1226 display_trace (oldsize
, trace_data
.size
);
1230 tdisassemble_command (arg
, from_tty
)
1235 CORE_ADDR low
, high
;
1241 high
= trace_data
.size
;
1243 else if (!(space_index
= (char *) strchr (arg
, ' ')))
1245 low
= parse_and_eval_address (arg
);
1250 /* Two arguments. */
1251 *space_index
= '\0';
1252 low
= parse_and_eval_address (arg
);
1253 high
= parse_and_eval_address (space_index
+ 1);
1258 printf_filtered ("Dump of trace from %d to %d:\n", low
, high
);
1260 display_trace (low
, high
);
1262 printf_filtered ("End of trace dump.\n");
1263 gdb_flush (gdb_stdout
);
1267 display_trace (low
, high
)
1270 int i
, count
, trace_show_source
, first
, suppress
;
1271 CORE_ADDR next_address
;
1273 trace_show_source
= default_trace_show_source
;
1274 if (!have_full_symbols () && !have_partial_symbols())
1276 trace_show_source
= 0;
1277 printf_filtered ("No symbol table is loaded. Use the \"file\" command.\n");
1278 printf_filtered ("Trace will not display any source.\n");
1283 for (i
= low
; i
< high
; ++i
)
1285 next_address
= trace_data
.addrs
[i
];
1286 count
= trace_data
.counts
[i
];
1290 if (trace_show_source
)
1292 struct symtab_and_line sal
, sal_prev
;
1294 sal_prev
= find_pc_line (next_address
- 4, 0);
1295 sal
= find_pc_line (next_address
, 0);
1299 if (first
|| sal
.line
!= sal_prev
.line
)
1300 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
1306 /* FIXME-32x64--assumes sal.pc fits in long. */
1307 printf_filtered ("No source file for address %s.\n",
1308 local_hex_string((unsigned long) sal
.pc
));
1313 print_address (next_address
, gdb_stdout
);
1314 printf_filtered (":");
1315 printf_filtered ("\t");
1317 next_address
= next_address
+ print_insn (next_address
, gdb_stdout
);
1318 printf_filtered ("\n");
1319 gdb_flush (gdb_stdout
);
1325 static gdbarch_init_ftype d10v_gdbarch_init
;
1326 static struct gdbarch
*
1327 d10v_gdbarch_init (info
, arches
)
1328 struct gdbarch_info info
;
1329 struct gdbarch_list
*arches
;
1331 static LONGEST d10v_call_dummy_words
[] = { 0 };
1332 struct gdbarch
*gdbarch
;
1333 int d10v_num_regs
= 37;
1335 /* there is only one d10v architecture */
1337 return arches
->gdbarch
;
1338 gdbarch
= gdbarch_alloc (&info
, NULL
);
1340 set_gdbarch_read_pc (gdbarch
, d10v_read_pc
);
1341 set_gdbarch_write_pc (gdbarch
, d10v_write_pc
);
1342 set_gdbarch_read_fp (gdbarch
, d10v_read_fp
);
1343 set_gdbarch_write_fp (gdbarch
, d10v_write_fp
);
1344 set_gdbarch_read_sp (gdbarch
, d10v_read_sp
);
1345 set_gdbarch_write_sp (gdbarch
, d10v_write_sp
);
1347 set_gdbarch_num_regs (gdbarch
, d10v_num_regs
);
1348 set_gdbarch_sp_regnum (gdbarch
, 15);
1349 set_gdbarch_fp_regnum (gdbarch
, 11);
1350 set_gdbarch_pc_regnum (gdbarch
, 18);
1351 set_gdbarch_register_name (gdbarch
, d10v_register_name
);
1352 set_gdbarch_register_size (gdbarch
, 2);
1353 set_gdbarch_register_bytes (gdbarch
, (d10v_num_regs
- 2) * 2 + 16);
1354 set_gdbarch_register_byte (gdbarch
, d10v_register_byte
);
1355 set_gdbarch_register_raw_size (gdbarch
, d10v_register_raw_size
);
1356 set_gdbarch_max_register_raw_size (gdbarch
, 8);
1357 set_gdbarch_register_virtual_size (gdbarch
, d10v_register_virtual_size
);
1358 set_gdbarch_max_register_virtual_size (gdbarch
, 8);
1359 set_gdbarch_register_virtual_type (gdbarch
, d10v_register_virtual_type
);
1361 set_gdbarch_ptr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1362 set_gdbarch_short_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1363 set_gdbarch_int_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1364 set_gdbarch_long_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1365 set_gdbarch_long_long_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1366 set_gdbarch_float_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1367 set_gdbarch_double_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1368 set_gdbarch_long_double_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
1370 set_gdbarch_use_generic_dummy_frames (gdbarch
, 1);
1371 set_gdbarch_call_dummy_length (gdbarch
, 0);
1372 set_gdbarch_call_dummy_location (gdbarch
, AT_ENTRY_POINT
);
1373 set_gdbarch_call_dummy_address (gdbarch
, entry_point_address
);
1374 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch
, 1);
1375 set_gdbarch_call_dummy_breakpoint_offset (gdbarch
, 0);
1376 set_gdbarch_call_dummy_start_offset (gdbarch
, 0);
1377 set_gdbarch_pc_in_call_dummy (gdbarch
, generic_pc_in_call_dummy
);
1378 set_gdbarch_call_dummy_words (gdbarch
, d10v_call_dummy_words
);
1379 set_gdbarch_sizeof_call_dummy_words (gdbarch
, sizeof (d10v_call_dummy_words
));
1380 set_gdbarch_call_dummy_p (gdbarch
, 1);
1381 set_gdbarch_call_dummy_stack_adjust_p (gdbarch
, 0);
1382 set_gdbarch_get_saved_register (gdbarch
, generic_get_saved_register
);
1383 set_gdbarch_fix_call_dummy (gdbarch
, generic_fix_call_dummy
);
1385 set_gdbarch_register_convertible (gdbarch
, d10v_register_convertible
);
1386 set_gdbarch_register_convert_to_virtual (gdbarch
, d10v_register_convert_to_virtual
);
1387 set_gdbarch_register_convert_to_raw (gdbarch
, d10v_register_convert_to_raw
);
1389 set_gdbarch_extract_return_value (gdbarch
, d10v_extract_return_value
);
1390 set_gdbarch_push_arguments (gdbarch
, d10v_push_arguments
);
1391 set_gdbarch_push_dummy_frame (gdbarch
, generic_push_dummy_frame
);
1392 set_gdbarch_push_return_address (gdbarch
, d10v_push_return_address
);
1394 set_gdbarch_d10v_make_daddr (gdbarch
, d10v_make_daddr
);
1395 set_gdbarch_d10v_make_iaddr (gdbarch
, d10v_make_iaddr
);
1396 set_gdbarch_d10v_daddr_p (gdbarch
, d10v_daddr_p
);
1397 set_gdbarch_d10v_iaddr_p (gdbarch
, d10v_iaddr_p
);
1398 set_gdbarch_d10v_convert_daddr_to_raw (gdbarch
, d10v_convert_daddr_to_raw
);
1399 set_gdbarch_d10v_convert_iaddr_to_raw (gdbarch
, d10v_convert_iaddr_to_raw
);
1401 set_gdbarch_store_struct_return (gdbarch
, d10v_store_struct_return
);
1402 set_gdbarch_store_return_value (gdbarch
, d10v_store_return_value
);
1403 set_gdbarch_extract_struct_value_address (gdbarch
, d10v_extract_struct_value_address
);
1404 set_gdbarch_use_struct_convention (gdbarch
, d10v_use_struct_convention
);
1406 set_gdbarch_frame_init_saved_regs (gdbarch
, d10v_frame_init_saved_regs
);
1407 set_gdbarch_init_extra_frame_info (gdbarch
, d10v_init_extra_frame_info
);
1409 set_gdbarch_pop_frame (gdbarch
, d10v_pop_frame
);
1411 set_gdbarch_skip_prologue (gdbarch
, d10v_skip_prologue
);
1412 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1413 set_gdbarch_decr_pc_after_break (gdbarch
, 4);
1414 set_gdbarch_function_start_offset (gdbarch
, 0);
1415 set_gdbarch_breakpoint_from_pc (gdbarch
, d10v_breakpoint_from_pc
);
1417 set_gdbarch_remote_translate_xfer_address (gdbarch
, remote_d10v_translate_xfer_address
);
1419 set_gdbarch_frame_args_skip (gdbarch
, 0);
1420 set_gdbarch_frameless_function_invocation (gdbarch
, frameless_look_for_prologue
);
1421 set_gdbarch_frame_chain (gdbarch
, d10v_frame_chain
);
1422 set_gdbarch_frame_chain_valid (gdbarch
, d10v_frame_chain_valid
);
1423 set_gdbarch_frame_saved_pc (gdbarch
, d10v_frame_saved_pc
);
1424 set_gdbarch_frame_args_address (gdbarch
, d10v_frame_args_address
);
1425 set_gdbarch_frame_locals_address (gdbarch
, d10v_frame_locals_address
);
1426 set_gdbarch_saved_pc_after_call (gdbarch
, d10v_saved_pc_after_call
);
1427 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
1433 extern void (*target_resume_hook
) PARAMS ((void));
1434 extern void (*target_wait_loop_hook
) PARAMS ((void));
1437 _initialize_d10v_tdep ()
1439 register_gdbarch_init (bfd_arch_d10v
, d10v_gdbarch_init
);
1441 tm_print_insn
= print_insn_d10v
;
1443 target_resume_hook
= d10v_eva_prepare_to_trace
;
1444 target_wait_loop_hook
= d10v_eva_get_trace_data
;
1446 add_com ("regs", class_vars
, show_regs
, "Print all registers");
1448 add_com ("trace", class_support
, trace_command
,
1449 "Enable tracing of instruction execution.");
1451 add_com ("untrace", class_support
, untrace_command
,
1452 "Disable tracing of instruction execution.");
1454 add_com ("tdisassemble", class_vars
, tdisassemble_command
,
1455 "Disassemble the trace buffer.\n\
1456 Two optional arguments specify a range of trace buffer entries\n\
1457 as reported by info trace (NOT addresses!).");
1459 add_info ("trace", trace_info
,
1460 "Display info about the trace data buffer.");
1462 add_show_from_set (add_set_cmd ("tracedisplay", no_class
,
1463 var_integer
, (char *)&trace_display
,
1464 "Set automatic display of trace.\n", &setlist
),
1466 add_show_from_set (add_set_cmd ("tracesource", no_class
,
1467 var_integer
, (char *)&default_trace_show_source
,
1468 "Set display of source code with trace.\n", &setlist
),