1 /* Target-dependent code for Mitsubishi D10V, for GDB.
3 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software
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. */
23 /* Contributed by Martin Hunt, hunt@cygnus.com */
27 #include "frame-unwind.h"
28 #include "frame-base.h"
33 #include "gdb_string.h"
40 #include "arch-utils.h"
43 #include "floatformat.h"
44 #include "gdb/sim-d10v.h"
45 #include "sim-regno.h"
47 #include "trad-frame.h"
49 #include "gdb_assert.h"
55 unsigned long (*dmap_register
) (void *regcache
, int nr
);
56 unsigned long (*imap_register
) (void *regcache
, int nr
);
59 /* These are the addresses the D10V-EVA board maps data and
60 instruction memory to. */
63 DMEM_START
= 0x2000000,
64 IMEM_START
= 0x1000000,
65 STACK_START
= 0x200bffe
68 /* d10v register names. */
83 /* d10v calling convention. */
84 ARG1_REGNUM
= R0_REGNUM
,
85 ARGN_REGNUM
= R3_REGNUM
,
86 RET1_REGNUM
= R0_REGNUM
,
90 nr_dmap_regs (struct gdbarch
*gdbarch
)
92 return gdbarch_tdep (gdbarch
)->nr_dmap_regs
;
96 a0_regnum (struct gdbarch
*gdbarch
)
98 return gdbarch_tdep (gdbarch
)->a0_regnum
;
101 /* Local functions */
103 extern void _initialize_d10v_tdep (void);
105 static CORE_ADDR
d10v_read_sp (void);
107 static void d10v_eva_prepare_to_trace (void);
109 static void d10v_eva_get_trace_data (void);
112 d10v_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
114 /* Align to the size of an instruction (so that they can safely be
115 pushed onto the stack. */
119 /* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of
120 EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc
121 and TYPE is the type (which is known to be struct, union or array).
123 The d10v returns anything less than 8 bytes in size in
127 d10v_use_struct_convention (int gcc_p
, struct type
*type
)
131 /* The d10v only passes a struct in a register when that structure
132 has an alignment that matches the size of a register. */
133 /* If the structure doesn't fit in 4 registers, put it on the
135 if (TYPE_LENGTH (type
) > 8)
137 /* If the struct contains only one field, don't put it on the stack
138 - gcc can fit it in one or more registers. */
139 if (TYPE_NFIELDS (type
) == 1)
141 alignment
= TYPE_LENGTH (TYPE_FIELD_TYPE (type
, 0));
142 for (i
= 1; i
< TYPE_NFIELDS (type
); i
++)
144 /* If the alignment changes, just assume it goes on the
146 if (TYPE_LENGTH (TYPE_FIELD_TYPE (type
, i
)) != alignment
)
149 /* If the alignment is suitable for the d10v's 16 bit registers,
150 don't put it on the stack. */
151 if (alignment
== 2 || alignment
== 4)
157 static const unsigned char *
158 d10v_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
160 static unsigned char breakpoint
[] =
161 {0x2f, 0x90, 0x5e, 0x00};
162 *lenptr
= sizeof (breakpoint
);
166 /* Map the REG_NR onto an ascii name. Return NULL or an empty string
167 when the reg_nr isn't valid. */
171 TS2_IMAP0_REGNUM
= 32,
172 TS2_DMAP_REGNUM
= 34,
173 TS2_NR_DMAP_REGS
= 1,
178 d10v_ts2_register_name (int reg_nr
)
180 static char *register_names
[] =
182 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
183 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
184 "psw", "bpsw", "pc", "bpc", "cr4", "cr5", "cr6", "rpt_c",
185 "rpt_s", "rpt_e", "mod_s", "mod_e", "cr12", "cr13", "iba", "cr15",
186 "imap0", "imap1", "dmap", "a0", "a1"
190 if (reg_nr
>= (sizeof (register_names
) / sizeof (*register_names
)))
192 return register_names
[reg_nr
];
197 TS3_IMAP0_REGNUM
= 36,
198 TS3_DMAP0_REGNUM
= 38,
199 TS3_NR_DMAP_REGS
= 4,
204 d10v_ts3_register_name (int reg_nr
)
206 static char *register_names
[] =
208 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
209 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
210 "psw", "bpsw", "pc", "bpc", "cr4", "cr5", "cr6", "rpt_c",
211 "rpt_s", "rpt_e", "mod_s", "mod_e", "cr12", "cr13", "iba", "cr15",
215 "dmap0", "dmap1", "dmap2", "dmap3"
219 if (reg_nr
>= (sizeof (register_names
) / sizeof (*register_names
)))
221 return register_names
[reg_nr
];
224 /* Access the DMAP/IMAP registers in a target independent way.
226 Divide the D10V's 64k data space into four 16k segments:
227 0x0000 -- 0x3fff, 0x4000 -- 0x7fff, 0x8000 -- 0xbfff, and
230 On the TS2, the first two segments (0x0000 -- 0x3fff, 0x4000 --
231 0x7fff) always map to the on-chip data RAM, and the fourth always
232 maps to I/O space. The third (0x8000 - 0xbfff) can be mapped into
233 unified memory or instruction memory, under the control of the
234 single DMAP register.
236 On the TS3, there are four DMAP registers, each of which controls
237 one of the segments. */
240 d10v_ts2_dmap_register (void *regcache
, int reg_nr
)
250 regcache_cooked_read_unsigned (regcache
, TS2_DMAP_REGNUM
, ®
);
259 d10v_ts3_dmap_register (void *regcache
, int reg_nr
)
262 regcache_cooked_read_unsigned (regcache
, TS3_DMAP0_REGNUM
+ reg_nr
, ®
);
267 d10v_ts2_imap_register (void *regcache
, int reg_nr
)
270 regcache_cooked_read_unsigned (regcache
, TS2_IMAP0_REGNUM
+ reg_nr
, ®
);
275 d10v_ts3_imap_register (void *regcache
, int reg_nr
)
278 regcache_cooked_read_unsigned (regcache
, TS3_IMAP0_REGNUM
+ reg_nr
, ®
);
282 /* MAP GDB's internal register numbering (determined by the layout fo
283 the REGISTER_BYTE array) onto the simulator's register
287 d10v_ts2_register_sim_regno (int nr
)
289 /* Only makes sense to supply raw registers. */
290 gdb_assert (nr
>= 0 && nr
< NUM_REGS
);
291 if (nr
>= TS2_IMAP0_REGNUM
292 && nr
< TS2_IMAP0_REGNUM
+ NR_IMAP_REGS
)
293 return nr
- TS2_IMAP0_REGNUM
+ SIM_D10V_IMAP0_REGNUM
;
294 if (nr
== TS2_DMAP_REGNUM
)
295 return nr
- TS2_DMAP_REGNUM
+ SIM_D10V_TS2_DMAP_REGNUM
;
296 if (nr
>= TS2_A0_REGNUM
297 && nr
< TS2_A0_REGNUM
+ NR_A_REGS
)
298 return nr
- TS2_A0_REGNUM
+ SIM_D10V_A0_REGNUM
;
303 d10v_ts3_register_sim_regno (int nr
)
305 /* Only makes sense to supply raw registers. */
306 gdb_assert (nr
>= 0 && nr
< NUM_REGS
);
307 if (nr
>= TS3_IMAP0_REGNUM
308 && nr
< TS3_IMAP0_REGNUM
+ NR_IMAP_REGS
)
309 return nr
- TS3_IMAP0_REGNUM
+ SIM_D10V_IMAP0_REGNUM
;
310 if (nr
>= TS3_DMAP0_REGNUM
311 && nr
< TS3_DMAP0_REGNUM
+ TS3_NR_DMAP_REGS
)
312 return nr
- TS3_DMAP0_REGNUM
+ SIM_D10V_DMAP0_REGNUM
;
313 if (nr
>= TS3_A0_REGNUM
314 && nr
< TS3_A0_REGNUM
+ NR_A_REGS
)
315 return nr
- TS3_A0_REGNUM
+ SIM_D10V_A0_REGNUM
;
319 /* Return the GDB type object for the "standard" data type
320 of data in register N. */
323 d10v_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
325 if (reg_nr
== D10V_PC_REGNUM
)
326 return builtin_type_void_func_ptr
;
327 if (reg_nr
== D10V_SP_REGNUM
|| reg_nr
== D10V_FP_REGNUM
)
328 return builtin_type_void_data_ptr
;
329 else if (reg_nr
>= a0_regnum (gdbarch
)
330 && reg_nr
< (a0_regnum (gdbarch
) + NR_A_REGS
))
331 return builtin_type_int64
;
333 return builtin_type_int16
;
337 d10v_daddr_p (CORE_ADDR x
)
339 return (((x
) & 0x3000000) == DMEM_START
);
343 d10v_iaddr_p (CORE_ADDR x
)
345 return (((x
) & 0x3000000) == IMEM_START
);
349 d10v_make_daddr (CORE_ADDR x
)
351 return ((x
) | DMEM_START
);
355 d10v_make_iaddr (CORE_ADDR x
)
357 if (d10v_iaddr_p (x
))
358 return x
; /* Idempotency -- x is already in the IMEM space. */
360 return (((x
) << 2) | IMEM_START
);
364 d10v_convert_iaddr_to_raw (CORE_ADDR x
)
366 return (((x
) >> 2) & 0xffff);
370 d10v_convert_daddr_to_raw (CORE_ADDR x
)
372 return ((x
) & 0xffff);
376 d10v_address_to_pointer (struct type
*type
, void *buf
, CORE_ADDR addr
)
378 /* Is it a code address? */
379 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
380 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_METHOD
)
382 store_unsigned_integer (buf
, TYPE_LENGTH (type
),
383 d10v_convert_iaddr_to_raw (addr
));
387 /* Strip off any upper segment bits. */
388 store_unsigned_integer (buf
, TYPE_LENGTH (type
),
389 d10v_convert_daddr_to_raw (addr
));
394 d10v_pointer_to_address (struct type
*type
, const void *buf
)
396 CORE_ADDR addr
= extract_unsigned_integer (buf
, TYPE_LENGTH (type
));
397 /* Is it a code address? */
398 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
399 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_METHOD
400 || TYPE_CODE_SPACE (TYPE_TARGET_TYPE (type
)))
401 return d10v_make_iaddr (addr
);
403 return d10v_make_daddr (addr
);
406 /* Don't do anything if we have an integer, this way users can type 'x
407 <addr>' w/o having gdb outsmart them. The internal gdb conversions
408 to the correct space are taken care of in the pointer_to_address
409 function. If we don't do this, 'x $fp' wouldn't work. */
411 d10v_integer_to_address (struct type
*type
, void *buf
)
414 val
= unpack_long (type
, buf
);
418 /* Write into appropriate registers a function return value
419 of type TYPE, given in virtual format.
421 Things always get returned in RET1_REGNUM, RET2_REGNUM, ... */
424 d10v_store_return_value (struct type
*type
, struct regcache
*regcache
,
427 /* Only char return values need to be shifted right within the first
429 if (TYPE_LENGTH (type
) == 1
430 && TYPE_CODE (type
) == TYPE_CODE_INT
)
433 tmp
[1] = *(bfd_byte
*)valbuf
;
434 regcache_cooked_write (regcache
, RET1_REGNUM
, tmp
);
439 /* A structure is never more than 8 bytes long. See
440 use_struct_convention(). */
441 gdb_assert (TYPE_LENGTH (type
) <= 8);
442 /* Write out most registers, stop loop before trying to write
443 out any dangling byte at the end of the buffer. */
444 for (reg
= 0; (reg
* 2) + 1 < TYPE_LENGTH (type
); reg
++)
446 regcache_cooked_write (regcache
, RET1_REGNUM
+ reg
,
447 (bfd_byte
*) valbuf
+ reg
* 2);
449 /* Write out any dangling byte at the end of the buffer. */
450 if ((reg
* 2) + 1 == TYPE_LENGTH (type
))
451 regcache_cooked_write_part (regcache
, reg
, 0, 1,
452 (bfd_byte
*) valbuf
+ reg
* 2);
456 /* Extract from an array REGBUF containing the (raw) register state
457 the address in which a function should return its structure value,
458 as a CORE_ADDR (or an expression that can be used as one). */
461 d10v_extract_struct_value_address (struct regcache
*regcache
)
464 regcache_cooked_read_unsigned (regcache
, ARG1_REGNUM
, &addr
);
465 return (addr
| DMEM_START
);
469 check_prologue (unsigned short op
)
472 if ((op
& 0x7E1F) == 0x6C1F)
476 if ((op
& 0x7E3F) == 0x6E1F)
480 if ((op
& 0x7FE1) == 0x01E1)
492 if ((op
& 0x7E1F) == 0x681E)
496 if ((op
& 0x7E3F) == 0x3A1E)
503 d10v_skip_prologue (CORE_ADDR pc
)
506 unsigned short op1
, op2
;
507 CORE_ADDR func_addr
, func_end
;
508 struct symtab_and_line sal
;
510 /* If we have line debugging information, then the end of the */
511 /* prologue should the first assembly instruction of the first source line */
512 if (find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
514 sal
= find_pc_line (func_addr
, 0);
515 if (sal
.end
&& sal
.end
< func_end
)
519 if (target_read_memory (pc
, (char *) &op
, 4))
520 return pc
; /* Can't access it -- assume no prologue. */
524 op
= (unsigned long) read_memory_integer (pc
, 4);
525 if ((op
& 0xC0000000) == 0xC0000000)
527 /* long instruction */
528 if (((op
& 0x3FFF0000) != 0x01FF0000) && /* add3 sp,sp,n */
529 ((op
& 0x3F0F0000) != 0x340F0000) && /* st rn, @(offset,sp) */
530 ((op
& 0x3F1F0000) != 0x350F0000)) /* st2w rn, @(offset,sp) */
535 /* short instructions */
536 if ((op
& 0xC0000000) == 0x80000000)
538 op2
= (op
& 0x3FFF8000) >> 15;
543 op1
= (op
& 0x3FFF8000) >> 15;
546 if (check_prologue (op1
))
548 if (!check_prologue (op2
))
550 /* if the previous opcode was really part of the prologue */
551 /* and not just a NOP, then we want to break after both instructions */
565 struct d10v_unwind_cache
567 /* The previous frame's inner most stack address. Used as this
568 frame ID's stack_addr. */
570 /* The frame's base, optionally used by the high-level debug info. */
573 /* How far the SP and r11 (FP) have been offset from the start of
574 the stack frame (as defined by the previous frame's stack
579 /* Table indicating the location of each and every register. */
580 struct trad_frame_saved_reg
*saved_regs
;
584 prologue_find_regs (struct d10v_unwind_cache
*info
, unsigned short op
,
590 if ((op
& 0x7E1F) == 0x6C1F)
592 n
= (op
& 0x1E0) >> 5;
593 info
->sp_offset
-= 2;
594 info
->saved_regs
[n
].addr
= info
->sp_offset
;
599 else if ((op
& 0x7E3F) == 0x6E1F)
601 n
= (op
& 0x1E0) >> 5;
602 info
->sp_offset
-= 4;
603 info
->saved_regs
[n
+ 0].addr
= info
->sp_offset
+ 0;
604 info
->saved_regs
[n
+ 1].addr
= info
->sp_offset
+ 2;
609 if ((op
& 0x7FE1) == 0x01E1)
611 n
= (op
& 0x1E) >> 1;
614 info
->sp_offset
-= n
;
621 info
->uses_frame
= 1;
622 info
->r11_offset
= info
->sp_offset
;
627 if ((op
& 0x7E1F) == 0x6816)
629 n
= (op
& 0x1E0) >> 5;
630 info
->saved_regs
[n
].addr
= info
->r11_offset
;
639 if ((op
& 0x7E1F) == 0x681E)
641 n
= (op
& 0x1E0) >> 5;
642 info
->saved_regs
[n
].addr
= info
->sp_offset
;
647 if ((op
& 0x7E3F) == 0x3A1E)
649 n
= (op
& 0x1E0) >> 5;
650 info
->saved_regs
[n
+ 0].addr
= info
->sp_offset
+ 0;
651 info
->saved_regs
[n
+ 1].addr
= info
->sp_offset
+ 2;
658 /* Put here the code to store, into fi->saved_regs, the addresses of
659 the saved registers of frame described by FRAME_INFO. This
660 includes special registers such as pc and fp saved in special ways
661 in the stack frame. sp is even more special: the address we return
662 for it IS the sp for the next frame. */
664 static struct d10v_unwind_cache
*
665 d10v_frame_unwind_cache (struct frame_info
*next_frame
,
666 void **this_prologue_cache
)
668 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
673 unsigned short op1
, op2
;
675 struct d10v_unwind_cache
*info
;
677 if ((*this_prologue_cache
))
678 return (*this_prologue_cache
);
680 info
= FRAME_OBSTACK_ZALLOC (struct d10v_unwind_cache
);
681 (*this_prologue_cache
) = info
;
682 info
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
687 info
->uses_frame
= 0;
688 for (pc
= frame_func_unwind (next_frame
);
689 pc
> 0 && pc
< frame_pc_unwind (next_frame
);
692 op
= get_frame_memory_unsigned (next_frame
, pc
, 4);
693 if ((op
& 0xC0000000) == 0xC0000000)
695 /* long instruction */
696 if ((op
& 0x3FFF0000) == 0x01FF0000)
699 short n
= op
& 0xFFFF;
700 info
->sp_offset
+= n
;
702 else if ((op
& 0x3F0F0000) == 0x340F0000)
704 /* st rn, @(offset,sp) */
705 short offset
= op
& 0xFFFF;
706 short n
= (op
>> 20) & 0xF;
707 info
->saved_regs
[n
].addr
= info
->sp_offset
+ offset
;
709 else if ((op
& 0x3F1F0000) == 0x350F0000)
711 /* st2w rn, @(offset,sp) */
712 short offset
= op
& 0xFFFF;
713 short n
= (op
>> 20) & 0xF;
714 info
->saved_regs
[n
+ 0].addr
= info
->sp_offset
+ offset
+ 0;
715 info
->saved_regs
[n
+ 1].addr
= info
->sp_offset
+ offset
+ 2;
722 /* short instructions */
723 if ((op
& 0xC0000000) == 0x80000000)
725 op2
= (op
& 0x3FFF8000) >> 15;
730 op1
= (op
& 0x3FFF8000) >> 15;
733 if (!prologue_find_regs (info
, op1
, pc
)
734 || !prologue_find_regs (info
, op2
, pc
))
739 info
->size
= -info
->sp_offset
;
741 /* Compute the previous frame's stack pointer (which is also the
742 frame's ID's stack address), and this frame's base pointer. */
743 if (info
->uses_frame
)
745 /* The SP was moved to the FP. This indicates that a new frame
746 was created. Get THIS frame's FP value by unwinding it from
748 frame_unwind_unsigned_register (next_frame
, D10V_FP_REGNUM
, &this_base
);
749 /* The FP points at the last saved register. Adjust the FP back
750 to before the first saved register giving the SP. */
751 prev_sp
= this_base
+ info
->size
;
755 /* Assume that the FP is this frame's SP but with that pushed
756 stack space added back. */
757 frame_unwind_unsigned_register (next_frame
, D10V_SP_REGNUM
, &this_base
);
758 prev_sp
= this_base
+ info
->size
;
761 /* Convert that SP/BASE into real addresses. */
762 info
->prev_sp
= d10v_make_daddr (prev_sp
);
763 info
->base
= d10v_make_daddr (this_base
);
765 /* Adjust all the saved registers so that they contain addresses and
767 for (i
= 0; i
< NUM_REGS
- 1; i
++)
768 if (info
->saved_regs
[i
].addr
)
770 info
->saved_regs
[i
].addr
= (info
->prev_sp
+ info
->saved_regs
[i
].addr
);
773 /* The call instruction moves the caller's PC in the callee's LR.
774 Since this is an unwind, do the reverse. Copy the location of LR
775 into PC (the address / regnum) so that a request for PC will be
776 converted into a request for the LR. */
777 info
->saved_regs
[D10V_PC_REGNUM
] = info
->saved_regs
[LR_REGNUM
];
779 /* The previous frame's SP needed to be computed. Save the computed
781 trad_frame_register_value (info
->saved_regs
, D10V_SP_REGNUM
,
782 d10v_make_daddr (prev_sp
));
788 d10v_print_registers_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
789 struct frame_info
*frame
, int regnum
, int all
)
791 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
794 default_print_registers_info (gdbarch
, file
, frame
, regnum
, all
);
799 ULONGEST pc
, psw
, rpt_s
, rpt_e
, rpt_c
;
800 frame_read_unsigned_register (frame
, D10V_PC_REGNUM
, &pc
);
801 frame_read_unsigned_register (frame
, PSW_REGNUM
, &psw
);
802 frame_read_unsigned_register (frame
, frame_map_name_to_regnum ("rpt_s", -1), &rpt_s
);
803 frame_read_unsigned_register (frame
, frame_map_name_to_regnum ("rpt_e", -1), &rpt_e
);
804 frame_read_unsigned_register (frame
, frame_map_name_to_regnum ("rpt_c", -1), &rpt_c
);
805 fprintf_filtered (file
, "PC=%04lx (0x%lx) PSW=%04lx RPT_S=%04lx RPT_E=%04lx RPT_C=%04lx\n",
806 (long) pc
, (long) d10v_make_iaddr (pc
), (long) psw
,
807 (long) rpt_s
, (long) rpt_e
, (long) rpt_c
);
812 for (group
= 0; group
< 16; group
+= 8)
815 fprintf_filtered (file
, "R%d-R%-2d", group
, group
+ 7);
816 for (r
= group
; r
< group
+ 8; r
++)
819 frame_read_unsigned_register (frame
, r
, &tmp
);
820 fprintf_filtered (file
, " %04lx", (long) tmp
);
822 fprintf_filtered (file
, "\n");
826 /* Note: The IMAP/DMAP registers don't participate in function
827 calls. Don't bother trying to unwind them. */
831 for (a
= 0; a
< NR_IMAP_REGS
; a
++)
834 fprintf_filtered (file
, " ");
835 fprintf_filtered (file
, "IMAP%d %04lx", a
,
836 tdep
->imap_register (current_regcache
, a
));
838 if (nr_dmap_regs (gdbarch
) == 1)
839 /* Registers DMAP0 and DMAP1 are constant. Just return dmap2. */
840 fprintf_filtered (file
, " DMAP %04lx\n",
841 tdep
->dmap_register (current_regcache
, 2));
844 for (a
= 0; a
< nr_dmap_regs (gdbarch
); a
++)
846 fprintf_filtered (file
, " DMAP%d %04lx", a
,
847 tdep
->dmap_register (current_regcache
, a
));
849 fprintf_filtered (file
, "\n");
854 char num
[MAX_REGISTER_SIZE
];
856 fprintf_filtered (file
, "A0-A%d", NR_A_REGS
- 1);
857 for (a
= a0_regnum (gdbarch
); a
< a0_regnum (gdbarch
) + NR_A_REGS
; a
++)
860 fprintf_filtered (file
, " ");
861 frame_read_register (frame
, a
, num
);
862 for (i
= 0; i
< register_size (gdbarch
, a
); i
++)
864 fprintf_filtered (file
, "%02x", (num
[i
] & 0xff));
868 fprintf_filtered (file
, "\n");
872 show_regs (char *args
, int from_tty
)
874 d10v_print_registers_info (current_gdbarch
, gdb_stdout
,
875 get_current_frame (), -1, 1);
879 d10v_read_pc (ptid_t ptid
)
885 save_ptid
= inferior_ptid
;
886 inferior_ptid
= ptid
;
887 pc
= (int) read_register (D10V_PC_REGNUM
);
888 inferior_ptid
= save_ptid
;
889 retval
= d10v_make_iaddr (pc
);
894 d10v_write_pc (CORE_ADDR val
, ptid_t ptid
)
898 save_ptid
= inferior_ptid
;
899 inferior_ptid
= ptid
;
900 write_register (D10V_PC_REGNUM
, d10v_convert_iaddr_to_raw (val
));
901 inferior_ptid
= save_ptid
;
907 return (d10v_make_daddr (read_register (D10V_SP_REGNUM
)));
910 /* When arguments must be pushed onto the stack, they go on in reverse
911 order. The below implements a FILO (stack) to do this. */
916 struct stack_item
*prev
;
920 static struct stack_item
*push_stack_item (struct stack_item
*prev
,
921 void *contents
, int len
);
922 static struct stack_item
*
923 push_stack_item (struct stack_item
*prev
, void *contents
, int len
)
925 struct stack_item
*si
;
926 si
= xmalloc (sizeof (struct stack_item
));
927 si
->data
= xmalloc (len
);
930 memcpy (si
->data
, contents
, len
);
934 static struct stack_item
*pop_stack_item (struct stack_item
*si
);
935 static struct stack_item
*
936 pop_stack_item (struct stack_item
*si
)
938 struct stack_item
*dead
= si
;
947 d10v_push_dummy_code (struct gdbarch
*gdbarch
,
948 CORE_ADDR sp
, CORE_ADDR funaddr
, int using_gcc
,
949 struct value
**args
, int nargs
,
950 struct type
*value_type
,
951 CORE_ADDR
*real_pc
, CORE_ADDR
*bp_addr
)
953 /* Allocate space sufficient for a breakpoint. */
955 /* Store the address of that breakpoint taking care to first convert
956 it into a code (IADDR) address from a stack (DADDR) address.
957 This of course assumes that the two virtual addresses map onto
958 the same real address. */
959 (*bp_addr
) = d10v_make_iaddr (d10v_convert_iaddr_to_raw (sp
));
960 /* d10v always starts the call at the callee's entry point. */
961 (*real_pc
) = funaddr
;
966 d10v_push_dummy_call (struct gdbarch
*gdbarch
, CORE_ADDR func_addr
,
967 struct regcache
*regcache
, CORE_ADDR bp_addr
,
968 int nargs
, struct value
**args
, CORE_ADDR sp
, int struct_return
,
969 CORE_ADDR struct_addr
)
972 int regnum
= ARG1_REGNUM
;
973 struct stack_item
*si
= NULL
;
976 /* Set the return address. For the d10v, the return breakpoint is
977 always at BP_ADDR. */
978 regcache_cooked_write_unsigned (regcache
, LR_REGNUM
,
979 d10v_convert_iaddr_to_raw (bp_addr
));
981 /* If STRUCT_RETURN is true, then the struct return address (in
982 STRUCT_ADDR) will consume the first argument-passing register.
983 Both adjust the register count and store that value. */
986 regcache_cooked_write_unsigned (regcache
, regnum
, struct_addr
);
990 /* Fill in registers and arg lists */
991 for (i
= 0; i
< nargs
; i
++)
993 struct value
*arg
= args
[i
];
994 struct type
*type
= check_typedef (VALUE_TYPE (arg
));
995 char *contents
= VALUE_CONTENTS (arg
);
996 int len
= TYPE_LENGTH (type
);
997 int aligned_regnum
= (regnum
+ 1) & ~1;
999 /* printf ("push: type=%d len=%d\n", TYPE_CODE (type), len); */
1000 if (len
<= 2 && regnum
<= ARGN_REGNUM
)
1001 /* fits in a single register, do not align */
1003 val
= extract_unsigned_integer (contents
, len
);
1004 regcache_cooked_write_unsigned (regcache
, regnum
++, val
);
1006 else if (len
<= (ARGN_REGNUM
- aligned_regnum
+ 1) * 2)
1007 /* value fits in remaining registers, store keeping left
1011 regnum
= aligned_regnum
;
1012 for (b
= 0; b
< (len
& ~1); b
+= 2)
1014 val
= extract_unsigned_integer (&contents
[b
], 2);
1015 regcache_cooked_write_unsigned (regcache
, regnum
++, val
);
1019 val
= extract_unsigned_integer (&contents
[b
], 1);
1020 regcache_cooked_write_unsigned (regcache
, regnum
++, (val
<< 8));
1025 /* arg will go onto stack */
1026 regnum
= ARGN_REGNUM
+ 1;
1027 si
= push_stack_item (si
, contents
, len
);
1033 sp
= (sp
- si
->len
) & ~1;
1034 write_memory (sp
, si
->data
, si
->len
);
1035 si
= pop_stack_item (si
);
1038 /* Finally, update the SP register. */
1039 regcache_cooked_write_unsigned (regcache
, D10V_SP_REGNUM
,
1040 d10v_convert_daddr_to_raw (sp
));
1046 /* Given a return value in `regbuf' with a type `valtype',
1047 extract and copy its value into `valbuf'. */
1050 d10v_extract_return_value (struct type
*type
, struct regcache
*regcache
,
1054 if (TYPE_LENGTH (type
) == 1)
1057 regcache_cooked_read_unsigned (regcache
, RET1_REGNUM
, &c
);
1058 store_unsigned_integer (valbuf
, 1, c
);
1062 /* For return values of odd size, the first byte is in the
1063 least significant part of the first register. The
1064 remaining bytes in remaining registers. Interestingly, when
1065 such values are passed in, the last byte is in the most
1066 significant byte of that same register - wierd. */
1067 int reg
= RET1_REGNUM
;
1069 if (TYPE_LENGTH (type
) & 1)
1071 regcache_cooked_read_part (regcache
, RET1_REGNUM
, 1, 1,
1072 (bfd_byte
*)valbuf
+ off
);
1076 /* Transfer the remaining registers. */
1077 for (; off
< TYPE_LENGTH (type
); reg
++, off
+= 2)
1079 regcache_cooked_read (regcache
, RET1_REGNUM
+ reg
,
1080 (bfd_byte
*) valbuf
+ off
);
1085 /* Translate a GDB virtual ADDR/LEN into a format the remote target
1086 understands. Returns number of bytes that can be transfered
1087 starting at TARG_ADDR. Return ZERO if no bytes can be transfered
1088 (segmentation fault). Since the simulator knows all about how the
1089 VM system works, we just call that to do the translation. */
1092 remote_d10v_translate_xfer_address (struct gdbarch
*gdbarch
,
1093 struct regcache
*regcache
,
1094 CORE_ADDR memaddr
, int nr_bytes
,
1095 CORE_ADDR
*targ_addr
, int *targ_len
)
1097 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1100 out_len
= sim_d10v_translate_addr (memaddr
, nr_bytes
, &out_addr
, regcache
,
1101 tdep
->dmap_register
, tdep
->imap_register
);
1102 *targ_addr
= out_addr
;
1103 *targ_len
= out_len
;
1107 /* The following code implements access to, and display of, the D10V's
1108 instruction trace buffer. The buffer consists of 64K or more
1109 4-byte words of data, of which each words includes an 8-bit count,
1110 an 8-bit segment number, and a 16-bit instruction address.
1112 In theory, the trace buffer is continuously capturing instruction
1113 data that the CPU presents on its "debug bus", but in practice, the
1114 ROMified GDB stub only enables tracing when it continues or steps
1115 the program, and stops tracing when the program stops; so it
1116 actually works for GDB to read the buffer counter out of memory and
1117 then read each trace word. The counter records where the tracing
1118 stops, but there is no record of where it started, so we remember
1119 the PC when we resumed and then search backwards in the trace
1120 buffer for a word that includes that address. This is not perfect,
1121 because you will miss trace data if the resumption PC is the target
1122 of a branch. (The value of the buffer counter is semi-random, any
1123 trace data from a previous program stop is gone.) */
1125 /* The address of the last word recorded in the trace buffer. */
1127 #define DBBC_ADDR (0xd80000)
1129 /* The base of the trace buffer, at least for the "Board_0". */
1131 #define TRACE_BUFFER_BASE (0xf40000)
1133 static void trace_command (char *, int);
1135 static void untrace_command (char *, int);
1137 static void trace_info (char *, int);
1139 static void tdisassemble_command (char *, int);
1141 static void display_trace (int, int);
1143 /* True when instruction traces are being collected. */
1147 /* Remembered PC. */
1149 static CORE_ADDR last_pc
;
1151 /* True when trace output should be displayed whenever program stops. */
1153 static int trace_display
;
1155 /* True when trace listing should include source lines. */
1157 static int default_trace_show_source
= 1;
1168 trace_command (char *args
, int from_tty
)
1170 /* Clear the host-side trace buffer, allocating space if needed. */
1171 trace_data
.size
= 0;
1172 if (trace_data
.counts
== NULL
)
1173 trace_data
.counts
= XCALLOC (65536, short);
1174 if (trace_data
.addrs
== NULL
)
1175 trace_data
.addrs
= XCALLOC (65536, CORE_ADDR
);
1179 printf_filtered ("Tracing is now on.\n");
1183 untrace_command (char *args
, int from_tty
)
1187 printf_filtered ("Tracing is now off.\n");
1191 trace_info (char *args
, int from_tty
)
1195 if (trace_data
.size
)
1197 printf_filtered ("%d entries in trace buffer:\n", trace_data
.size
);
1199 for (i
= 0; i
< trace_data
.size
; ++i
)
1201 printf_filtered ("%d: %d instruction%s at 0x%s\n",
1203 trace_data
.counts
[i
],
1204 (trace_data
.counts
[i
] == 1 ? "" : "s"),
1205 paddr_nz (trace_data
.addrs
[i
]));
1209 printf_filtered ("No entries in trace buffer.\n");
1211 printf_filtered ("Tracing is currently %s.\n", (tracing
? "on" : "off"));
1215 d10v_eva_prepare_to_trace (void)
1220 last_pc
= read_register (D10V_PC_REGNUM
);
1223 /* Collect trace data from the target board and format it into a form
1224 more useful for display. */
1227 d10v_eva_get_trace_data (void)
1229 int count
, i
, j
, oldsize
;
1230 int trace_addr
, trace_seg
, trace_cnt
, next_cnt
;
1231 unsigned int last_trace
, trace_word
, next_word
;
1232 unsigned int *tmpspace
;
1237 tmpspace
= xmalloc (65536 * sizeof (unsigned int));
1239 last_trace
= read_memory_unsigned_integer (DBBC_ADDR
, 2) << 2;
1241 /* Collect buffer contents from the target, stopping when we reach
1242 the word recorded when execution resumed. */
1245 while (last_trace
> 0)
1249 read_memory_unsigned_integer (TRACE_BUFFER_BASE
+ last_trace
, 4);
1250 trace_addr
= trace_word
& 0xffff;
1252 /* Ignore an apparently nonsensical entry. */
1253 if (trace_addr
== 0xffd5)
1255 tmpspace
[count
++] = trace_word
;
1256 if (trace_addr
== last_pc
)
1262 /* Move the data to the host-side trace buffer, adjusting counts to
1263 include the last instruction executed and transforming the address
1264 into something that GDB likes. */
1266 for (i
= 0; i
< count
; ++i
)
1268 trace_word
= tmpspace
[i
];
1269 next_word
= ((i
== 0) ? 0 : tmpspace
[i
- 1]);
1270 trace_addr
= trace_word
& 0xffff;
1271 next_cnt
= (next_word
>> 24) & 0xff;
1272 j
= trace_data
.size
+ count
- i
- 1;
1273 trace_data
.addrs
[j
] = (trace_addr
<< 2) + 0x1000000;
1274 trace_data
.counts
[j
] = next_cnt
+ 1;
1277 oldsize
= trace_data
.size
;
1278 trace_data
.size
+= count
;
1283 display_trace (oldsize
, trace_data
.size
);
1287 tdisassemble_command (char *arg
, int from_tty
)
1290 CORE_ADDR low
, high
;
1295 high
= trace_data
.size
;
1299 char *space_index
= strchr (arg
, ' ');
1300 if (space_index
== NULL
)
1302 low
= parse_and_eval_address (arg
);
1307 /* Two arguments. */
1308 *space_index
= '\0';
1309 low
= parse_and_eval_address (arg
);
1310 high
= parse_and_eval_address (space_index
+ 1);
1316 printf_filtered ("Dump of trace from %s to %s:\n", paddr_u (low
), paddr_u (high
));
1318 display_trace (low
, high
);
1320 printf_filtered ("End of trace dump.\n");
1321 gdb_flush (gdb_stdout
);
1325 display_trace (int low
, int high
)
1327 int i
, count
, trace_show_source
, first
, suppress
;
1328 CORE_ADDR next_address
;
1330 trace_show_source
= default_trace_show_source
;
1331 if (!have_full_symbols () && !have_partial_symbols ())
1333 trace_show_source
= 0;
1334 printf_filtered ("No symbol table is loaded. Use the \"file\" command.\n");
1335 printf_filtered ("Trace will not display any source.\n");
1340 for (i
= low
; i
< high
; ++i
)
1342 next_address
= trace_data
.addrs
[i
];
1343 count
= trace_data
.counts
[i
];
1347 if (trace_show_source
)
1349 struct symtab_and_line sal
, sal_prev
;
1351 sal_prev
= find_pc_line (next_address
- 4, 0);
1352 sal
= find_pc_line (next_address
, 0);
1356 if (first
|| sal
.line
!= sal_prev
.line
)
1357 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
1363 /* FIXME-32x64--assumes sal.pc fits in long. */
1364 printf_filtered ("No source file for address %s.\n",
1365 local_hex_string ((unsigned long) sal
.pc
));
1370 print_address (next_address
, gdb_stdout
);
1371 printf_filtered (":");
1372 printf_filtered ("\t");
1374 next_address
+= gdb_print_insn (next_address
, gdb_stdout
);
1375 printf_filtered ("\n");
1376 gdb_flush (gdb_stdout
);
1382 d10v_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1385 frame_unwind_unsigned_register (next_frame
, D10V_PC_REGNUM
, &pc
);
1386 return d10v_make_iaddr (pc
);
1389 /* Given a GDB frame, determine the address of the calling function's
1390 frame. This will be used to create a new GDB frame struct. */
1393 d10v_frame_this_id (struct frame_info
*next_frame
,
1394 void **this_prologue_cache
,
1395 struct frame_id
*this_id
)
1397 struct d10v_unwind_cache
*info
1398 = d10v_frame_unwind_cache (next_frame
, this_prologue_cache
);
1403 /* The FUNC is easy. */
1404 func
= frame_func_unwind (next_frame
);
1406 /* This is meant to halt the backtrace at "_start". Make sure we
1407 don't halt it at a generic dummy frame. */
1408 if (func
<= IMEM_START
|| inside_entry_file (func
))
1411 /* Hopefully the prologue analysis either correctly determined the
1412 frame's base (which is the SP from the previous frame), or set
1413 that base to "NULL". */
1414 base
= info
->prev_sp
;
1415 if (base
== STACK_START
|| base
== 0)
1418 id
= frame_id_build (base
, func
);
1420 /* Check that we're not going round in circles with the same frame
1421 ID (but avoid applying the test to sentinel frames which do go
1422 round in circles). Can't use frame_id_eq() as that doesn't yet
1423 compare the frame's PC value. */
1424 if (frame_relative_level (next_frame
) >= 0
1425 && get_frame_type (next_frame
) != DUMMY_FRAME
1426 && frame_id_eq (get_frame_id (next_frame
), id
))
1433 d10v_frame_prev_register (struct frame_info
*next_frame
,
1434 void **this_prologue_cache
,
1435 int regnum
, int *optimizedp
,
1436 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1437 int *realnump
, void *bufferp
)
1439 struct d10v_unwind_cache
*info
1440 = d10v_frame_unwind_cache (next_frame
, this_prologue_cache
);
1441 trad_frame_prev_register (next_frame
, info
->saved_regs
, regnum
,
1442 optimizedp
, lvalp
, addrp
, realnump
, bufferp
);
1445 static const struct frame_unwind d10v_frame_unwind
= {
1448 d10v_frame_prev_register
1451 static const struct frame_unwind
*
1452 d10v_frame_p (CORE_ADDR pc
)
1454 return &d10v_frame_unwind
;
1458 d10v_frame_base_address (struct frame_info
*next_frame
, void **this_cache
)
1460 struct d10v_unwind_cache
*info
1461 = d10v_frame_unwind_cache (next_frame
, this_cache
);
1465 static const struct frame_base d10v_frame_base
= {
1467 d10v_frame_base_address
,
1468 d10v_frame_base_address
,
1469 d10v_frame_base_address
1472 /* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
1473 dummy frame. The frame ID's base needs to match the TOS value
1474 saved by save_dummy_frame_tos(), and the PC match the dummy frame's
1477 static struct frame_id
1478 d10v_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1481 frame_unwind_unsigned_register (next_frame
, D10V_SP_REGNUM
, &base
);
1482 return frame_id_build (d10v_make_daddr (base
), frame_pc_unwind (next_frame
));
1485 static gdbarch_init_ftype d10v_gdbarch_init
;
1487 static struct gdbarch
*
1488 d10v_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1490 struct gdbarch
*gdbarch
;
1492 struct gdbarch_tdep
*tdep
;
1493 gdbarch_register_name_ftype
*d10v_register_name
;
1494 gdbarch_register_sim_regno_ftype
*d10v_register_sim_regno
;
1496 /* Find a candidate among the list of pre-declared architectures. */
1497 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1499 return arches
->gdbarch
;
1501 /* None found, create a new architecture from the information
1503 tdep
= XMALLOC (struct gdbarch_tdep
);
1504 gdbarch
= gdbarch_alloc (&info
, tdep
);
1506 switch (info
.bfd_arch_info
->mach
)
1508 case bfd_mach_d10v_ts2
:
1510 d10v_register_name
= d10v_ts2_register_name
;
1511 d10v_register_sim_regno
= d10v_ts2_register_sim_regno
;
1512 tdep
->a0_regnum
= TS2_A0_REGNUM
;
1513 tdep
->nr_dmap_regs
= TS2_NR_DMAP_REGS
;
1514 tdep
->dmap_register
= d10v_ts2_dmap_register
;
1515 tdep
->imap_register
= d10v_ts2_imap_register
;
1518 case bfd_mach_d10v_ts3
:
1520 d10v_register_name
= d10v_ts3_register_name
;
1521 d10v_register_sim_regno
= d10v_ts3_register_sim_regno
;
1522 tdep
->a0_regnum
= TS3_A0_REGNUM
;
1523 tdep
->nr_dmap_regs
= TS3_NR_DMAP_REGS
;
1524 tdep
->dmap_register
= d10v_ts3_dmap_register
;
1525 tdep
->imap_register
= d10v_ts3_imap_register
;
1529 set_gdbarch_read_pc (gdbarch
, d10v_read_pc
);
1530 set_gdbarch_write_pc (gdbarch
, d10v_write_pc
);
1531 set_gdbarch_read_sp (gdbarch
, d10v_read_sp
);
1533 set_gdbarch_num_regs (gdbarch
, d10v_num_regs
);
1534 set_gdbarch_sp_regnum (gdbarch
, D10V_SP_REGNUM
);
1535 set_gdbarch_register_name (gdbarch
, d10v_register_name
);
1536 set_gdbarch_register_type (gdbarch
, d10v_register_type
);
1538 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1539 set_gdbarch_addr_bit (gdbarch
, 32);
1540 set_gdbarch_address_to_pointer (gdbarch
, d10v_address_to_pointer
);
1541 set_gdbarch_pointer_to_address (gdbarch
, d10v_pointer_to_address
);
1542 set_gdbarch_integer_to_address (gdbarch
, d10v_integer_to_address
);
1543 set_gdbarch_short_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1544 set_gdbarch_int_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1545 set_gdbarch_long_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1546 set_gdbarch_long_long_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
1547 /* NOTE: The d10v as a 32 bit ``float'' and ``double''. ``long
1548 double'' is 64 bits. */
1549 set_gdbarch_float_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1550 set_gdbarch_double_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1551 set_gdbarch_long_double_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
1552 switch (info
.byte_order
)
1554 case BFD_ENDIAN_BIG
:
1555 set_gdbarch_float_format (gdbarch
, &floatformat_ieee_single_big
);
1556 set_gdbarch_double_format (gdbarch
, &floatformat_ieee_single_big
);
1557 set_gdbarch_long_double_format (gdbarch
, &floatformat_ieee_double_big
);
1559 case BFD_ENDIAN_LITTLE
:
1560 set_gdbarch_float_format (gdbarch
, &floatformat_ieee_single_little
);
1561 set_gdbarch_double_format (gdbarch
, &floatformat_ieee_single_little
);
1562 set_gdbarch_long_double_format (gdbarch
, &floatformat_ieee_double_little
);
1565 internal_error (__FILE__
, __LINE__
,
1566 "d10v_gdbarch_init: bad byte order for float format");
1569 set_gdbarch_extract_return_value (gdbarch
, d10v_extract_return_value
);
1570 set_gdbarch_push_dummy_code (gdbarch
, d10v_push_dummy_code
);
1571 set_gdbarch_push_dummy_call (gdbarch
, d10v_push_dummy_call
);
1572 set_gdbarch_store_return_value (gdbarch
, d10v_store_return_value
);
1573 set_gdbarch_extract_struct_value_address (gdbarch
, d10v_extract_struct_value_address
);
1574 set_gdbarch_use_struct_convention (gdbarch
, d10v_use_struct_convention
);
1576 set_gdbarch_skip_prologue (gdbarch
, d10v_skip_prologue
);
1577 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1578 set_gdbarch_decr_pc_after_break (gdbarch
, 4);
1579 set_gdbarch_function_start_offset (gdbarch
, 0);
1580 set_gdbarch_breakpoint_from_pc (gdbarch
, d10v_breakpoint_from_pc
);
1582 set_gdbarch_remote_translate_xfer_address (gdbarch
, remote_d10v_translate_xfer_address
);
1584 set_gdbarch_frame_args_skip (gdbarch
, 0);
1585 set_gdbarch_frameless_function_invocation (gdbarch
, frameless_look_for_prologue
);
1587 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
1588 set_gdbarch_frame_align (gdbarch
, d10v_frame_align
);
1590 set_gdbarch_register_sim_regno (gdbarch
, d10v_register_sim_regno
);
1592 set_gdbarch_print_registers_info (gdbarch
, d10v_print_registers_info
);
1594 frame_unwind_append_predicate (gdbarch
, d10v_frame_p
);
1595 frame_base_set_default (gdbarch
, &d10v_frame_base
);
1597 /* Methods for saving / extracting a dummy frame's ID. */
1598 set_gdbarch_unwind_dummy_id (gdbarch
, d10v_unwind_dummy_id
);
1599 set_gdbarch_save_dummy_frame_tos (gdbarch
, generic_save_dummy_frame_tos
);
1601 /* Return the unwound PC value. */
1602 set_gdbarch_unwind_pc (gdbarch
, d10v_unwind_pc
);
1604 set_gdbarch_print_insn (gdbarch
, print_insn_d10v
);
1610 _initialize_d10v_tdep (void)
1612 register_gdbarch_init (bfd_arch_d10v
, d10v_gdbarch_init
);
1614 target_resume_hook
= d10v_eva_prepare_to_trace
;
1615 target_wait_loop_hook
= d10v_eva_get_trace_data
;
1617 deprecate_cmd (add_com ("regs", class_vars
, show_regs
, "Print all registers"),
1620 add_com ("itrace", class_support
, trace_command
,
1621 "Enable tracing of instruction execution.");
1623 add_com ("iuntrace", class_support
, untrace_command
,
1624 "Disable tracing of instruction execution.");
1626 add_com ("itdisassemble", class_vars
, tdisassemble_command
,
1627 "Disassemble the trace buffer.\n\
1628 Two optional arguments specify a range of trace buffer entries\n\
1629 as reported by info trace (NOT addresses!).");
1631 add_info ("itrace", trace_info
,
1632 "Display info about the trace data buffer.");
1634 add_setshow_boolean_cmd ("itracedisplay", no_class
, &trace_display
,
1635 "Set automatic display of trace.\n",
1636 "Show automatic display of trace.\n",
1637 NULL
, NULL
, &setlist
, &showlist
);
1638 add_setshow_boolean_cmd ("itracesource", no_class
,
1639 &default_trace_show_source
,
1640 "Set display of source code with trace.\n",
1641 "Show display of source code with trace.\n",
1642 NULL
, NULL
, &setlist
, &showlist
);