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 read_memory_unsigned_integer(fsr
.regs
[FP_REGNUM
], REGISTER_RAW_SIZE(FP_REGNUM
))| DMEM_START
;
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
= read_register(SP_REGNUM
) | DMEM_START
;
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
])
365 fi
->return_pc
= (read_memory_unsigned_integer(fsr
->regs
[LR_REGNUM
], REGISTER_RAW_SIZE(LR_REGNUM
)) << 2) | IMEM_START
;
367 fi
->return_pc
= (read_register(LR_REGNUM
) << 2) | IMEM_START
;
369 /* th SP is not normally (ever?) saved, but check anyway */
370 if (!fsr
->regs
[SP_REGNUM
])
372 /* if the FP was saved, that means the current FP is valid, */
373 /* otherwise, it isn't being used, so we use the SP instead */
375 fsr
->regs
[SP_REGNUM
] = read_register(FP_REGNUM
) + fi
->size
;
378 fsr
->regs
[SP_REGNUM
] = fp
+ fi
->size
;
380 fsr
->regs
[FP_REGNUM
] = 0;
386 d10v_init_extra_frame_info (fromleaf
, fi
)
388 struct frame_info
*fi
;
394 /* The call dummy doesn't save any registers on the stack, so we can
396 if (PC_IN_CALL_DUMMY (fi
->pc
, fi
->frame
, fi
->frame
))
402 struct frame_saved_regs dummy
;
403 d10v_frame_find_saved_regs (fi
, &dummy
);
408 show_regs (args
, from_tty
)
413 printf_filtered ("PC=%04x (0x%x) PSW=%04x RPT_S=%04x RPT_E=%04x RPT_C=%04x\n",
414 read_register (PC_REGNUM
), (read_register (PC_REGNUM
) << 2) + IMEM_START
,
415 read_register (PSW_REGNUM
),
419 printf_filtered ("R0-R7 %04x %04x %04x %04x %04x %04x %04x %04x\n",
428 printf_filtered ("R8-R15 %04x %04x %04x %04x %04x %04x %04x %04x\n",
437 printf_filtered ("IMAP0 %04x IMAP1 %04x DMAP %04x\n",
438 read_register (IMAP0_REGNUM
),
439 read_register (IMAP1_REGNUM
),
440 read_register (DMAP_REGNUM
));
441 read_register_gen (A0_REGNUM
, (char *)&num1
);
442 read_register_gen (A0_REGNUM
+1, (char *)&num2
);
443 printf_filtered ("A0-A1 %010llx %010llx\n",num1
, num2
);
447 d10v_xlate_addr (addr
)
453 imap
= (int)read_register(IMAP0_REGNUM
);
455 imap
= (int)read_register(IMAP1_REGNUM
);
458 return (CORE_ADDR
)(addr
+ 0x1000000);
459 return (CORE_ADDR
)(addr
+ (imap
& 0xff)*0x20000);
470 save_pid
= inferior_pid
;
472 retval
= (int)read_register (PC_REGNUM
);
473 inferior_pid
= save_pid
;
474 retval
= d10v_xlate_addr(retval
<< 2);
479 d10v_write_pc (val
, pid
)
485 save_pid
= inferior_pid
;
487 write_register (PC_REGNUM
, (val
& 0x3ffff) >> 2);
488 inferior_pid
= save_pid
;
494 return (read_register(SP_REGNUM
) | DMEM_START
);
501 write_register (SP_REGNUM
, (LONGEST
)(val
& 0xffff));
508 write_register (FP_REGNUM
, (LONGEST
)(val
& 0xffff));
514 return (read_register(FP_REGNUM
) | DMEM_START
);
517 /* Function: push_return_address (pc)
518 Set up the return address for the inferior function call.
519 Needed for targets where we don't actually execute a JSR/BSR instruction */
522 d10v_push_return_address (pc
, sp
)
526 write_register (LR_REGNUM
, (CALL_DUMMY_ADDRESS () & 0xffff) >> 2);
532 d10v_push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
)
537 CORE_ADDR struct_addr
;
540 int regnum
= ARG1_REGNUM
;
542 /* Fill in registers and arg lists */
543 for (i
= 0; i
< nargs
; i
++)
545 value_ptr arg
= args
[i
];
546 struct type
*type
= check_typedef (VALUE_TYPE (arg
));
547 char *contents
= VALUE_CONTENTS (arg
);
548 int len
= TYPE_LENGTH (type
);
549 /* printf ("push: type=%d len=%d\n", type->code, len); */
550 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
552 /* pointers require special handling - first convert and
554 long val
= extract_signed_integer (contents
, len
);
556 if (TYPE_TARGET_TYPE (type
)
557 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
))
559 /* function pointer */
560 val
= D10V_CONVERT_IADDR_TO_RAW (val
);
562 else if (D10V_IADDR_P (val
))
564 /* also function pointer! */
565 val
= D10V_CONVERT_DADDR_TO_RAW (val
);
572 if (regnum
<= ARGN_REGNUM
)
573 write_register (regnum
++, val
& 0xffff);
578 store_address (ptr
, val
& 0xffff, 2);
579 write_memory (sp
, ptr
, 2);
584 int aligned_regnum
= (regnum
+ 1) & ~1;
585 if (len
<= 2 && regnum
<= ARGN_REGNUM
)
586 /* fits in a single register, do not align */
588 long val
= extract_unsigned_integer (contents
, len
);
589 write_register (regnum
++, val
);
591 else if (len
<= (ARGN_REGNUM
- aligned_regnum
+ 1) * 2)
592 /* value fits in remaining registers, store keeping left
596 regnum
= aligned_regnum
;
597 for (b
= 0; b
< (len
& ~1); b
+= 2)
599 long val
= extract_unsigned_integer (&contents
[b
], 2);
600 write_register (regnum
++, val
);
604 long val
= extract_unsigned_integer (&contents
[b
], 1);
605 write_register (regnum
++, (val
<< 8));
610 /* arg goes straight on stack */
611 regnum
= ARGN_REGNUM
+ 1;
612 sp
= (sp
- len
) & ~1;
613 write_memory (sp
, contents
, len
);
621 /* Given a return value in `regbuf' with a type `valtype',
622 extract and copy its value into `valbuf'. */
625 d10v_extract_return_value (type
, regbuf
, valbuf
)
627 char regbuf
[REGISTER_BYTES
];
631 /* 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))); */
632 if (TYPE_CODE (type
) == TYPE_CODE_PTR
633 && TYPE_TARGET_TYPE (type
)
634 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
))
636 /* pointer to function */
639 snum
= extract_address (regbuf
+ REGISTER_BYTE (RET1_REGNUM
), REGISTER_RAW_SIZE (RET1_REGNUM
));
640 store_address ( valbuf
, 4, D10V_MAKE_IADDR(snum
));
642 else if (TYPE_CODE(type
) == TYPE_CODE_PTR
)
644 /* pointer to data */
647 snum
= extract_address (regbuf
+ REGISTER_BYTE (RET1_REGNUM
), REGISTER_RAW_SIZE (RET1_REGNUM
));
648 store_address ( valbuf
, 4, D10V_MAKE_DADDR(snum
));
652 len
= TYPE_LENGTH (type
);
655 unsigned short c
= extract_unsigned_integer (regbuf
+ REGISTER_BYTE (RET1_REGNUM
), REGISTER_RAW_SIZE (RET1_REGNUM
));
656 store_unsigned_integer (valbuf
, 1, c
);
659 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (RET1_REGNUM
), len
);
663 /* The following code implements access to, and display of, the D10V's
664 instruction trace buffer. The buffer consists of 64K or more
665 4-byte words of data, of which each words includes an 8-bit count,
666 an 8-bit segment number, and a 16-bit instruction address.
668 In theory, the trace buffer is continuously capturing instruction
669 data that the CPU presents on its "debug bus", but in practice, the
670 ROMified GDB stub only enables tracing when it continues or steps
671 the program, and stops tracing when the program stops; so it
672 actually works for GDB to read the buffer counter out of memory and
673 then read each trace word. The counter records where the tracing
674 stops, but there is no record of where it started, so we remember
675 the PC when we resumed and then search backwards in the trace
676 buffer for a word that includes that address. This is not perfect,
677 because you will miss trace data if the resumption PC is the target
678 of a branch. (The value of the buffer counter is semi-random, any
679 trace data from a previous program stop is gone.) */
681 /* The address of the last word recorded in the trace buffer. */
683 #define DBBC_ADDR (0xd80000)
685 /* The base of the trace buffer, at least for the "Board_0". */
687 #define TRACE_BUFFER_BASE (0xf40000)
689 static void trace_command
PARAMS ((char *, int));
691 static void untrace_command
PARAMS ((char *, int));
693 static void trace_info
PARAMS ((char *, int));
695 static void tdisassemble_command
PARAMS ((char *, int));
697 static void display_trace
PARAMS ((int, int));
699 /* True when instruction traces are being collected. */
705 static CORE_ADDR last_pc
;
707 /* True when trace output should be displayed whenever program stops. */
709 static int trace_display
;
711 /* True when trace listing should include source lines. */
713 static int default_trace_show_source
= 1;
715 struct trace_buffer
{
722 trace_command (args
, from_tty
)
726 /* Clear the host-side trace buffer, allocating space if needed. */
728 if (trace_data
.counts
== NULL
)
729 trace_data
.counts
= (short *) xmalloc (65536 * sizeof(short));
730 if (trace_data
.addrs
== NULL
)
731 trace_data
.addrs
= (CORE_ADDR
*) xmalloc (65536 * sizeof(CORE_ADDR
));
735 printf_filtered ("Tracing is now on.\n");
739 untrace_command (args
, from_tty
)
745 printf_filtered ("Tracing is now off.\n");
749 trace_info (args
, from_tty
)
757 printf_filtered ("%d entries in trace buffer:\n", trace_data
.size
);
759 for (i
= 0; i
< trace_data
.size
; ++i
)
761 printf_filtered ("%d: %d instruction%s at 0x%x\n",
762 i
, trace_data
.counts
[i
],
763 (trace_data
.counts
[i
] == 1 ? "" : "s"),
764 trace_data
.addrs
[i
]);
768 printf_filtered ("No entries in trace buffer.\n");
770 printf_filtered ("Tracing is currently %s.\n", (tracing
? "on" : "off"));
773 /* Print the instruction at address MEMADDR in debugged memory,
774 on STREAM. Returns length of the instruction, in bytes. */
777 print_insn (memaddr
, stream
)
781 /* If there's no disassembler, something is very wrong. */
782 if (tm_print_insn
== NULL
)
785 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
786 tm_print_insn_info
.endian
= BFD_ENDIAN_BIG
;
788 tm_print_insn_info
.endian
= BFD_ENDIAN_LITTLE
;
789 return (*tm_print_insn
) (memaddr
, &tm_print_insn_info
);
793 d10v_eva_prepare_to_trace ()
798 last_pc
= read_register (PC_REGNUM
);
801 /* Collect trace data from the target board and format it into a form
802 more useful for display. */
805 d10v_eva_get_trace_data ()
807 int count
, i
, j
, oldsize
;
808 int trace_addr
, trace_seg
, trace_cnt
, next_cnt
;
809 unsigned int last_trace
, trace_word
, next_word
;
810 unsigned int *tmpspace
;
815 tmpspace
= xmalloc (65536 * sizeof(unsigned int));
817 last_trace
= read_memory_unsigned_integer (DBBC_ADDR
, 2) << 2;
819 /* Collect buffer contents from the target, stopping when we reach
820 the word recorded when execution resumed. */
823 while (last_trace
> 0)
827 read_memory_unsigned_integer (TRACE_BUFFER_BASE
+ last_trace
, 4);
828 trace_addr
= trace_word
& 0xffff;
830 /* Ignore an apparently nonsensical entry. */
831 if (trace_addr
== 0xffd5)
833 tmpspace
[count
++] = trace_word
;
834 if (trace_addr
== last_pc
)
840 /* Move the data to the host-side trace buffer, adjusting counts to
841 include the last instruction executed and transforming the address
842 into something that GDB likes. */
844 for (i
= 0; i
< count
; ++i
)
846 trace_word
= tmpspace
[i
];
847 next_word
= ((i
== 0) ? 0 : tmpspace
[i
- 1]);
848 trace_addr
= trace_word
& 0xffff;
849 next_cnt
= (next_word
>> 24) & 0xff;
850 j
= trace_data
.size
+ count
- i
- 1;
851 trace_data
.addrs
[j
] = (trace_addr
<< 2) + 0x1000000;
852 trace_data
.counts
[j
] = next_cnt
+ 1;
855 oldsize
= trace_data
.size
;
856 trace_data
.size
+= count
;
861 display_trace (oldsize
, trace_data
.size
);
865 tdisassemble_command (arg
, from_tty
)
876 high
= trace_data
.size
;
878 else if (!(space_index
= (char *) strchr (arg
, ' ')))
880 low
= parse_and_eval_address (arg
);
887 low
= parse_and_eval_address (arg
);
888 high
= parse_and_eval_address (space_index
+ 1);
893 printf_filtered ("Dump of trace from %d to %d:\n", low
, high
);
895 display_trace (low
, high
);
897 printf_filtered ("End of trace dump.\n");
898 gdb_flush (gdb_stdout
);
902 display_trace (low
, high
)
905 int i
, count
, trace_show_source
, first
, suppress
;
906 CORE_ADDR next_address
;
908 trace_show_source
= default_trace_show_source
;
909 if (!have_full_symbols () && !have_partial_symbols())
911 trace_show_source
= 0;
912 printf_filtered ("No symbol table is loaded. Use the \"file\" command.\n");
913 printf_filtered ("Trace will not display any source.\n");
918 for (i
= low
; i
< high
; ++i
)
920 next_address
= trace_data
.addrs
[i
];
921 count
= trace_data
.counts
[i
];
925 if (trace_show_source
)
927 struct symtab_and_line sal
, sal_prev
;
929 sal_prev
= find_pc_line (next_address
- 4, 0);
930 sal
= find_pc_line (next_address
, 0);
934 if (first
|| sal
.line
!= sal_prev
.line
)
935 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
941 /* FIXME-32x64--assumes sal.pc fits in long. */
942 printf_filtered ("No source file for address %s.\n",
943 local_hex_string((unsigned long) sal
.pc
));
948 print_address (next_address
, gdb_stdout
);
949 printf_filtered (":");
950 printf_filtered ("\t");
952 next_address
= next_address
+ print_insn (next_address
, gdb_stdout
);
953 printf_filtered ("\n");
954 gdb_flush (gdb_stdout
);
959 extern void (*target_resume_hook
) PARAMS ((void));
960 extern void (*target_wait_loop_hook
) PARAMS ((void));
963 _initialize_d10v_tdep ()
965 tm_print_insn
= print_insn_d10v
;
967 target_resume_hook
= d10v_eva_prepare_to_trace
;
968 target_wait_loop_hook
= d10v_eva_get_trace_data
;
970 add_com ("regs", class_vars
, show_regs
, "Print all registers");
972 add_com ("trace", class_support
, trace_command
,
973 "Enable tracing of instruction execution.");
975 add_com ("untrace", class_support
, untrace_command
,
976 "Disable tracing of instruction execution.");
978 add_com ("tdisassemble", class_vars
, tdisassemble_command
,
979 "Disassemble the trace buffer.\n\
980 Two optional arguments specify a range of trace buffer entries\n\
981 as reported by info trace (NOT addresses!).");
983 add_info ("trace", trace_info
,
984 "Display info about the trace data buffer.");
986 add_show_from_set (add_set_cmd ("tracedisplay", no_class
,
987 var_integer
, (char *)&trace_display
,
988 "Set automatic display of trace.\n", &setlist
),
990 add_show_from_set (add_set_cmd ("tracesource", no_class
,
991 var_integer
, (char *)&default_trace_show_source
,
992 "Set display of source code with trace.\n", &setlist
),