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 void d10v_frame_find_saved_regs
PARAMS ((struct frame_info
*fi
,
37 struct frame_saved_regs
*fsr
));
39 /* Discard from the stack the innermost frame, restoring all saved
43 d10v_pop_frame (frame
)
44 struct frame_info
*frame
;
48 struct frame_saved_regs fsr
;
51 fp
= FRAME_FP (frame
);
52 /* fill out fsr with the address of where each */
53 /* register was stored in the frame */
54 get_frame_saved_regs (frame
, &fsr
);
56 /* now update the current registers with the old values */
57 for (regnum
= A0_REGNUM
; regnum
< A0_REGNUM
+2 ; regnum
++)
61 read_memory (fsr
.regs
[regnum
], raw_buffer
, REGISTER_RAW_SIZE(regnum
));
62 write_register_bytes (REGISTER_BYTE (regnum
), raw_buffer
, REGISTER_RAW_SIZE(regnum
));
65 for (regnum
= 0; regnum
< SP_REGNUM
; regnum
++)
69 write_register (regnum
, read_memory_unsigned_integer (fsr
.regs
[regnum
], REGISTER_RAW_SIZE(regnum
)));
72 if (fsr
.regs
[PSW_REGNUM
])
74 write_register (PSW_REGNUM
, read_memory_unsigned_integer (fsr
.regs
[PSW_REGNUM
], REGISTER_RAW_SIZE(PSW_REGNUM
)));
77 write_register (PC_REGNUM
, read_register (LR_REGNUM
));
78 write_register (SP_REGNUM
, fp
+ frame
->size
);
79 target_store_registers (-1);
80 flush_cached_frames ();
88 if ((op
& 0x7E1F) == 0x6C1F)
92 if ((op
& 0x7E3F) == 0x6E1F)
96 if ((op
& 0x7FE1) == 0x01E1)
108 if ((op
& 0x7E1F) == 0x681E)
112 if ((op
& 0x7E3F) == 0x3A1E)
119 d10v_skip_prologue (pc
)
123 unsigned short op1
, op2
;
124 CORE_ADDR func_addr
, func_end
;
125 struct symtab_and_line sal
;
127 /* If we have line debugging information, then the end of the */
128 /* prologue should the first assembly instruction of the first source line */
129 if (find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
131 sal
= find_pc_line (func_addr
, 0);
132 if ( sal
.end
&& sal
.end
< func_end
)
136 if (target_read_memory (pc
, (char *)&op
, 4))
137 return pc
; /* Can't access it -- assume no prologue. */
141 op
= (unsigned long)read_memory_integer (pc
, 4);
142 if ((op
& 0xC0000000) == 0xC0000000)
144 /* long instruction */
145 if ( ((op
& 0x3FFF0000) != 0x01FF0000) && /* add3 sp,sp,n */
146 ((op
& 0x3F0F0000) != 0x340F0000) && /* st rn, @(offset,sp) */
147 ((op
& 0x3F1F0000) != 0x350F0000)) /* st2w rn, @(offset,sp) */
152 /* short instructions */
153 if ((op
& 0xC0000000) == 0x80000000)
155 op2
= (op
& 0x3FFF8000) >> 15;
160 op1
= (op
& 0x3FFF8000) >> 15;
163 if (check_prologue(op1
))
165 if (!check_prologue(op2
))
167 /* if the previous opcode was really part of the prologue */
168 /* and not just a NOP, then we want to break after both instructions */
182 /* Given a GDB frame, determine the address of the calling function's frame.
183 This will be used to create a new GDB frame struct, and then
184 INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
188 d10v_frame_chain (frame
)
189 struct frame_info
*frame
;
191 struct frame_saved_regs fsr
;
193 d10v_frame_find_saved_regs (frame
, &fsr
);
195 if (frame
->return_pc
== IMEM_START
|| inside_entry_file(frame
->return_pc
))
198 if (!fsr
.regs
[FP_REGNUM
])
200 if (!fsr
.regs
[SP_REGNUM
] || fsr
.regs
[SP_REGNUM
] == STACK_START
)
203 return fsr
.regs
[SP_REGNUM
];
206 if (!read_memory_unsigned_integer(fsr
.regs
[FP_REGNUM
], REGISTER_RAW_SIZE(FP_REGNUM
)))
209 return D10V_MAKE_DADDR (read_memory_unsigned_integer (fsr
.regs
[FP_REGNUM
], REGISTER_RAW_SIZE (FP_REGNUM
)));
212 static int next_addr
, uses_frame
;
215 prologue_find_regs (op
, fsr
, addr
)
217 struct frame_saved_regs
*fsr
;
223 if ((op
& 0x7E1F) == 0x6C1F)
225 n
= (op
& 0x1E0) >> 5;
227 fsr
->regs
[n
] = next_addr
;
232 else if ((op
& 0x7E3F) == 0x6E1F)
234 n
= (op
& 0x1E0) >> 5;
236 fsr
->regs
[n
] = next_addr
;
237 fsr
->regs
[n
+1] = next_addr
+2;
242 if ((op
& 0x7FE1) == 0x01E1)
244 n
= (op
& 0x1E) >> 1;
263 if ((op
& 0x7E1F) == 0x681E)
265 n
= (op
& 0x1E0) >> 5;
266 fsr
->regs
[n
] = next_addr
;
271 if ((op
& 0x7E3F) == 0x3A1E)
273 n
= (op
& 0x1E0) >> 5;
274 fsr
->regs
[n
] = next_addr
;
275 fsr
->regs
[n
+1] = next_addr
+2;
282 /* Put here the code to store, into a struct frame_saved_regs, the
283 addresses of the saved registers of frame described by FRAME_INFO.
284 This includes special registers such as pc and fp saved in special
285 ways in the stack frame. sp is even more special: the address we
286 return for it IS the sp for the next frame. */
288 d10v_frame_find_saved_regs (fi
, fsr
)
289 struct frame_info
*fi
;
290 struct frame_saved_regs
*fsr
;
294 unsigned short op1
, op2
;
298 memset (fsr
, 0, sizeof (*fsr
));
301 pc
= get_pc_function_start (fi
->pc
);
306 op
= (unsigned long)read_memory_integer (pc
, 4);
307 if ((op
& 0xC0000000) == 0xC0000000)
309 /* long instruction */
310 if ((op
& 0x3FFF0000) == 0x01FF0000)
313 short n
= op
& 0xFFFF;
316 else if ((op
& 0x3F0F0000) == 0x340F0000)
318 /* st rn, @(offset,sp) */
319 short offset
= op
& 0xFFFF;
320 short n
= (op
>> 20) & 0xF;
321 fsr
->regs
[n
] = next_addr
+ offset
;
323 else if ((op
& 0x3F1F0000) == 0x350F0000)
325 /* st2w rn, @(offset,sp) */
326 short offset
= op
& 0xFFFF;
327 short n
= (op
>> 20) & 0xF;
328 fsr
->regs
[n
] = next_addr
+ offset
;
329 fsr
->regs
[n
+1] = next_addr
+ offset
+ 2;
336 /* short instructions */
337 if ((op
& 0xC0000000) == 0x80000000)
339 op2
= (op
& 0x3FFF8000) >> 15;
344 op1
= (op
& 0x3FFF8000) >> 15;
347 if (!prologue_find_regs(op1
,fsr
,pc
) || !prologue_find_regs(op2
,fsr
,pc
))
353 fi
->size
= -next_addr
;
356 fp
= D10V_MAKE_DADDR (read_register(SP_REGNUM
));
358 for (i
=0; i
<NUM_REGS
-1; i
++)
361 fsr
->regs
[i
] = fp
- (next_addr
- fsr
->regs
[i
]);
364 if (fsr
->regs
[LR_REGNUM
])
366 CORE_ADDR return_pc
= read_memory_unsigned_integer (fsr
->regs
[LR_REGNUM
], REGISTER_RAW_SIZE (LR_REGNUM
));
367 fi
->return_pc
= D10V_MAKE_IADDR (return_pc
);
371 fi
->return_pc
= D10V_MAKE_IADDR (read_register(LR_REGNUM
));
374 /* th SP is not normally (ever?) saved, but check anyway */
375 if (!fsr
->regs
[SP_REGNUM
])
377 /* if the FP was saved, that means the current FP is valid, */
378 /* otherwise, it isn't being used, so we use the SP instead */
380 fsr
->regs
[SP_REGNUM
] = read_register(FP_REGNUM
) + fi
->size
;
383 fsr
->regs
[SP_REGNUM
] = fp
+ fi
->size
;
385 fsr
->regs
[FP_REGNUM
] = 0;
391 d10v_init_extra_frame_info (fromleaf
, fi
)
393 struct frame_info
*fi
;
399 /* The call dummy doesn't save any registers on the stack, so we can
401 if (PC_IN_CALL_DUMMY (fi
->pc
, fi
->frame
, fi
->frame
))
407 struct frame_saved_regs dummy
;
408 d10v_frame_find_saved_regs (fi
, &dummy
);
413 show_regs (args
, from_tty
)
418 printf_filtered ("PC=%04x (0x%x) PSW=%04x RPT_S=%04x RPT_E=%04x RPT_C=%04x\n",
419 read_register (PC_REGNUM
), D10V_MAKE_IADDR (read_register (PC_REGNUM
)),
420 read_register (PSW_REGNUM
),
424 printf_filtered ("R0-R7 %04x %04x %04x %04x %04x %04x %04x %04x\n",
433 printf_filtered ("R8-R15 %04x %04x %04x %04x %04x %04x %04x %04x\n",
442 printf_filtered ("IMAP0 %04x IMAP1 %04x DMAP %04x\n",
443 read_register (IMAP0_REGNUM
),
444 read_register (IMAP1_REGNUM
),
445 read_register (DMAP_REGNUM
));
446 printf_filtered ("A0-A1");
447 for (a
= A0_REGNUM
; a
<= A0_REGNUM
+ 1; a
++)
449 char num
[MAX_REGISTER_RAW_SIZE
];
451 printf_filtered (" ");
452 read_register_gen (a
, (char *)&num
);
453 for (i
= 0; i
< MAX_REGISTER_RAW_SIZE
; i
++)
455 printf_filtered ("%02x", (num
[i
] & 0xff));
458 printf_filtered ("\n");
469 save_pid
= inferior_pid
;
471 pc
= (int) read_register (PC_REGNUM
);
472 inferior_pid
= save_pid
;
473 retval
= D10V_MAKE_IADDR (pc
);
478 d10v_write_pc (val
, pid
)
484 save_pid
= inferior_pid
;
486 write_register (PC_REGNUM
, D10V_CONVERT_IADDR_TO_RAW (val
));
487 inferior_pid
= save_pid
;
493 return (D10V_MAKE_DADDR (read_register (SP_REGNUM
)));
500 write_register (SP_REGNUM
, D10V_CONVERT_DADDR_TO_RAW (val
));
507 write_register (FP_REGNUM
, D10V_CONVERT_DADDR_TO_RAW (val
));
513 return (D10V_MAKE_DADDR (read_register(FP_REGNUM
)));
516 /* Function: push_return_address (pc)
517 Set up the return address for the inferior function call.
518 Needed for targets where we don't actually execute a JSR/BSR instruction */
521 d10v_push_return_address (pc
, sp
)
525 write_register (LR_REGNUM
, D10V_CONVERT_IADDR_TO_RAW (CALL_DUMMY_ADDRESS ()));
531 d10v_push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
)
536 CORE_ADDR struct_addr
;
539 int regnum
= ARG1_REGNUM
;
541 /* Fill in registers and arg lists */
542 for (i
= 0; i
< nargs
; i
++)
544 value_ptr arg
= args
[i
];
545 struct type
*type
= check_typedef (VALUE_TYPE (arg
));
546 char *contents
= VALUE_CONTENTS (arg
);
547 int len
= TYPE_LENGTH (type
);
548 /* printf ("push: type=%d len=%d\n", type->code, len); */
549 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
551 /* pointers require special handling - first convert and
553 long val
= extract_signed_integer (contents
, len
);
555 if (TYPE_TARGET_TYPE (type
)
556 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
))
558 /* function pointer */
559 val
= D10V_CONVERT_IADDR_TO_RAW (val
);
561 else if (D10V_IADDR_P (val
))
563 /* also function pointer! */
564 val
= D10V_CONVERT_DADDR_TO_RAW (val
);
571 if (regnum
<= ARGN_REGNUM
)
572 write_register (regnum
++, val
& 0xffff);
577 store_address (ptr
, val
& 0xffff, 2);
578 write_memory (sp
, ptr
, 2);
583 int aligned_regnum
= (regnum
+ 1) & ~1;
584 if (len
<= 2 && regnum
<= ARGN_REGNUM
)
585 /* fits in a single register, do not align */
587 long val
= extract_unsigned_integer (contents
, len
);
588 write_register (regnum
++, val
);
590 else if (len
<= (ARGN_REGNUM
- aligned_regnum
+ 1) * 2)
591 /* value fits in remaining registers, store keeping left
595 regnum
= aligned_regnum
;
596 for (b
= 0; b
< (len
& ~1); b
+= 2)
598 long val
= extract_unsigned_integer (&contents
[b
], 2);
599 write_register (regnum
++, val
);
603 long val
= extract_unsigned_integer (&contents
[b
], 1);
604 write_register (regnum
++, (val
<< 8));
609 /* arg goes straight on stack */
610 regnum
= ARGN_REGNUM
+ 1;
611 sp
= (sp
- len
) & ~1;
612 write_memory (sp
, contents
, len
);
620 /* Given a return value in `regbuf' with a type `valtype',
621 extract and copy its value into `valbuf'. */
624 d10v_extract_return_value (type
, regbuf
, valbuf
)
626 char regbuf
[REGISTER_BYTES
];
630 /* 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))); */
631 if (TYPE_CODE (type
) == TYPE_CODE_PTR
632 && TYPE_TARGET_TYPE (type
)
633 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
))
635 /* pointer to function */
638 snum
= extract_address (regbuf
+ REGISTER_BYTE (RET1_REGNUM
), REGISTER_RAW_SIZE (RET1_REGNUM
));
639 store_address ( valbuf
, 4, D10V_MAKE_IADDR(snum
));
641 else if (TYPE_CODE(type
) == TYPE_CODE_PTR
)
643 /* pointer to data */
646 snum
= extract_address (regbuf
+ REGISTER_BYTE (RET1_REGNUM
), REGISTER_RAW_SIZE (RET1_REGNUM
));
647 store_address ( valbuf
, 4, D10V_MAKE_DADDR(snum
));
651 len
= TYPE_LENGTH (type
);
654 unsigned short c
= extract_unsigned_integer (regbuf
+ REGISTER_BYTE (RET1_REGNUM
), REGISTER_RAW_SIZE (RET1_REGNUM
));
655 store_unsigned_integer (valbuf
, 1, c
);
658 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (RET1_REGNUM
), len
);
662 /* The following code implements access to, and display of, the D10V's
663 instruction trace buffer. The buffer consists of 64K or more
664 4-byte words of data, of which each words includes an 8-bit count,
665 an 8-bit segment number, and a 16-bit instruction address.
667 In theory, the trace buffer is continuously capturing instruction
668 data that the CPU presents on its "debug bus", but in practice, the
669 ROMified GDB stub only enables tracing when it continues or steps
670 the program, and stops tracing when the program stops; so it
671 actually works for GDB to read the buffer counter out of memory and
672 then read each trace word. The counter records where the tracing
673 stops, but there is no record of where it started, so we remember
674 the PC when we resumed and then search backwards in the trace
675 buffer for a word that includes that address. This is not perfect,
676 because you will miss trace data if the resumption PC is the target
677 of a branch. (The value of the buffer counter is semi-random, any
678 trace data from a previous program stop is gone.) */
680 /* The address of the last word recorded in the trace buffer. */
682 #define DBBC_ADDR (0xd80000)
684 /* The base of the trace buffer, at least for the "Board_0". */
686 #define TRACE_BUFFER_BASE (0xf40000)
688 static void trace_command
PARAMS ((char *, int));
690 static void untrace_command
PARAMS ((char *, int));
692 static void trace_info
PARAMS ((char *, int));
694 static void tdisassemble_command
PARAMS ((char *, int));
696 static void display_trace
PARAMS ((int, int));
698 /* True when instruction traces are being collected. */
704 static CORE_ADDR last_pc
;
706 /* True when trace output should be displayed whenever program stops. */
708 static int trace_display
;
710 /* True when trace listing should include source lines. */
712 static int default_trace_show_source
= 1;
714 struct trace_buffer
{
721 trace_command (args
, from_tty
)
725 /* Clear the host-side trace buffer, allocating space if needed. */
727 if (trace_data
.counts
== NULL
)
728 trace_data
.counts
= (short *) xmalloc (65536 * sizeof(short));
729 if (trace_data
.addrs
== NULL
)
730 trace_data
.addrs
= (CORE_ADDR
*) xmalloc (65536 * sizeof(CORE_ADDR
));
734 printf_filtered ("Tracing is now on.\n");
738 untrace_command (args
, from_tty
)
744 printf_filtered ("Tracing is now off.\n");
748 trace_info (args
, from_tty
)
756 printf_filtered ("%d entries in trace buffer:\n", trace_data
.size
);
758 for (i
= 0; i
< trace_data
.size
; ++i
)
760 printf_filtered ("%d: %d instruction%s at 0x%x\n",
761 i
, trace_data
.counts
[i
],
762 (trace_data
.counts
[i
] == 1 ? "" : "s"),
763 trace_data
.addrs
[i
]);
767 printf_filtered ("No entries in trace buffer.\n");
769 printf_filtered ("Tracing is currently %s.\n", (tracing
? "on" : "off"));
772 /* Print the instruction at address MEMADDR in debugged memory,
773 on STREAM. Returns length of the instruction, in bytes. */
776 print_insn (memaddr
, stream
)
780 /* If there's no disassembler, something is very wrong. */
781 if (tm_print_insn
== NULL
)
784 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
785 tm_print_insn_info
.endian
= BFD_ENDIAN_BIG
;
787 tm_print_insn_info
.endian
= BFD_ENDIAN_LITTLE
;
788 return (*tm_print_insn
) (memaddr
, &tm_print_insn_info
);
792 d10v_eva_prepare_to_trace ()
797 last_pc
= read_register (PC_REGNUM
);
800 /* Collect trace data from the target board and format it into a form
801 more useful for display. */
804 d10v_eva_get_trace_data ()
806 int count
, i
, j
, oldsize
;
807 int trace_addr
, trace_seg
, trace_cnt
, next_cnt
;
808 unsigned int last_trace
, trace_word
, next_word
;
809 unsigned int *tmpspace
;
814 tmpspace
= xmalloc (65536 * sizeof(unsigned int));
816 last_trace
= read_memory_unsigned_integer (DBBC_ADDR
, 2) << 2;
818 /* Collect buffer contents from the target, stopping when we reach
819 the word recorded when execution resumed. */
822 while (last_trace
> 0)
826 read_memory_unsigned_integer (TRACE_BUFFER_BASE
+ last_trace
, 4);
827 trace_addr
= trace_word
& 0xffff;
829 /* Ignore an apparently nonsensical entry. */
830 if (trace_addr
== 0xffd5)
832 tmpspace
[count
++] = trace_word
;
833 if (trace_addr
== last_pc
)
839 /* Move the data to the host-side trace buffer, adjusting counts to
840 include the last instruction executed and transforming the address
841 into something that GDB likes. */
843 for (i
= 0; i
< count
; ++i
)
845 trace_word
= tmpspace
[i
];
846 next_word
= ((i
== 0) ? 0 : tmpspace
[i
- 1]);
847 trace_addr
= trace_word
& 0xffff;
848 next_cnt
= (next_word
>> 24) & 0xff;
849 j
= trace_data
.size
+ count
- i
- 1;
850 trace_data
.addrs
[j
] = (trace_addr
<< 2) + 0x1000000;
851 trace_data
.counts
[j
] = next_cnt
+ 1;
854 oldsize
= trace_data
.size
;
855 trace_data
.size
+= count
;
860 display_trace (oldsize
, trace_data
.size
);
864 tdisassemble_command (arg
, from_tty
)
875 high
= trace_data
.size
;
877 else if (!(space_index
= (char *) strchr (arg
, ' ')))
879 low
= parse_and_eval_address (arg
);
886 low
= parse_and_eval_address (arg
);
887 high
= parse_and_eval_address (space_index
+ 1);
892 printf_filtered ("Dump of trace from %d to %d:\n", low
, high
);
894 display_trace (low
, high
);
896 printf_filtered ("End of trace dump.\n");
897 gdb_flush (gdb_stdout
);
901 display_trace (low
, high
)
904 int i
, count
, trace_show_source
, first
, suppress
;
905 CORE_ADDR next_address
;
907 trace_show_source
= default_trace_show_source
;
908 if (!have_full_symbols () && !have_partial_symbols())
910 trace_show_source
= 0;
911 printf_filtered ("No symbol table is loaded. Use the \"file\" command.\n");
912 printf_filtered ("Trace will not display any source.\n");
917 for (i
= low
; i
< high
; ++i
)
919 next_address
= trace_data
.addrs
[i
];
920 count
= trace_data
.counts
[i
];
924 if (trace_show_source
)
926 struct symtab_and_line sal
, sal_prev
;
928 sal_prev
= find_pc_line (next_address
- 4, 0);
929 sal
= find_pc_line (next_address
, 0);
933 if (first
|| sal
.line
!= sal_prev
.line
)
934 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
940 /* FIXME-32x64--assumes sal.pc fits in long. */
941 printf_filtered ("No source file for address %s.\n",
942 local_hex_string((unsigned long) sal
.pc
));
947 print_address (next_address
, gdb_stdout
);
948 printf_filtered (":");
949 printf_filtered ("\t");
951 next_address
= next_address
+ print_insn (next_address
, gdb_stdout
);
952 printf_filtered ("\n");
953 gdb_flush (gdb_stdout
);
958 extern void (*target_resume_hook
) PARAMS ((void));
959 extern void (*target_wait_loop_hook
) PARAMS ((void));
962 _initialize_d10v_tdep ()
964 tm_print_insn
= print_insn_d10v
;
966 target_resume_hook
= d10v_eva_prepare_to_trace
;
967 target_wait_loop_hook
= d10v_eva_get_trace_data
;
969 add_com ("regs", class_vars
, show_regs
, "Print all registers");
971 add_com ("trace", class_support
, trace_command
,
972 "Enable tracing of instruction execution.");
974 add_com ("untrace", class_support
, untrace_command
,
975 "Disable tracing of instruction execution.");
977 add_com ("tdisassemble", class_vars
, tdisassemble_command
,
978 "Disassemble the trace buffer.\n\
979 Two optional arguments specify a range of trace buffer entries\n\
980 as reported by info trace (NOT addresses!).");
982 add_info ("trace", trace_info
,
983 "Display info about the trace data buffer.");
985 add_show_from_set (add_set_cmd ("tracedisplay", no_class
,
986 var_integer
, (char *)&trace_display
,
987 "Set automatic display of trace.\n", &setlist
),
989 add_show_from_set (add_set_cmd ("tracesource", no_class
,
990 var_integer
, (char *)&default_trace_show_source
,
991 "Set display of source code with trace.\n", &setlist
),