1 /* Target-dependent code for Mitsubishi D10V, for GDB.
3 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002 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 */
32 #include "gdb_string.h"
39 #include "arch-utils.h"
42 #include "floatformat.h"
45 struct frame_extra_info
56 unsigned long (*dmap_register
) (int nr
);
57 unsigned long (*imap_register
) (int nr
);
60 /* These are the addresses the D10V-EVA board maps data and
61 instruction memory to. */
63 #define DMEM_START 0x2000000
64 #define IMEM_START 0x1000000
65 #define STACK_START 0x200bffe
67 /* d10v register names. */
77 #define NR_DMAP_REGS (gdbarch_tdep (current_gdbarch)->nr_dmap_regs)
78 #define A0_REGNUM (gdbarch_tdep (current_gdbarch)->a0_regnum)
80 /* d10v calling convention. */
82 #define ARG1_REGNUM R0_REGNUM
84 #define RET1_REGNUM R0_REGNUM
88 extern void _initialize_d10v_tdep (void);
90 static void d10v_eva_prepare_to_trace (void);
92 static void d10v_eva_get_trace_data (void);
94 static int prologue_find_regs (unsigned short op
, struct frame_info
*fi
,
97 static void d10v_frame_init_saved_regs (struct frame_info
*);
99 static void do_d10v_pop_frame (struct frame_info
*fi
);
102 d10v_frame_chain_valid (CORE_ADDR chain
, struct frame_info
*frame
)
104 return ((chain
) != 0 && (frame
) != 0
105 && (frame
)->pc
> IMEM_START
106 && !inside_entry_file (FRAME_SAVED_PC (frame
)));
110 d10v_stack_align (CORE_ADDR len
)
112 return (len
+ 1) & ~1;
115 /* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of
116 EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc
117 and TYPE is the type (which is known to be struct, union or array).
119 The d10v returns anything less than 8 bytes in size in
123 d10v_use_struct_convention (int gcc_p
, struct type
*type
)
127 /* The d10v only passes a struct in a register when that structure
128 has an alignment that matches the size of a register. */
129 /* If the structure doesn't fit in 4 registers, put it on the
131 if (TYPE_LENGTH (type
) > 8)
133 /* If the struct contains only one field, don't put it on the stack
134 - gcc can fit it in one or more registers. */
135 if (TYPE_NFIELDS (type
) == 1)
137 alignment
= TYPE_LENGTH (TYPE_FIELD_TYPE (type
, 0));
138 for (i
= 1; i
< TYPE_NFIELDS (type
); i
++)
140 /* If the alignment changes, just assume it goes on the
142 if (TYPE_LENGTH (TYPE_FIELD_TYPE (type
, i
)) != alignment
)
145 /* If the alignment is suitable for the d10v's 16 bit registers,
146 don't put it on the stack. */
147 if (alignment
== 2 || alignment
== 4)
153 static unsigned char *
154 d10v_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
156 static unsigned char breakpoint
[] =
157 {0x2f, 0x90, 0x5e, 0x00};
158 *lenptr
= sizeof (breakpoint
);
162 /* Map the REG_NR onto an ascii name. Return NULL or an empty string
163 when the reg_nr isn't valid. */
167 TS2_IMAP0_REGNUM
= 32,
168 TS2_DMAP_REGNUM
= 34,
169 TS2_NR_DMAP_REGS
= 1,
174 d10v_ts2_register_name (int reg_nr
)
176 static char *register_names
[] =
178 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
179 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
180 "psw", "bpsw", "pc", "bpc", "cr4", "cr5", "cr6", "rpt_c",
181 "rpt_s", "rpt_e", "mod_s", "mod_e", "cr12", "cr13", "iba", "cr15",
182 "imap0", "imap1", "dmap", "a0", "a1"
186 if (reg_nr
>= (sizeof (register_names
) / sizeof (*register_names
)))
188 return register_names
[reg_nr
];
193 TS3_IMAP0_REGNUM
= 36,
194 TS3_DMAP0_REGNUM
= 38,
195 TS3_NR_DMAP_REGS
= 4,
200 d10v_ts3_register_name (int reg_nr
)
202 static char *register_names
[] =
204 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
205 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
206 "psw", "bpsw", "pc", "bpc", "cr4", "cr5", "cr6", "rpt_c",
207 "rpt_s", "rpt_e", "mod_s", "mod_e", "cr12", "cr13", "iba", "cr15",
211 "dmap0", "dmap1", "dmap2", "dmap3"
215 if (reg_nr
>= (sizeof (register_names
) / sizeof (*register_names
)))
217 return register_names
[reg_nr
];
220 /* Access the DMAP/IMAP registers in a target independent way.
222 Divide the D10V's 64k data space into four 16k segments:
223 0x0000 -- 0x3fff, 0x4000 -- 0x7fff, 0x8000 -- 0xbfff, and
226 On the TS2, the first two segments (0x0000 -- 0x3fff, 0x4000 --
227 0x7fff) always map to the on-chip data RAM, and the fourth always
228 maps to I/O space. The third (0x8000 - 0xbfff) can be mapped into
229 unified memory or instruction memory, under the control of the
230 single DMAP register.
232 On the TS3, there are four DMAP registers, each of which controls
233 one of the segments. */
236 d10v_ts2_dmap_register (int reg_nr
)
244 return read_register (TS2_DMAP_REGNUM
);
251 d10v_ts3_dmap_register (int reg_nr
)
253 return read_register (TS3_DMAP0_REGNUM
+ reg_nr
);
257 d10v_dmap_register (int reg_nr
)
259 return gdbarch_tdep (current_gdbarch
)->dmap_register (reg_nr
);
263 d10v_ts2_imap_register (int reg_nr
)
265 return read_register (TS2_IMAP0_REGNUM
+ reg_nr
);
269 d10v_ts3_imap_register (int reg_nr
)
271 return read_register (TS3_IMAP0_REGNUM
+ reg_nr
);
275 d10v_imap_register (int reg_nr
)
277 return gdbarch_tdep (current_gdbarch
)->imap_register (reg_nr
);
280 /* MAP GDB's internal register numbering (determined by the layout fo
281 the REGISTER_BYTE array) onto the simulator's register
285 d10v_ts2_register_sim_regno (int nr
)
287 if (nr
>= TS2_IMAP0_REGNUM
288 && nr
< TS2_IMAP0_REGNUM
+ NR_IMAP_REGS
)
289 return nr
- TS2_IMAP0_REGNUM
+ SIM_D10V_IMAP0_REGNUM
;
290 if (nr
== TS2_DMAP_REGNUM
)
291 return nr
- TS2_DMAP_REGNUM
+ SIM_D10V_TS2_DMAP_REGNUM
;
292 if (nr
>= TS2_A0_REGNUM
293 && nr
< TS2_A0_REGNUM
+ NR_A_REGS
)
294 return nr
- TS2_A0_REGNUM
+ SIM_D10V_A0_REGNUM
;
299 d10v_ts3_register_sim_regno (int nr
)
301 if (nr
>= TS3_IMAP0_REGNUM
302 && nr
< TS3_IMAP0_REGNUM
+ NR_IMAP_REGS
)
303 return nr
- TS3_IMAP0_REGNUM
+ SIM_D10V_IMAP0_REGNUM
;
304 if (nr
>= TS3_DMAP0_REGNUM
305 && nr
< TS3_DMAP0_REGNUM
+ TS3_NR_DMAP_REGS
)
306 return nr
- TS3_DMAP0_REGNUM
+ SIM_D10V_DMAP0_REGNUM
;
307 if (nr
>= TS3_A0_REGNUM
308 && nr
< TS3_A0_REGNUM
+ NR_A_REGS
)
309 return nr
- TS3_A0_REGNUM
+ SIM_D10V_A0_REGNUM
;
313 /* Index within `registers' of the first byte of the space for
317 d10v_register_byte (int reg_nr
)
319 if (reg_nr
< A0_REGNUM
)
321 else if (reg_nr
< (A0_REGNUM
+ NR_A_REGS
))
322 return (A0_REGNUM
* 2
323 + (reg_nr
- A0_REGNUM
) * 8);
325 return (A0_REGNUM
* 2
327 + (reg_nr
- A0_REGNUM
- NR_A_REGS
) * 2);
330 /* Number of bytes of storage in the actual machine representation for
334 d10v_register_raw_size (int reg_nr
)
336 if (reg_nr
< A0_REGNUM
)
338 else if (reg_nr
< (A0_REGNUM
+ NR_A_REGS
))
344 /* Return the GDB type object for the "standard" data type
345 of data in register N. */
348 d10v_register_virtual_type (int reg_nr
)
350 if (reg_nr
== PC_REGNUM
)
351 return builtin_type_void_func_ptr
;
352 else if (reg_nr
>= A0_REGNUM
353 && reg_nr
< (A0_REGNUM
+ NR_A_REGS
))
354 return builtin_type_int64
;
356 return builtin_type_int16
;
360 d10v_make_daddr (CORE_ADDR x
)
362 return ((x
) | DMEM_START
);
366 d10v_make_iaddr (CORE_ADDR x
)
368 return (((x
) << 2) | IMEM_START
);
372 d10v_daddr_p (CORE_ADDR x
)
374 return (((x
) & 0x3000000) == DMEM_START
);
378 d10v_iaddr_p (CORE_ADDR x
)
380 return (((x
) & 0x3000000) == IMEM_START
);
385 d10v_convert_iaddr_to_raw (CORE_ADDR x
)
387 return (((x
) >> 2) & 0xffff);
391 d10v_convert_daddr_to_raw (CORE_ADDR x
)
393 return ((x
) & 0xffff);
397 d10v_address_to_pointer (struct type
*type
, void *buf
, CORE_ADDR addr
)
399 /* Is it a code address? */
400 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
401 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_METHOD
)
403 store_unsigned_integer (buf
, TYPE_LENGTH (type
),
404 d10v_convert_iaddr_to_raw (addr
));
408 /* Strip off any upper segment bits. */
409 store_unsigned_integer (buf
, TYPE_LENGTH (type
),
410 d10v_convert_daddr_to_raw (addr
));
415 d10v_pointer_to_address (struct type
*type
, void *buf
)
417 CORE_ADDR addr
= extract_address (buf
, TYPE_LENGTH (type
));
419 /* Is it a code address? */
420 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
421 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_METHOD
422 || TYPE_CODE_SPACE (TYPE_TARGET_TYPE (type
)))
423 return d10v_make_iaddr (addr
);
425 return d10v_make_daddr (addr
);
429 d10v_integer_to_address (struct type
*type
, void *buf
)
432 val
= unpack_long (type
, buf
);
433 if (TYPE_CODE (type
) == TYPE_CODE_INT
434 && TYPE_LENGTH (type
) <= TYPE_LENGTH (builtin_type_void_data_ptr
))
435 /* Convert small integers that would would be directly copied into
436 a pointer variable into an address pointing into data space. */
437 return d10v_make_daddr (val
& 0xffff);
439 /* The value is too large to fit in a pointer. Assume this was
440 intentional and that the user in fact specified a raw address. */
444 /* Store the address of the place in which to copy the structure the
445 subroutine will return. This is called from call_function.
447 We store structs through a pointer passed in the first Argument
451 d10v_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
453 write_register (ARG1_REGNUM
, (addr
));
456 /* Write into appropriate registers a function return value
457 of type TYPE, given in virtual format.
459 Things always get returned in RET1_REGNUM, RET2_REGNUM, ... */
462 d10v_store_return_value (struct type
*type
, char *valbuf
)
464 write_register_bytes (REGISTER_BYTE (RET1_REGNUM
),
469 /* Extract from an array REGBUF containing the (raw) register state
470 the address in which a function should return its structure value,
471 as a CORE_ADDR (or an expression that can be used as one). */
474 d10v_extract_struct_value_address (char *regbuf
)
476 return (extract_address ((regbuf
) + REGISTER_BYTE (ARG1_REGNUM
),
477 REGISTER_RAW_SIZE (ARG1_REGNUM
))
482 d10v_frame_saved_pc (struct frame_info
*frame
)
484 return ((frame
)->extra_info
->return_pc
);
487 /* Immediately after a function call, return the saved pc. We can't
488 use frame->return_pc beause that is determined by reading R13 off
489 the stack and that may not be written yet. */
492 d10v_saved_pc_after_call (struct frame_info
*frame
)
494 return ((read_register (LR_REGNUM
) << 2)
498 /* Discard from the stack the innermost frame, restoring all saved
502 d10v_pop_frame (void)
504 generic_pop_current_frame (do_d10v_pop_frame
);
508 do_d10v_pop_frame (struct frame_info
*fi
)
515 /* fill out fsr with the address of where each */
516 /* register was stored in the frame */
517 d10v_frame_init_saved_regs (fi
);
519 /* now update the current registers with the old values */
520 for (regnum
= A0_REGNUM
; regnum
< A0_REGNUM
+ NR_A_REGS
; regnum
++)
522 if (fi
->saved_regs
[regnum
])
524 read_memory (fi
->saved_regs
[regnum
], raw_buffer
, REGISTER_RAW_SIZE (regnum
));
525 write_register_bytes (REGISTER_BYTE (regnum
), raw_buffer
, REGISTER_RAW_SIZE (regnum
));
528 for (regnum
= 0; regnum
< SP_REGNUM
; regnum
++)
530 if (fi
->saved_regs
[regnum
])
532 write_register (regnum
, read_memory_unsigned_integer (fi
->saved_regs
[regnum
], REGISTER_RAW_SIZE (regnum
)));
535 if (fi
->saved_regs
[PSW_REGNUM
])
537 write_register (PSW_REGNUM
, read_memory_unsigned_integer (fi
->saved_regs
[PSW_REGNUM
], REGISTER_RAW_SIZE (PSW_REGNUM
)));
540 write_register (PC_REGNUM
, read_register (LR_REGNUM
));
541 write_register (SP_REGNUM
, fp
+ fi
->extra_info
->size
);
542 target_store_registers (-1);
543 flush_cached_frames ();
547 check_prologue (unsigned short op
)
550 if ((op
& 0x7E1F) == 0x6C1F)
554 if ((op
& 0x7E3F) == 0x6E1F)
558 if ((op
& 0x7FE1) == 0x01E1)
570 if ((op
& 0x7E1F) == 0x681E)
574 if ((op
& 0x7E3F) == 0x3A1E)
581 d10v_skip_prologue (CORE_ADDR pc
)
584 unsigned short op1
, op2
;
585 CORE_ADDR func_addr
, func_end
;
586 struct symtab_and_line sal
;
588 /* If we have line debugging information, then the end of the */
589 /* prologue should the first assembly instruction of the first source line */
590 if (find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
592 sal
= find_pc_line (func_addr
, 0);
593 if (sal
.end
&& sal
.end
< func_end
)
597 if (target_read_memory (pc
, (char *) &op
, 4))
598 return pc
; /* Can't access it -- assume no prologue. */
602 op
= (unsigned long) read_memory_integer (pc
, 4);
603 if ((op
& 0xC0000000) == 0xC0000000)
605 /* long instruction */
606 if (((op
& 0x3FFF0000) != 0x01FF0000) && /* add3 sp,sp,n */
607 ((op
& 0x3F0F0000) != 0x340F0000) && /* st rn, @(offset,sp) */
608 ((op
& 0x3F1F0000) != 0x350F0000)) /* st2w rn, @(offset,sp) */
613 /* short instructions */
614 if ((op
& 0xC0000000) == 0x80000000)
616 op2
= (op
& 0x3FFF8000) >> 15;
621 op1
= (op
& 0x3FFF8000) >> 15;
624 if (check_prologue (op1
))
626 if (!check_prologue (op2
))
628 /* if the previous opcode was really part of the prologue */
629 /* and not just a NOP, then we want to break after both instructions */
643 /* Given a GDB frame, determine the address of the calling function's frame.
644 This will be used to create a new GDB frame struct, and then
645 INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
649 d10v_frame_chain (struct frame_info
*fi
)
651 d10v_frame_init_saved_regs (fi
);
653 if (fi
->extra_info
->return_pc
== IMEM_START
654 || inside_entry_file (fi
->extra_info
->return_pc
))
655 return (CORE_ADDR
) 0;
657 if (!fi
->saved_regs
[FP_REGNUM
])
659 if (!fi
->saved_regs
[SP_REGNUM
]
660 || fi
->saved_regs
[SP_REGNUM
] == STACK_START
)
661 return (CORE_ADDR
) 0;
663 return fi
->saved_regs
[SP_REGNUM
];
666 if (!read_memory_unsigned_integer (fi
->saved_regs
[FP_REGNUM
],
667 REGISTER_RAW_SIZE (FP_REGNUM
)))
668 return (CORE_ADDR
) 0;
670 return d10v_make_daddr (read_memory_unsigned_integer (fi
->saved_regs
[FP_REGNUM
],
671 REGISTER_RAW_SIZE (FP_REGNUM
)));
674 static int next_addr
, uses_frame
;
677 prologue_find_regs (unsigned short op
, struct frame_info
*fi
, CORE_ADDR addr
)
682 if ((op
& 0x7E1F) == 0x6C1F)
684 n
= (op
& 0x1E0) >> 5;
686 fi
->saved_regs
[n
] = next_addr
;
691 else if ((op
& 0x7E3F) == 0x6E1F)
693 n
= (op
& 0x1E0) >> 5;
695 fi
->saved_regs
[n
] = next_addr
;
696 fi
->saved_regs
[n
+ 1] = next_addr
+ 2;
701 if ((op
& 0x7FE1) == 0x01E1)
703 n
= (op
& 0x1E) >> 1;
722 if ((op
& 0x7E1F) == 0x681E)
724 n
= (op
& 0x1E0) >> 5;
725 fi
->saved_regs
[n
] = next_addr
;
730 if ((op
& 0x7E3F) == 0x3A1E)
732 n
= (op
& 0x1E0) >> 5;
733 fi
->saved_regs
[n
] = next_addr
;
734 fi
->saved_regs
[n
+ 1] = next_addr
+ 2;
741 /* Put here the code to store, into fi->saved_regs, the addresses of
742 the saved registers of frame described by FRAME_INFO. This
743 includes special registers such as pc and fp saved in special ways
744 in the stack frame. sp is even more special: the address we return
745 for it IS the sp for the next frame. */
748 d10v_frame_init_saved_regs (struct frame_info
*fi
)
752 unsigned short op1
, op2
;
756 memset (fi
->saved_regs
, 0, SIZEOF_FRAME_SAVED_REGS
);
759 pc
= get_pc_function_start (fi
->pc
);
764 op
= (unsigned long) read_memory_integer (pc
, 4);
765 if ((op
& 0xC0000000) == 0xC0000000)
767 /* long instruction */
768 if ((op
& 0x3FFF0000) == 0x01FF0000)
771 short n
= op
& 0xFFFF;
774 else if ((op
& 0x3F0F0000) == 0x340F0000)
776 /* st rn, @(offset,sp) */
777 short offset
= op
& 0xFFFF;
778 short n
= (op
>> 20) & 0xF;
779 fi
->saved_regs
[n
] = next_addr
+ offset
;
781 else if ((op
& 0x3F1F0000) == 0x350F0000)
783 /* st2w rn, @(offset,sp) */
784 short offset
= op
& 0xFFFF;
785 short n
= (op
>> 20) & 0xF;
786 fi
->saved_regs
[n
] = next_addr
+ offset
;
787 fi
->saved_regs
[n
+ 1] = next_addr
+ offset
+ 2;
794 /* short instructions */
795 if ((op
& 0xC0000000) == 0x80000000)
797 op2
= (op
& 0x3FFF8000) >> 15;
802 op1
= (op
& 0x3FFF8000) >> 15;
805 if (!prologue_find_regs (op1
, fi
, pc
) || !prologue_find_regs (op2
, fi
, pc
))
811 fi
->extra_info
->size
= -next_addr
;
814 fp
= d10v_make_daddr (read_register (SP_REGNUM
));
816 for (i
= 0; i
< NUM_REGS
- 1; i
++)
817 if (fi
->saved_regs
[i
])
819 fi
->saved_regs
[i
] = fp
- (next_addr
- fi
->saved_regs
[i
]);
822 if (fi
->saved_regs
[LR_REGNUM
])
824 CORE_ADDR return_pc
= read_memory_unsigned_integer (fi
->saved_regs
[LR_REGNUM
], REGISTER_RAW_SIZE (LR_REGNUM
));
825 fi
->extra_info
->return_pc
= d10v_make_iaddr (return_pc
);
829 fi
->extra_info
->return_pc
= d10v_make_iaddr (read_register (LR_REGNUM
));
832 /* th SP is not normally (ever?) saved, but check anyway */
833 if (!fi
->saved_regs
[SP_REGNUM
])
835 /* if the FP was saved, that means the current FP is valid, */
836 /* otherwise, it isn't being used, so we use the SP instead */
838 fi
->saved_regs
[SP_REGNUM
] = read_register (FP_REGNUM
) + fi
->extra_info
->size
;
841 fi
->saved_regs
[SP_REGNUM
] = fp
+ fi
->extra_info
->size
;
842 fi
->extra_info
->frameless
= 1;
843 fi
->saved_regs
[FP_REGNUM
] = 0;
849 d10v_init_extra_frame_info (int fromleaf
, struct frame_info
*fi
)
851 fi
->extra_info
= (struct frame_extra_info
*)
852 frame_obstack_alloc (sizeof (struct frame_extra_info
));
853 frame_saved_regs_zalloc (fi
);
855 fi
->extra_info
->frameless
= 0;
856 fi
->extra_info
->size
= 0;
857 fi
->extra_info
->return_pc
= 0;
859 /* The call dummy doesn't save any registers on the stack, so we can
861 if (PC_IN_CALL_DUMMY (fi
->pc
, fi
->frame
, fi
->frame
))
867 d10v_frame_init_saved_regs (fi
);
872 show_regs (char *args
, int from_tty
)
875 printf_filtered ("PC=%04lx (0x%lx) PSW=%04lx RPT_S=%04lx RPT_E=%04lx RPT_C=%04lx\n",
876 (long) read_register (PC_REGNUM
),
877 (long) d10v_make_iaddr (read_register (PC_REGNUM
)),
878 (long) read_register (PSW_REGNUM
),
879 (long) read_register (24),
880 (long) read_register (25),
881 (long) read_register (23));
882 printf_filtered ("R0-R7 %04lx %04lx %04lx %04lx %04lx %04lx %04lx %04lx\n",
883 (long) read_register (0),
884 (long) read_register (1),
885 (long) read_register (2),
886 (long) read_register (3),
887 (long) read_register (4),
888 (long) read_register (5),
889 (long) read_register (6),
890 (long) read_register (7));
891 printf_filtered ("R8-R15 %04lx %04lx %04lx %04lx %04lx %04lx %04lx %04lx\n",
892 (long) read_register (8),
893 (long) read_register (9),
894 (long) read_register (10),
895 (long) read_register (11),
896 (long) read_register (12),
897 (long) read_register (13),
898 (long) read_register (14),
899 (long) read_register (15));
900 for (a
= 0; a
< NR_IMAP_REGS
; a
++)
903 printf_filtered (" ");
904 printf_filtered ("IMAP%d %04lx", a
, d10v_imap_register (a
));
906 if (NR_DMAP_REGS
== 1)
907 printf_filtered (" DMAP %04lx\n", d10v_dmap_register (2));
910 for (a
= 0; a
< NR_DMAP_REGS
; a
++)
912 printf_filtered (" DMAP%d %04lx", a
, d10v_dmap_register (a
));
914 printf_filtered ("\n");
916 printf_filtered ("A0-A%d", NR_A_REGS
- 1);
917 for (a
= A0_REGNUM
; a
< A0_REGNUM
+ NR_A_REGS
; a
++)
919 char num
[MAX_REGISTER_RAW_SIZE
];
921 printf_filtered (" ");
922 read_register_gen (a
, (char *) &num
);
923 for (i
= 0; i
< MAX_REGISTER_RAW_SIZE
; i
++)
925 printf_filtered ("%02x", (num
[i
] & 0xff));
928 printf_filtered ("\n");
932 d10v_read_pc (ptid_t ptid
)
938 save_ptid
= inferior_ptid
;
939 inferior_ptid
= ptid
;
940 pc
= (int) read_register (PC_REGNUM
);
941 inferior_ptid
= save_ptid
;
942 retval
= d10v_make_iaddr (pc
);
947 d10v_write_pc (CORE_ADDR val
, ptid_t ptid
)
951 save_ptid
= inferior_ptid
;
952 inferior_ptid
= ptid
;
953 write_register (PC_REGNUM
, d10v_convert_iaddr_to_raw (val
));
954 inferior_ptid
= save_ptid
;
960 return (d10v_make_daddr (read_register (SP_REGNUM
)));
964 d10v_write_sp (CORE_ADDR val
)
966 write_register (SP_REGNUM
, d10v_convert_daddr_to_raw (val
));
970 d10v_write_fp (CORE_ADDR val
)
972 write_register (FP_REGNUM
, d10v_convert_daddr_to_raw (val
));
978 return (d10v_make_daddr (read_register (FP_REGNUM
)));
981 /* Function: push_return_address (pc)
982 Set up the return address for the inferior function call.
983 Needed for targets where we don't actually execute a JSR/BSR instruction */
986 d10v_push_return_address (CORE_ADDR pc
, CORE_ADDR sp
)
988 write_register (LR_REGNUM
, d10v_convert_iaddr_to_raw (CALL_DUMMY_ADDRESS ()));
993 /* When arguments must be pushed onto the stack, they go on in reverse
994 order. The below implements a FILO (stack) to do this. */
999 struct stack_item
*prev
;
1003 static struct stack_item
*push_stack_item (struct stack_item
*prev
,
1004 void *contents
, int len
);
1005 static struct stack_item
*
1006 push_stack_item (struct stack_item
*prev
, void *contents
, int len
)
1008 struct stack_item
*si
;
1009 si
= xmalloc (sizeof (struct stack_item
));
1010 si
->data
= xmalloc (len
);
1013 memcpy (si
->data
, contents
, len
);
1017 static struct stack_item
*pop_stack_item (struct stack_item
*si
);
1018 static struct stack_item
*
1019 pop_stack_item (struct stack_item
*si
)
1021 struct stack_item
*dead
= si
;
1030 d10v_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
1031 int struct_return
, CORE_ADDR struct_addr
)
1034 int regnum
= ARG1_REGNUM
;
1035 struct stack_item
*si
= NULL
;
1037 /* Fill in registers and arg lists */
1038 for (i
= 0; i
< nargs
; i
++)
1040 struct value
*arg
= args
[i
];
1041 struct type
*type
= check_typedef (VALUE_TYPE (arg
));
1042 char *contents
= VALUE_CONTENTS (arg
);
1043 int len
= TYPE_LENGTH (type
);
1044 /* printf ("push: type=%d len=%d\n", type->code, len); */
1046 int aligned_regnum
= (regnum
+ 1) & ~1;
1047 if (len
<= 2 && regnum
<= ARGN_REGNUM
)
1048 /* fits in a single register, do not align */
1050 long val
= extract_unsigned_integer (contents
, len
);
1051 write_register (regnum
++, val
);
1053 else if (len
<= (ARGN_REGNUM
- aligned_regnum
+ 1) * 2)
1054 /* value fits in remaining registers, store keeping left
1058 regnum
= aligned_regnum
;
1059 for (b
= 0; b
< (len
& ~1); b
+= 2)
1061 long val
= extract_unsigned_integer (&contents
[b
], 2);
1062 write_register (regnum
++, val
);
1066 long val
= extract_unsigned_integer (&contents
[b
], 1);
1067 write_register (regnum
++, (val
<< 8));
1072 /* arg will go onto stack */
1073 regnum
= ARGN_REGNUM
+ 1;
1074 si
= push_stack_item (si
, contents
, len
);
1081 sp
= (sp
- si
->len
) & ~1;
1082 write_memory (sp
, si
->data
, si
->len
);
1083 si
= pop_stack_item (si
);
1090 /* Given a return value in `regbuf' with a type `valtype',
1091 extract and copy its value into `valbuf'. */
1094 d10v_extract_return_value (struct type
*type
, char regbuf
[REGISTER_BYTES
],
1098 /* 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))); */
1100 len
= TYPE_LENGTH (type
);
1103 unsigned short c
= extract_unsigned_integer (regbuf
+ REGISTER_BYTE (RET1_REGNUM
), REGISTER_RAW_SIZE (RET1_REGNUM
));
1104 store_unsigned_integer (valbuf
, 1, c
);
1106 else if ((len
& 1) == 0)
1107 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (RET1_REGNUM
), len
);
1110 /* For return values of odd size, the first byte is in the
1111 least significant part of the first register. The
1112 remaining bytes in remaining registers. Interestingly,
1113 when such values are passed in, the last byte is in the
1114 most significant byte of that same register - wierd. */
1115 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (RET1_REGNUM
) + 1, len
);
1120 /* Translate a GDB virtual ADDR/LEN into a format the remote target
1121 understands. Returns number of bytes that can be transfered
1122 starting at TARG_ADDR. Return ZERO if no bytes can be transfered
1123 (segmentation fault). Since the simulator knows all about how the
1124 VM system works, we just call that to do the translation. */
1127 remote_d10v_translate_xfer_address (CORE_ADDR memaddr
, int nr_bytes
,
1128 CORE_ADDR
*targ_addr
, int *targ_len
)
1132 out_len
= sim_d10v_translate_addr (memaddr
, nr_bytes
,
1135 d10v_imap_register
);
1136 *targ_addr
= out_addr
;
1137 *targ_len
= out_len
;
1141 /* The following code implements access to, and display of, the D10V's
1142 instruction trace buffer. The buffer consists of 64K or more
1143 4-byte words of data, of which each words includes an 8-bit count,
1144 an 8-bit segment number, and a 16-bit instruction address.
1146 In theory, the trace buffer is continuously capturing instruction
1147 data that the CPU presents on its "debug bus", but in practice, the
1148 ROMified GDB stub only enables tracing when it continues or steps
1149 the program, and stops tracing when the program stops; so it
1150 actually works for GDB to read the buffer counter out of memory and
1151 then read each trace word. The counter records where the tracing
1152 stops, but there is no record of where it started, so we remember
1153 the PC when we resumed and then search backwards in the trace
1154 buffer for a word that includes that address. This is not perfect,
1155 because you will miss trace data if the resumption PC is the target
1156 of a branch. (The value of the buffer counter is semi-random, any
1157 trace data from a previous program stop is gone.) */
1159 /* The address of the last word recorded in the trace buffer. */
1161 #define DBBC_ADDR (0xd80000)
1163 /* The base of the trace buffer, at least for the "Board_0". */
1165 #define TRACE_BUFFER_BASE (0xf40000)
1167 static void trace_command (char *, int);
1169 static void untrace_command (char *, int);
1171 static void trace_info (char *, int);
1173 static void tdisassemble_command (char *, int);
1175 static void display_trace (int, int);
1177 /* True when instruction traces are being collected. */
1181 /* Remembered PC. */
1183 static CORE_ADDR last_pc
;
1185 /* True when trace output should be displayed whenever program stops. */
1187 static int trace_display
;
1189 /* True when trace listing should include source lines. */
1191 static int default_trace_show_source
= 1;
1202 trace_command (char *args
, int from_tty
)
1204 /* Clear the host-side trace buffer, allocating space if needed. */
1205 trace_data
.size
= 0;
1206 if (trace_data
.counts
== NULL
)
1207 trace_data
.counts
= (short *) xmalloc (65536 * sizeof (short));
1208 if (trace_data
.addrs
== NULL
)
1209 trace_data
.addrs
= (CORE_ADDR
*) xmalloc (65536 * sizeof (CORE_ADDR
));
1213 printf_filtered ("Tracing is now on.\n");
1217 untrace_command (char *args
, int from_tty
)
1221 printf_filtered ("Tracing is now off.\n");
1225 trace_info (char *args
, int from_tty
)
1229 if (trace_data
.size
)
1231 printf_filtered ("%d entries in trace buffer:\n", trace_data
.size
);
1233 for (i
= 0; i
< trace_data
.size
; ++i
)
1235 printf_filtered ("%d: %d instruction%s at 0x%s\n",
1237 trace_data
.counts
[i
],
1238 (trace_data
.counts
[i
] == 1 ? "" : "s"),
1239 paddr_nz (trace_data
.addrs
[i
]));
1243 printf_filtered ("No entries in trace buffer.\n");
1245 printf_filtered ("Tracing is currently %s.\n", (tracing
? "on" : "off"));
1248 /* Print the instruction at address MEMADDR in debugged memory,
1249 on STREAM. Returns length of the instruction, in bytes. */
1252 print_insn (CORE_ADDR memaddr
, struct ui_file
*stream
)
1254 /* If there's no disassembler, something is very wrong. */
1255 if (tm_print_insn
== NULL
)
1256 internal_error (__FILE__
, __LINE__
,
1257 "print_insn: no disassembler");
1259 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
1260 tm_print_insn_info
.endian
= BFD_ENDIAN_BIG
;
1262 tm_print_insn_info
.endian
= BFD_ENDIAN_LITTLE
;
1263 return TARGET_PRINT_INSN (memaddr
, &tm_print_insn_info
);
1267 d10v_eva_prepare_to_trace (void)
1272 last_pc
= read_register (PC_REGNUM
);
1275 /* Collect trace data from the target board and format it into a form
1276 more useful for display. */
1279 d10v_eva_get_trace_data (void)
1281 int count
, i
, j
, oldsize
;
1282 int trace_addr
, trace_seg
, trace_cnt
, next_cnt
;
1283 unsigned int last_trace
, trace_word
, next_word
;
1284 unsigned int *tmpspace
;
1289 tmpspace
= xmalloc (65536 * sizeof (unsigned int));
1291 last_trace
= read_memory_unsigned_integer (DBBC_ADDR
, 2) << 2;
1293 /* Collect buffer contents from the target, stopping when we reach
1294 the word recorded when execution resumed. */
1297 while (last_trace
> 0)
1301 read_memory_unsigned_integer (TRACE_BUFFER_BASE
+ last_trace
, 4);
1302 trace_addr
= trace_word
& 0xffff;
1304 /* Ignore an apparently nonsensical entry. */
1305 if (trace_addr
== 0xffd5)
1307 tmpspace
[count
++] = trace_word
;
1308 if (trace_addr
== last_pc
)
1314 /* Move the data to the host-side trace buffer, adjusting counts to
1315 include the last instruction executed and transforming the address
1316 into something that GDB likes. */
1318 for (i
= 0; i
< count
; ++i
)
1320 trace_word
= tmpspace
[i
];
1321 next_word
= ((i
== 0) ? 0 : tmpspace
[i
- 1]);
1322 trace_addr
= trace_word
& 0xffff;
1323 next_cnt
= (next_word
>> 24) & 0xff;
1324 j
= trace_data
.size
+ count
- i
- 1;
1325 trace_data
.addrs
[j
] = (trace_addr
<< 2) + 0x1000000;
1326 trace_data
.counts
[j
] = next_cnt
+ 1;
1329 oldsize
= trace_data
.size
;
1330 trace_data
.size
+= count
;
1335 display_trace (oldsize
, trace_data
.size
);
1339 tdisassemble_command (char *arg
, int from_tty
)
1342 CORE_ADDR low
, high
;
1348 high
= trace_data
.size
;
1350 else if (!(space_index
= (char *) strchr (arg
, ' ')))
1352 low
= parse_and_eval_address (arg
);
1357 /* Two arguments. */
1358 *space_index
= '\0';
1359 low
= parse_and_eval_address (arg
);
1360 high
= parse_and_eval_address (space_index
+ 1);
1365 printf_filtered ("Dump of trace from %s to %s:\n", paddr_u (low
), paddr_u (high
));
1367 display_trace (low
, high
);
1369 printf_filtered ("End of trace dump.\n");
1370 gdb_flush (gdb_stdout
);
1374 display_trace (int low
, int high
)
1376 int i
, count
, trace_show_source
, first
, suppress
;
1377 CORE_ADDR next_address
;
1379 trace_show_source
= default_trace_show_source
;
1380 if (!have_full_symbols () && !have_partial_symbols ())
1382 trace_show_source
= 0;
1383 printf_filtered ("No symbol table is loaded. Use the \"file\" command.\n");
1384 printf_filtered ("Trace will not display any source.\n");
1389 for (i
= low
; i
< high
; ++i
)
1391 next_address
= trace_data
.addrs
[i
];
1392 count
= trace_data
.counts
[i
];
1396 if (trace_show_source
)
1398 struct symtab_and_line sal
, sal_prev
;
1400 sal_prev
= find_pc_line (next_address
- 4, 0);
1401 sal
= find_pc_line (next_address
, 0);
1405 if (first
|| sal
.line
!= sal_prev
.line
)
1406 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
1412 /* FIXME-32x64--assumes sal.pc fits in long. */
1413 printf_filtered ("No source file for address %s.\n",
1414 local_hex_string ((unsigned long) sal
.pc
));
1419 print_address (next_address
, gdb_stdout
);
1420 printf_filtered (":");
1421 printf_filtered ("\t");
1423 next_address
= next_address
+ print_insn (next_address
, gdb_stdout
);
1424 printf_filtered ("\n");
1425 gdb_flush (gdb_stdout
);
1431 static gdbarch_init_ftype d10v_gdbarch_init
;
1433 static struct gdbarch
*
1434 d10v_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1436 static LONGEST d10v_call_dummy_words
[] =
1438 struct gdbarch
*gdbarch
;
1440 struct gdbarch_tdep
*tdep
;
1441 gdbarch_register_name_ftype
*d10v_register_name
;
1442 gdbarch_register_sim_regno_ftype
*d10v_register_sim_regno
;
1444 /* Find a candidate among the list of pre-declared architectures. */
1445 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1447 return arches
->gdbarch
;
1449 /* None found, create a new architecture from the information
1451 tdep
= XMALLOC (struct gdbarch_tdep
);
1452 gdbarch
= gdbarch_alloc (&info
, tdep
);
1454 switch (info
.bfd_arch_info
->mach
)
1456 case bfd_mach_d10v_ts2
:
1458 d10v_register_name
= d10v_ts2_register_name
;
1459 d10v_register_sim_regno
= d10v_ts2_register_sim_regno
;
1460 tdep
->a0_regnum
= TS2_A0_REGNUM
;
1461 tdep
->nr_dmap_regs
= TS2_NR_DMAP_REGS
;
1462 tdep
->dmap_register
= d10v_ts2_dmap_register
;
1463 tdep
->imap_register
= d10v_ts2_imap_register
;
1466 case bfd_mach_d10v_ts3
:
1468 d10v_register_name
= d10v_ts3_register_name
;
1469 d10v_register_sim_regno
= d10v_ts3_register_sim_regno
;
1470 tdep
->a0_regnum
= TS3_A0_REGNUM
;
1471 tdep
->nr_dmap_regs
= TS3_NR_DMAP_REGS
;
1472 tdep
->dmap_register
= d10v_ts3_dmap_register
;
1473 tdep
->imap_register
= d10v_ts3_imap_register
;
1477 set_gdbarch_read_pc (gdbarch
, d10v_read_pc
);
1478 set_gdbarch_write_pc (gdbarch
, d10v_write_pc
);
1479 set_gdbarch_read_fp (gdbarch
, d10v_read_fp
);
1480 set_gdbarch_write_fp (gdbarch
, d10v_write_fp
);
1481 set_gdbarch_read_sp (gdbarch
, d10v_read_sp
);
1482 set_gdbarch_write_sp (gdbarch
, d10v_write_sp
);
1484 set_gdbarch_num_regs (gdbarch
, d10v_num_regs
);
1485 set_gdbarch_sp_regnum (gdbarch
, 15);
1486 set_gdbarch_fp_regnum (gdbarch
, 11);
1487 set_gdbarch_pc_regnum (gdbarch
, 18);
1488 set_gdbarch_register_name (gdbarch
, d10v_register_name
);
1489 set_gdbarch_register_size (gdbarch
, 2);
1490 set_gdbarch_register_bytes (gdbarch
, (d10v_num_regs
- 2) * 2 + 16);
1491 set_gdbarch_register_byte (gdbarch
, d10v_register_byte
);
1492 set_gdbarch_register_raw_size (gdbarch
, d10v_register_raw_size
);
1493 set_gdbarch_max_register_raw_size (gdbarch
, 8);
1494 set_gdbarch_register_virtual_size (gdbarch
, generic_register_virtual_size
);
1495 set_gdbarch_max_register_virtual_size (gdbarch
, 8);
1496 set_gdbarch_register_virtual_type (gdbarch
, d10v_register_virtual_type
);
1498 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1499 set_gdbarch_addr_bit (gdbarch
, 32);
1500 set_gdbarch_address_to_pointer (gdbarch
, d10v_address_to_pointer
);
1501 set_gdbarch_pointer_to_address (gdbarch
, d10v_pointer_to_address
);
1502 set_gdbarch_integer_to_address (gdbarch
, d10v_integer_to_address
);
1503 set_gdbarch_short_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1504 set_gdbarch_int_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1505 set_gdbarch_long_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1506 set_gdbarch_long_long_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
1507 /* NOTE: The d10v as a 32 bit ``float'' and ``double''. ``long
1508 double'' is 64 bits. */
1509 set_gdbarch_float_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1510 set_gdbarch_double_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1511 set_gdbarch_long_double_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
1512 switch (info
.byte_order
)
1514 case BFD_ENDIAN_BIG
:
1515 set_gdbarch_float_format (gdbarch
, &floatformat_ieee_single_big
);
1516 set_gdbarch_double_format (gdbarch
, &floatformat_ieee_single_big
);
1517 set_gdbarch_long_double_format (gdbarch
, &floatformat_ieee_double_big
);
1519 case BFD_ENDIAN_LITTLE
:
1520 set_gdbarch_float_format (gdbarch
, &floatformat_ieee_single_little
);
1521 set_gdbarch_double_format (gdbarch
, &floatformat_ieee_single_little
);
1522 set_gdbarch_long_double_format (gdbarch
, &floatformat_ieee_double_little
);
1525 internal_error (__FILE__
, __LINE__
,
1526 "d10v_gdbarch_init: bad byte order for float format");
1529 set_gdbarch_use_generic_dummy_frames (gdbarch
, 1);
1530 set_gdbarch_call_dummy_length (gdbarch
, 0);
1531 set_gdbarch_call_dummy_location (gdbarch
, AT_ENTRY_POINT
);
1532 set_gdbarch_call_dummy_address (gdbarch
, entry_point_address
);
1533 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch
, 1);
1534 set_gdbarch_call_dummy_breakpoint_offset (gdbarch
, 0);
1535 set_gdbarch_call_dummy_start_offset (gdbarch
, 0);
1536 set_gdbarch_pc_in_call_dummy (gdbarch
, generic_pc_in_call_dummy
);
1537 set_gdbarch_call_dummy_words (gdbarch
, d10v_call_dummy_words
);
1538 set_gdbarch_sizeof_call_dummy_words (gdbarch
, sizeof (d10v_call_dummy_words
));
1539 set_gdbarch_call_dummy_p (gdbarch
, 1);
1540 set_gdbarch_call_dummy_stack_adjust_p (gdbarch
, 0);
1541 set_gdbarch_get_saved_register (gdbarch
, generic_get_saved_register
);
1542 set_gdbarch_fix_call_dummy (gdbarch
, generic_fix_call_dummy
);
1544 set_gdbarch_extract_return_value (gdbarch
, d10v_extract_return_value
);
1545 set_gdbarch_push_arguments (gdbarch
, d10v_push_arguments
);
1546 set_gdbarch_push_dummy_frame (gdbarch
, generic_push_dummy_frame
);
1547 set_gdbarch_push_return_address (gdbarch
, d10v_push_return_address
);
1549 set_gdbarch_store_struct_return (gdbarch
, d10v_store_struct_return
);
1550 set_gdbarch_store_return_value (gdbarch
, d10v_store_return_value
);
1551 set_gdbarch_extract_struct_value_address (gdbarch
, d10v_extract_struct_value_address
);
1552 set_gdbarch_use_struct_convention (gdbarch
, d10v_use_struct_convention
);
1554 set_gdbarch_frame_init_saved_regs (gdbarch
, d10v_frame_init_saved_regs
);
1555 set_gdbarch_init_extra_frame_info (gdbarch
, d10v_init_extra_frame_info
);
1557 set_gdbarch_pop_frame (gdbarch
, d10v_pop_frame
);
1559 set_gdbarch_skip_prologue (gdbarch
, d10v_skip_prologue
);
1560 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1561 set_gdbarch_decr_pc_after_break (gdbarch
, 4);
1562 set_gdbarch_function_start_offset (gdbarch
, 0);
1563 set_gdbarch_breakpoint_from_pc (gdbarch
, d10v_breakpoint_from_pc
);
1565 set_gdbarch_remote_translate_xfer_address (gdbarch
, remote_d10v_translate_xfer_address
);
1567 set_gdbarch_frame_args_skip (gdbarch
, 0);
1568 set_gdbarch_frameless_function_invocation (gdbarch
, frameless_look_for_prologue
);
1569 set_gdbarch_frame_chain (gdbarch
, d10v_frame_chain
);
1570 set_gdbarch_frame_chain_valid (gdbarch
, d10v_frame_chain_valid
);
1571 set_gdbarch_frame_saved_pc (gdbarch
, d10v_frame_saved_pc
);
1572 set_gdbarch_frame_args_address (gdbarch
, default_frame_address
);
1573 set_gdbarch_frame_locals_address (gdbarch
, default_frame_address
);
1574 set_gdbarch_saved_pc_after_call (gdbarch
, d10v_saved_pc_after_call
);
1575 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
1576 set_gdbarch_stack_align (gdbarch
, d10v_stack_align
);
1578 set_gdbarch_register_sim_regno (gdbarch
, d10v_register_sim_regno
);
1579 set_gdbarch_extra_stack_alignment_needed (gdbarch
, 0);
1585 extern void (*target_resume_hook
) (void);
1586 extern void (*target_wait_loop_hook
) (void);
1589 _initialize_d10v_tdep (void)
1591 register_gdbarch_init (bfd_arch_d10v
, d10v_gdbarch_init
);
1593 tm_print_insn
= print_insn_d10v
;
1595 target_resume_hook
= d10v_eva_prepare_to_trace
;
1596 target_wait_loop_hook
= d10v_eva_get_trace_data
;
1598 add_com ("regs", class_vars
, show_regs
, "Print all registers");
1600 add_com ("itrace", class_support
, trace_command
,
1601 "Enable tracing of instruction execution.");
1603 add_com ("iuntrace", class_support
, untrace_command
,
1604 "Disable tracing of instruction execution.");
1606 add_com ("itdisassemble", class_vars
, tdisassemble_command
,
1607 "Disassemble the trace buffer.\n\
1608 Two optional arguments specify a range of trace buffer entries\n\
1609 as reported by info trace (NOT addresses!).");
1611 add_info ("itrace", trace_info
,
1612 "Display info about the trace data buffer.");
1614 add_show_from_set (add_set_cmd ("itracedisplay", no_class
,
1615 var_integer
, (char *) &trace_display
,
1616 "Set automatic display of trace.\n", &setlist
),
1618 add_show_from_set (add_set_cmd ("itracesource", no_class
,
1619 var_integer
, (char *) &default_trace_show_source
,
1620 "Set display of source code with trace.\n", &setlist
),