1 /* Simulator tracing/debugging support.
2 Copyright (C) 1997, 1998, 2001, 2007, 2008, 2009, 2010, 2011
3 Free Software Foundation, Inc.
4 Contributed by Cygnus Support.
6 This file is part of GDB, the GNU debugger.
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 3 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, see <http://www.gnu.org/licenses/>. */
23 #include "sim-options.h"
27 #include "libiberty.h"
29 #include "sim-assert.h"
47 #define SIZE_LOCATION 20
54 #ifndef SIZE_LINE_NUMBER
55 #define SIZE_LINE_NUMBER 4
58 static MODULE_INIT_FN trace_init
;
59 static MODULE_UNINSTALL_FN trace_uninstall
;
61 static DECLARE_OPTION_HANDLER (trace_option_handler
);
64 OPTION_TRACE_INSN
= OPTION_START
,
75 OPTION_TRACE_SEMANTICS
,
77 OPTION_TRACE_FUNCTION
,
84 static const OPTION trace_options
[] =
86 /* This table is organized to group related instructions together. */
87 { {"trace", optional_argument
, NULL
, 't'},
88 't', "on|off", "Trace useful things",
89 trace_option_handler
, NULL
},
90 { {"trace-insn", optional_argument
, NULL
, OPTION_TRACE_INSN
},
91 '\0', "on|off", "Perform instruction tracing",
92 trace_option_handler
, NULL
},
93 { {"trace-decode", optional_argument
, NULL
, OPTION_TRACE_DECODE
},
94 '\0', "on|off", "Trace instruction decoding",
95 trace_option_handler
, NULL
},
96 { {"trace-extract", optional_argument
, NULL
, OPTION_TRACE_EXTRACT
},
97 '\0', "on|off", "Trace instruction extraction",
98 trace_option_handler
, NULL
},
99 { {"trace-linenum", optional_argument
, NULL
, OPTION_TRACE_LINENUM
},
100 '\0', "on|off", "Perform line number tracing (implies --trace-insn)",
101 trace_option_handler
, NULL
},
102 { {"trace-memory", optional_argument
, NULL
, OPTION_TRACE_MEMORY
},
103 '\0', "on|off", "Trace memory operations",
104 trace_option_handler
, NULL
},
105 { {"trace-alu", optional_argument
, NULL
, OPTION_TRACE_ALU
},
106 '\0', "on|off", "Trace ALU operations",
107 trace_option_handler
, NULL
},
108 { {"trace-fpu", optional_argument
, NULL
, OPTION_TRACE_FPU
},
109 '\0', "on|off", "Trace FPU operations",
110 trace_option_handler
, NULL
},
111 { {"trace-vpu", optional_argument
, NULL
, OPTION_TRACE_VPU
},
112 '\0', "on|off", "Trace VPU operations",
113 trace_option_handler
, NULL
},
114 { {"trace-branch", optional_argument
, NULL
, OPTION_TRACE_BRANCH
},
115 '\0', "on|off", "Trace branching",
116 trace_option_handler
, NULL
},
117 { {"trace-semantics", optional_argument
, NULL
, OPTION_TRACE_SEMANTICS
},
118 '\0', "on|off", "Perform ALU, FPU, MEMORY, and BRANCH tracing",
119 trace_option_handler
, NULL
},
120 { {"trace-model", optional_argument
, NULL
, OPTION_TRACE_MODEL
},
121 '\0', "on|off", "Include model performance data",
122 trace_option_handler
, NULL
},
123 { {"trace-core", optional_argument
, NULL
, OPTION_TRACE_CORE
},
124 '\0', "on|off", "Trace core operations",
125 trace_option_handler
, NULL
},
126 { {"trace-events", optional_argument
, NULL
, OPTION_TRACE_EVENTS
},
127 '\0', "on|off", "Trace events",
128 trace_option_handler
, NULL
},
129 { {"trace-syscall", optional_argument
, NULL
, OPTION_TRACE_SYSCALL
},
130 '\0', "on|off", "Trace system calls",
131 trace_option_handler
, NULL
},
132 #ifdef SIM_HAVE_ADDR_RANGE
133 { {"trace-range", required_argument
, NULL
, OPTION_TRACE_RANGE
},
134 '\0', "START,END", "Specify range of addresses for instruction tracing",
135 trace_option_handler
, NULL
},
137 { {"trace-function", required_argument
, NULL
, OPTION_TRACE_FUNCTION
},
138 '\0', "FUNCTION", "Specify function to trace",
139 trace_option_handler
, NULL
},
142 { {"trace-debug", optional_argument
, NULL
, OPTION_TRACE_DEBUG
},
143 '\0', "on|off", "Add information useful for debugging the simulator to the tracing output",
144 trace_option_handler
, NULL
},
145 { {"trace-file", required_argument
, NULL
, OPTION_TRACE_FILE
},
146 '\0', "FILE NAME", "Specify tracing output file",
147 trace_option_handler
, NULL
},
148 { {NULL
, no_argument
, NULL
, 0}, '\0', NULL
, NULL
, NULL
, NULL
}
151 /* Set/reset the trace options indicated in MASK. */
154 set_trace_option_mask (SIM_DESC sd
, const char *name
, int mask
, const char *arg
)
162 if (strcmp (arg
, "yes") == 0
163 || strcmp (arg
, "on") == 0
164 || strcmp (arg
, "1") == 0)
166 else if (strcmp (arg
, "no") == 0
167 || strcmp (arg
, "off") == 0
168 || strcmp (arg
, "0") == 0)
172 sim_io_eprintf (sd
, "Argument `%s' for `--trace%s' invalid, one of `on', `off', `yes', `no' expected\n", arg
, name
);
177 /* update applicable trace bits */
178 for (trace_nr
= 0; trace_nr
< MAX_TRACE_VALUES
; ++trace_nr
)
180 if ((mask
& (1 << trace_nr
)) == 0)
183 /* Set non-cpu specific values. */
186 case TRACE_EVENTS_IDX
:
187 STATE_EVENTS (sd
)->trace
= trace_val
;
189 case TRACE_DEBUG_IDX
:
190 STATE_TRACE_FLAGS (sd
)[trace_nr
] = trace_val
;
194 /* Set cpu values. */
195 for (cpu_nr
= 0; cpu_nr
< MAX_NR_PROCESSORS
; cpu_nr
++)
197 CPU_TRACE_FLAGS (STATE_CPU (sd
, cpu_nr
))[trace_nr
] = trace_val
;
201 /* Re-compute the cpu trace summary. */
204 for (cpu_nr
= 0; cpu_nr
< MAX_NR_PROCESSORS
; cpu_nr
++)
205 CPU_TRACE_DATA (STATE_CPU (sd
, cpu_nr
))->trace_any_p
= 1;
209 for (cpu_nr
= 0; cpu_nr
< MAX_NR_PROCESSORS
; cpu_nr
++)
211 CPU_TRACE_DATA (STATE_CPU (sd
, cpu_nr
))->trace_any_p
= 0;
212 for (trace_nr
= 0; trace_nr
< MAX_TRACE_VALUES
; ++trace_nr
)
214 if (CPU_TRACE_FLAGS (STATE_CPU (sd
, cpu_nr
))[trace_nr
])
216 CPU_TRACE_DATA (STATE_CPU (sd
, cpu_nr
))->trace_any_p
= 1;
226 /* Set one trace option based on its IDX value. */
229 set_trace_option (SIM_DESC sd
, const char *name
, int idx
, const char *arg
)
231 return set_trace_option_mask (sd
, name
, 1 << idx
, arg
);
236 trace_option_handler (SIM_DESC sd
, sim_cpu
*cpu
, int opt
,
237 char *arg
, int is_command
)
245 sim_io_eprintf (sd
, "Tracing not compiled in, `-t' ignored\n");
247 return set_trace_option_mask (sd
, "trace", TRACE_USEFUL_MASK
, arg
);
250 case OPTION_TRACE_INSN
:
251 if (WITH_TRACE_INSN_P
)
252 return set_trace_option (sd
, "-insn", TRACE_INSN_IDX
, arg
);
254 sim_io_eprintf (sd
, "Instruction tracing not compiled in, `--trace-insn' ignored\n");
257 case OPTION_TRACE_DECODE
:
258 if (WITH_TRACE_DECODE_P
)
259 return set_trace_option (sd
, "-decode", TRACE_DECODE_IDX
, arg
);
261 sim_io_eprintf (sd
, "Decode tracing not compiled in, `--trace-decode' ignored\n");
264 case OPTION_TRACE_EXTRACT
:
265 if (WITH_TRACE_EXTRACT_P
)
266 return set_trace_option (sd
, "-extract", TRACE_EXTRACT_IDX
, arg
);
268 sim_io_eprintf (sd
, "Extract tracing not compiled in, `--trace-extract' ignored\n");
271 case OPTION_TRACE_LINENUM
:
272 if (WITH_TRACE_LINENUM_P
&& WITH_TRACE_INSN_P
)
274 if (set_trace_option (sd
, "-linenum", TRACE_LINENUM_IDX
, arg
) != SIM_RC_OK
275 || set_trace_option (sd
, "-linenum", TRACE_INSN_IDX
, arg
) != SIM_RC_OK
)
279 sim_io_eprintf (sd
, "Line number or instruction tracing not compiled in, `--trace-linenum' ignored\n");
282 case OPTION_TRACE_MEMORY
:
283 if (WITH_TRACE_MEMORY_P
)
284 return set_trace_option (sd
, "-memory", TRACE_MEMORY_IDX
, arg
);
286 sim_io_eprintf (sd
, "Memory tracing not compiled in, `--trace-memory' ignored\n");
289 case OPTION_TRACE_MODEL
:
290 if (WITH_TRACE_MODEL_P
)
291 return set_trace_option (sd
, "-model", TRACE_MODEL_IDX
, arg
);
293 sim_io_eprintf (sd
, "Model tracing not compiled in, `--trace-model' ignored\n");
296 case OPTION_TRACE_ALU
:
297 if (WITH_TRACE_ALU_P
)
298 return set_trace_option (sd
, "-alu", TRACE_ALU_IDX
, arg
);
300 sim_io_eprintf (sd
, "ALU tracing not compiled in, `--trace-alu' ignored\n");
303 case OPTION_TRACE_CORE
:
304 if (WITH_TRACE_CORE_P
)
305 return set_trace_option (sd
, "-core", TRACE_CORE_IDX
, arg
);
307 sim_io_eprintf (sd
, "CORE tracing not compiled in, `--trace-core' ignored\n");
310 case OPTION_TRACE_EVENTS
:
311 if (WITH_TRACE_EVENTS_P
)
312 return set_trace_option (sd
, "-events", TRACE_EVENTS_IDX
, arg
);
314 sim_io_eprintf (sd
, "EVENTS tracing not compiled in, `--trace-events' ignored\n");
317 case OPTION_TRACE_FPU
:
318 if (WITH_TRACE_FPU_P
)
319 return set_trace_option (sd
, "-fpu", TRACE_FPU_IDX
, arg
);
321 sim_io_eprintf (sd
, "FPU tracing not compiled in, `--trace-fpu' ignored\n");
324 case OPTION_TRACE_VPU
:
325 if (WITH_TRACE_VPU_P
)
326 return set_trace_option (sd
, "-vpu", TRACE_VPU_IDX
, arg
);
328 sim_io_eprintf (sd
, "VPU tracing not compiled in, `--trace-vpu' ignored\n");
331 case OPTION_TRACE_BRANCH
:
332 if (WITH_TRACE_BRANCH_P
)
333 return set_trace_option (sd
, "-branch", TRACE_BRANCH_IDX
, arg
);
335 sim_io_eprintf (sd
, "Branch tracing not compiled in, `--trace-branch' ignored\n");
338 case OPTION_TRACE_SYSCALL
:
339 if (WITH_TRACE_SYSCALL_P
)
340 return set_trace_option (sd
, "-syscall", TRACE_SYSCALL_IDX
, arg
);
342 sim_io_eprintf (sd
, "System call tracing not compiled in, `--trace-syscall' ignored\n");
345 case OPTION_TRACE_SEMANTICS
:
348 && WITH_TRACE_MEMORY_P
349 && WITH_TRACE_BRANCH_P
)
351 if (set_trace_option (sd
, "-semantics", TRACE_ALU_IDX
, arg
) != SIM_RC_OK
352 || set_trace_option (sd
, "-semantics", TRACE_FPU_IDX
, arg
) != SIM_RC_OK
353 || set_trace_option (sd
, "-semantics", TRACE_VPU_IDX
, arg
) != SIM_RC_OK
354 || set_trace_option (sd
, "-semantics", TRACE_MEMORY_IDX
, arg
) != SIM_RC_OK
355 || set_trace_option (sd
, "-semantics", TRACE_BRANCH_IDX
, arg
) != SIM_RC_OK
)
359 sim_io_eprintf (sd
, "Alu, fpu, memory, and/or branch tracing not compiled in, `--trace-semantics' ignored\n");
362 #ifdef SIM_HAVE_ADDR_RANGE
363 case OPTION_TRACE_RANGE
:
368 unsigned long start
,end
;
369 start
= strtoul (chp
, &chp
, 0);
372 sim_io_eprintf (sd
, "--trace-range missing END argument\n");
375 end
= strtoul (chp
+ 1, NULL
, 0);
376 /* FIXME: Argument validation. */
378 sim_addr_range_add (TRACE_RANGE (CPU_PROFILE_DATA (cpu
)),
381 for (cpu_nr
= 0; cpu_nr
< MAX_NR_PROCESSORS
; ++cpu_nr
)
382 sim_addr_range_add (TRACE_RANGE (CPU_TRACE_DATA (STATE_CPU (sd
, cpu_nr
))),
386 sim_io_eprintf (sd
, "Tracing not compiled in, `--trace-range' ignored\n");
389 case OPTION_TRACE_FUNCTION
:
392 /*wip: need to compute function range given name*/
395 sim_io_eprintf (sd
, "Tracing not compiled in, `--trace-function' ignored\n");
397 #endif /* SIM_HAVE_ADDR_RANGE */
399 case OPTION_TRACE_DEBUG
:
400 if (WITH_TRACE_DEBUG_P
)
401 return set_trace_option (sd
, "-debug", TRACE_DEBUG_IDX
, arg
);
403 sim_io_eprintf (sd
, "Tracing debug support not compiled in, `--trace-debug' ignored\n");
406 case OPTION_TRACE_FILE
:
408 sim_io_eprintf (sd
, "Tracing not compiled in, `--trace-file' ignored\n");
411 FILE *f
= fopen (arg
, "w");
415 sim_io_eprintf (sd
, "Unable to open trace output file `%s'\n", arg
);
418 for (n
= 0; n
< MAX_NR_PROCESSORS
; ++n
)
419 TRACE_FILE (CPU_TRACE_DATA (STATE_CPU (sd
, n
))) = f
;
420 TRACE_FILE (STATE_TRACE_DATA (sd
)) = f
;
428 /* Install tracing support. */
431 trace_install (SIM_DESC sd
)
435 SIM_ASSERT (STATE_MAGIC (sd
) == SIM_MAGIC_NUMBER
);
437 sim_add_option_table (sd
, NULL
, trace_options
);
438 memset (STATE_TRACE_DATA (sd
), 0, sizeof (* STATE_TRACE_DATA (sd
)));
439 for (i
= 0; i
< MAX_NR_PROCESSORS
; ++i
)
440 memset (CPU_TRACE_DATA (STATE_CPU (sd
, i
)), 0,
441 sizeof (* CPU_TRACE_DATA (STATE_CPU (sd
, i
))));
442 sim_module_add_init_fn (sd
, trace_init
);
443 sim_module_add_uninstall_fn (sd
, trace_uninstall
);
448 trace_init (SIM_DESC sd
)
450 #ifdef SIM_HAVE_ADDR_RANGE
451 /* Check if a range has been specified without specifying what to
456 for (i
= 0; i
< MAX_NR_PROCESSORS
; ++i
)
458 sim_cpu
*cpu
= STATE_CPU (sd
, i
);
460 if (ADDR_RANGE_RANGES (TRACE_RANGE (CPU_TRACE_DATA (cpu
)))
461 && ! TRACE_INSN_P (cpu
))
463 sim_io_eprintf_cpu (cpu
, "Tracing address range specified without --trace-insn.\n");
464 sim_io_eprintf_cpu (cpu
, "Address range ignored.\n");
465 sim_addr_range_delete (TRACE_RANGE (CPU_TRACE_DATA (cpu
)),
466 0, ~ (address_word
) 0);
476 trace_uninstall (SIM_DESC sd
)
479 FILE *sfile
= TRACE_FILE (STATE_TRACE_DATA (sd
));
484 for (i
= 0; i
< MAX_NR_PROCESSORS
; ++i
)
486 FILE *cfile
= TRACE_FILE (CPU_TRACE_DATA (STATE_CPU (sd
, i
)));
487 if (cfile
!= NULL
&& cfile
!= sfile
)
489 /* If output from different cpus is going to the same file,
490 avoid closing the file twice. */
491 for (j
= 0; j
< i
; ++j
)
492 if (TRACE_FILE (CPU_TRACE_DATA (STATE_CPU (sd
, j
))) == cfile
)
508 trace_fmt_instruction_incomplete
,
511 /* compute the nr of trace data units consumed by data */
513 save_data_size (TRACE_DATA
*data
,
516 return ((size
+ sizeof (TRACE_INPUT_DATA (data
) [0]) - 1)
517 / sizeof (TRACE_INPUT_DATA (data
) [0]));
521 /* Archive DATA into the trace buffer */
523 save_data (SIM_DESC sd
,
529 int i
= TRACE_INPUT_IDX (data
);
530 if (i
== sizeof (TRACE_INPUT_FMT (data
)))
531 sim_io_error (sd
, "trace buffer overflow");
532 TRACE_INPUT_FMT (data
) [i
] = fmt
;
533 TRACE_INPUT_SIZE (data
) [i
] = size
;
534 memcpy (&TRACE_INPUT_DATA (data
) [i
], buf
, size
);
535 i
+= save_data_size (data
, size
);
536 TRACE_INPUT_IDX (data
) = i
;
540 print_data (SIM_DESC sd
,
548 case trace_fmt_instruction_incomplete
:
549 trace_printf (sd
, cpu
, " (instruction incomplete)");
556 case sizeof (unsigned32
):
557 trace_printf (sd
, cpu
, " 0x%08lx", (long) * (unsigned32
*) data
);
559 case sizeof (unsigned64
):
560 trace_printf (sd
, cpu
, " 0x%08lx%08lx",
561 (long) ((* (unsigned64
*) data
) >> 32),
562 (long) * (unsigned64
*) data
);
571 SIM_ASSERT (size
== sizeof (int));
572 trace_printf (sd
, cpu
, " %-8s",
573 (* (int*) data
) ? "true" : "false");
581 /* FIXME: Assumes sizeof float == 4; sizeof double == 8 */
583 sim_fpu_32to (&fp
, *(unsigned32
*)data
);
586 sim_fpu_64to (&fp
, *(unsigned64
*)data
);
591 trace_printf (sd
, cpu
, " %8g", sim_fpu_2d (&fp
));
595 trace_printf (sd
, cpu
, " (0x%08lx)",
596 (long) *(unsigned32
*)data
);
599 trace_printf (sd
, cpu
, " (0x%08lx%08lx)",
600 (long) (*(unsigned64
*)data
>> 32),
601 (long) (*(unsigned64
*)data
));
609 /* FIXME: At present sim_fpu data is stored as a double */
610 trace_printf (sd
, cpu
, " %8g", * (double*) data
);
612 case trace_fmt_string
:
613 trace_printf (sd
, cpu
, " %-8s", (char*) data
);
621 trace_idx_to_str (int trace_idx
)
626 case TRACE_ALU_IDX
: return "alu: ";
627 case TRACE_INSN_IDX
: return "insn: ";
628 case TRACE_DECODE_IDX
: return "decode: ";
629 case TRACE_EXTRACT_IDX
: return "extract: ";
630 case TRACE_MEMORY_IDX
: return "memory: ";
631 case TRACE_CORE_IDX
: return "core: ";
632 case TRACE_EVENTS_IDX
: return "events: ";
633 case TRACE_FPU_IDX
: return "fpu: ";
634 case TRACE_BRANCH_IDX
: return "branch: ";
635 case TRACE_SYSCALL_IDX
: return "syscall: ";
636 case TRACE_VPU_IDX
: return "vpu: ";
638 sprintf (num
, "?%d?", trace_idx
);
644 trace_results (SIM_DESC sd
,
649 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
653 /* cross check trace_idx against TRACE_IDX (data)? */
656 trace_printf (sd
, cpu
, "%s %s",
657 trace_idx_to_str (TRACE_IDX (data
)),
658 TRACE_PREFIX (data
));
659 TRACE_IDX (data
) = 0;
661 for (i
= 0, nr_out
= 0;
662 i
< TRACE_INPUT_IDX (data
);
663 i
+= save_data_size (data
, TRACE_INPUT_SIZE (data
) [i
]), nr_out
++)
667 int pad
= (strlen (" 0x") + sizeof (unsigned_word
) * 2);
668 int padding
= pad
* (3 - nr_out
);
671 padding
+= strlen (" ::");
672 trace_printf (sd
, cpu
, "%*s", padding
, " ::");
675 TRACE_INPUT_FMT (data
) [i
],
676 TRACE_INPUT_SIZE (data
) [i
],
677 &TRACE_INPUT_DATA (data
) [i
]);
679 trace_printf (sd
, cpu
, "\n");
683 trace_prefix (SIM_DESC sd
,
688 const char *filename
,
693 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
695 char *prefix
= TRACE_PREFIX (data
);
697 /* FIXME: The TRACE_PREFIX_WIDTH should be determined at build time using
698 known information about the disassembled instructions. */
699 #ifndef TRACE_PREFIX_WIDTH
700 #define TRACE_PREFIX_WIDTH 48
702 int width
= TRACE_PREFIX_WIDTH
;
704 /* if the previous trace data wasn't flushed, flush it now with a
705 note indicating that the trace was incomplete. */
706 if (TRACE_IDX (data
) != 0)
708 int last_input
= TRACE_INPUT_IDX (data
);
709 save_data (sd
, data
, trace_fmt_instruction_incomplete
, 1, "");
710 trace_results (sd
, cpu
, TRACE_IDX (data
), last_input
);
712 TRACE_IDX (data
) = 0;
713 TRACE_INPUT_IDX (data
) = 0;
715 /* Create the text prefix for this new instruction: */
720 sprintf (prefix
, "%s:%-*d 0x%.*lx ",
722 SIZE_LINE_NUMBER
, linenum
,
727 sprintf (prefix
, "0x%.*lx ",
729 /* Shrink the width by the amount that we didn't print. */
730 width
-= SIZE_LINE_NUMBER
+ SIZE_PC
+ 8;
732 chp
= strchr (prefix
, '\0');
734 vsprintf (chp
, fmt
, ap
);
741 if (STATE_TEXT_SECTION (CPU_STATE (cpu
))
742 && pc
>= STATE_TEXT_START (CPU_STATE (cpu
))
743 && pc
< STATE_TEXT_END (CPU_STATE (cpu
)))
745 const char *pc_filename
= (const char *)0;
746 const char *pc_function
= (const char *)0;
747 unsigned int pc_linenum
= 0;
751 abfd
= STATE_PROG_BFD (CPU_STATE (cpu
));
752 asymbols
= STATE_PROG_SYMS (CPU_STATE (cpu
));
753 if (asymbols
== NULL
)
758 symsize
= bfd_get_symtab_upper_bound (abfd
);
761 sim_engine_abort (sd
, cpu
, cia
, "could not read symbols");
763 asymbols
= (asymbol
**) xmalloc (symsize
);
764 symbol_count
= bfd_canonicalize_symtab (abfd
, asymbols
);
765 if (symbol_count
< 0)
767 sim_engine_abort (sd
, cpu
, cia
, "could not canonicalize symbols");
769 STATE_PROG_SYMS (CPU_STATE (cpu
)) = asymbols
;
772 if (bfd_find_nearest_line (abfd
,
773 STATE_TEXT_SECTION (CPU_STATE (cpu
)),
775 pc
- STATE_TEXT_START (CPU_STATE (cpu
)),
776 &pc_filename
, &pc_function
, &pc_linenum
))
781 sprintf (p
, "#%-*d ", SIZE_LINE_NUMBER
, pc_linenum
);
786 sprintf (p
, "%-*s ", SIZE_LINE_NUMBER
+1, "---");
787 p
+= SIZE_LINE_NUMBER
+2;
792 sprintf (p
, "%s ", pc_function
);
795 else if (pc_filename
)
797 char *q
= (char *) strrchr (pc_filename
, '/');
798 sprintf (p
, "%s ", (q
) ? q
+1 : pc_filename
);
807 sprintf (prefix
, "0x%.*x %-*.*s ",
808 SIZE_PC
, (unsigned) pc
,
809 SIZE_LOCATION
, SIZE_LOCATION
, buf
);
810 chp
= strchr (prefix
, '\0');
812 vsprintf (chp
, fmt
, ap
);
816 /* Pad it out to TRACE_PREFIX_WIDTH. */
817 chp
= strchr (prefix
, '\0');
818 if (chp
- prefix
< width
)
820 memset (chp
, ' ', width
- (chp
- prefix
));
821 chp
= &prefix
[width
];
826 /* check that we've not over flowed the prefix buffer */
827 if (strlen (prefix
) >= sizeof (TRACE_PREFIX (data
)))
832 trace_generic (SIM_DESC sd
,
839 trace_printf (sd
, cpu
, "%s %s",
840 trace_idx_to_str (trace_idx
),
841 TRACE_PREFIX (CPU_TRACE_DATA (cpu
)));
843 trace_vprintf (sd
, cpu
, fmt
, ap
);
845 trace_printf (sd
, cpu
, "\n");
849 trace_input0 (SIM_DESC sd
,
853 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
854 TRACE_IDX (data
) = trace_idx
;
858 trace_input_word1 (SIM_DESC sd
,
863 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
864 TRACE_IDX (data
) = trace_idx
;
865 save_data (sd
, data
, trace_fmt_word
, sizeof (unsigned_word
), &d0
);
869 trace_input_word2 (SIM_DESC sd
,
875 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
876 TRACE_IDX (data
) = trace_idx
;
877 save_data (sd
, data
, trace_fmt_word
, sizeof (unsigned_word
), &d0
);
878 save_data (sd
, data
, trace_fmt_word
, sizeof (unsigned_word
), &d1
);
882 trace_input_word3 (SIM_DESC sd
,
889 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
890 TRACE_IDX (data
) = trace_idx
;
891 save_data (sd
, data
, trace_fmt_word
, sizeof (unsigned_word
), &d0
);
892 save_data (sd
, data
, trace_fmt_word
, sizeof (unsigned_word
), &d1
);
893 save_data (sd
, data
, trace_fmt_word
, sizeof (unsigned_word
), &d2
);
897 trace_input_word4 (SIM_DESC sd
,
905 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
906 TRACE_IDX (data
) = trace_idx
;
907 save_data (sd
, data
, trace_fmt_word
, sizeof (d0
), &d0
);
908 save_data (sd
, data
, trace_fmt_word
, sizeof (d1
), &d1
);
909 save_data (sd
, data
, trace_fmt_word
, sizeof (d2
), &d2
);
910 save_data (sd
, data
, trace_fmt_word
, sizeof (d3
), &d3
);
914 trace_input_bool1 (SIM_DESC sd
,
919 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
920 TRACE_IDX (data
) = trace_idx
;
921 save_data (sd
, data
, trace_fmt_bool
, sizeof (d0
), &d0
);
925 trace_input_addr1 (SIM_DESC sd
,
930 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
931 TRACE_IDX (data
) = trace_idx
;
932 save_data (sd
, data
, trace_fmt_addr
, sizeof (d0
), &d0
);
936 trace_input_fp1 (SIM_DESC sd
,
941 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
942 TRACE_IDX (data
) = trace_idx
;
943 save_data (sd
, data
, trace_fmt_fp
, sizeof (fp_word
), &f0
);
947 trace_input_fp2 (SIM_DESC sd
,
953 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
954 TRACE_IDX (data
) = trace_idx
;
955 save_data (sd
, data
, trace_fmt_fp
, sizeof (fp_word
), &f0
);
956 save_data (sd
, data
, trace_fmt_fp
, sizeof (fp_word
), &f1
);
960 trace_input_fp3 (SIM_DESC sd
,
967 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
968 TRACE_IDX (data
) = trace_idx
;
969 save_data (sd
, data
, trace_fmt_fp
, sizeof (fp_word
), &f0
);
970 save_data (sd
, data
, trace_fmt_fp
, sizeof (fp_word
), &f1
);
971 save_data (sd
, data
, trace_fmt_fp
, sizeof (fp_word
), &f2
);
975 trace_input_fpu1 (SIM_DESC sd
,
981 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
982 TRACE_IDX (data
) = trace_idx
;
984 save_data (sd
, data
, trace_fmt_fp
, sizeof (double), &d
);
988 trace_input_fpu2 (SIM_DESC sd
,
995 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
996 TRACE_IDX (data
) = trace_idx
;
998 save_data (sd
, data
, trace_fmt_fp
, sizeof (double), &d
);
1000 save_data (sd
, data
, trace_fmt_fp
, sizeof (double), &d
);
1004 trace_input_fpu3 (SIM_DESC sd
,
1012 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
1013 TRACE_IDX (data
) = trace_idx
;
1014 d
= sim_fpu_2d (f0
);
1015 save_data (sd
, data
, trace_fmt_fp
, sizeof (double), &d
);
1016 d
= sim_fpu_2d (f1
);
1017 save_data (sd
, data
, trace_fmt_fp
, sizeof (double), &d
);
1018 d
= sim_fpu_2d (f2
);
1019 save_data (sd
, data
, trace_fmt_fp
, sizeof (double), &d
);
1023 trace_result_word1 (SIM_DESC sd
,
1028 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
1031 /* Append any results to the end of the inputs */
1032 last_input
= TRACE_INPUT_IDX (data
);
1033 save_data (sd
, data
, trace_fmt_word
, sizeof (unsigned_word
), &r0
);
1035 trace_results (sd
, cpu
, trace_idx
, last_input
);
1039 trace_result0 (SIM_DESC sd
,
1043 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
1046 /* Append any results to the end of the inputs */
1047 last_input
= TRACE_INPUT_IDX (data
);
1049 trace_results (sd
, cpu
, trace_idx
, last_input
);
1053 trace_result_word2 (SIM_DESC sd
,
1059 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
1062 /* Append any results to the end of the inputs */
1063 last_input
= TRACE_INPUT_IDX (data
);
1064 save_data (sd
, data
, trace_fmt_word
, sizeof (r0
), &r0
);
1065 save_data (sd
, data
, trace_fmt_word
, sizeof (r1
), &r1
);
1067 trace_results (sd
, cpu
, trace_idx
, last_input
);
1071 trace_result_word4 (SIM_DESC sd
,
1079 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
1082 /* Append any results to the end of the inputs */
1083 last_input
= TRACE_INPUT_IDX (data
);
1084 save_data (sd
, data
, trace_fmt_word
, sizeof (r0
), &r0
);
1085 save_data (sd
, data
, trace_fmt_word
, sizeof (r1
), &r1
);
1086 save_data (sd
, data
, trace_fmt_word
, sizeof (r2
), &r2
);
1087 save_data (sd
, data
, trace_fmt_word
, sizeof (r3
), &r3
);
1089 trace_results (sd
, cpu
, trace_idx
, last_input
);
1093 trace_result_bool1 (SIM_DESC sd
,
1098 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
1101 /* Append any results to the end of the inputs */
1102 last_input
= TRACE_INPUT_IDX (data
);
1103 save_data (sd
, data
, trace_fmt_bool
, sizeof (r0
), &r0
);
1105 trace_results (sd
, cpu
, trace_idx
, last_input
);
1109 trace_result_addr1 (SIM_DESC sd
,
1114 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
1117 /* Append any results to the end of the inputs */
1118 last_input
= TRACE_INPUT_IDX (data
);
1119 save_data (sd
, data
, trace_fmt_addr
, sizeof (r0
), &r0
);
1121 trace_results (sd
, cpu
, trace_idx
, last_input
);
1125 trace_result_fp1 (SIM_DESC sd
,
1130 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
1133 /* Append any results to the end of the inputs */
1134 last_input
= TRACE_INPUT_IDX (data
);
1135 save_data (sd
, data
, trace_fmt_fp
, sizeof (fp_word
), &f0
);
1137 trace_results (sd
, cpu
, trace_idx
, last_input
);
1141 trace_result_fp2 (SIM_DESC sd
,
1147 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
1150 /* Append any results to the end of the inputs */
1151 last_input
= TRACE_INPUT_IDX (data
);
1152 save_data (sd
, data
, trace_fmt_fp
, sizeof (f0
), &f0
);
1153 save_data (sd
, data
, trace_fmt_fp
, sizeof (f1
), &f1
);
1155 trace_results (sd
, cpu
, trace_idx
, last_input
);
1159 trace_result_fpu1 (SIM_DESC sd
,
1165 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
1168 /* Append any results to the end of the inputs */
1169 last_input
= TRACE_INPUT_IDX (data
);
1170 d
= sim_fpu_2d (f0
);
1171 save_data (sd
, data
, trace_fmt_fp
, sizeof (double), &d
);
1173 trace_results (sd
, cpu
, trace_idx
, last_input
);
1177 trace_result_string1 (SIM_DESC sd
,
1182 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
1185 /* Append any results to the end of the inputs */
1186 last_input
= TRACE_INPUT_IDX (data
);
1187 save_data (sd
, data
, trace_fmt_string
, strlen (s0
) + 1, s0
);
1189 trace_results (sd
, cpu
, trace_idx
, last_input
);
1193 trace_result_word1_string1 (SIM_DESC sd
,
1199 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
1202 /* Append any results to the end of the inputs */
1203 last_input
= TRACE_INPUT_IDX (data
);
1204 save_data (sd
, data
, trace_fmt_word
, sizeof (unsigned_word
), &r0
);
1205 save_data (sd
, data
, trace_fmt_string
, strlen (s0
) + 1, s0
);
1207 trace_results (sd
, cpu
, trace_idx
, last_input
);
1211 trace_vprintf (SIM_DESC sd
, sim_cpu
*cpu
, const char *fmt
, va_list ap
)
1215 if (TRACE_FILE (CPU_TRACE_DATA (cpu
)) != NULL
)
1216 vfprintf (TRACE_FILE (CPU_TRACE_DATA (cpu
)), fmt
, ap
);
1218 sim_io_evprintf (sd
, fmt
, ap
);
1222 if (TRACE_FILE (STATE_TRACE_DATA (sd
)) != NULL
)
1223 vfprintf (TRACE_FILE (STATE_TRACE_DATA (sd
)), fmt
, ap
);
1225 sim_io_evprintf (sd
, fmt
, ap
);
1229 /* The function trace_one_insn has been replaced by the function pair
1230 trace_prefix() + trace_generic(). It is still used. */
1232 trace_one_insn (SIM_DESC sd
, sim_cpu
*cpu
, address_word pc
,
1233 int line_p
, const char *filename
, int linenum
,
1234 const char *phase_wo_colon
, const char *fmt
,
1238 char phase
[SIZE_PHASE
+2];
1240 strncpy (phase
, phase_wo_colon
, SIZE_PHASE
);
1241 strcat (phase
, ":");
1245 trace_printf (sd
, cpu
, "%-*s %s:%-*d 0x%.*lx ",
1246 SIZE_PHASE
+1, phase
,
1248 SIZE_LINE_NUMBER
, linenum
,
1251 trace_vprintf (sd
, cpu
, fmt
, ap
);
1253 trace_printf (sd
, cpu
, "\n");
1260 if (STATE_TEXT_SECTION (CPU_STATE (cpu
))
1261 && pc
>= STATE_TEXT_START (CPU_STATE (cpu
))
1262 && pc
< STATE_TEXT_END (CPU_STATE (cpu
)))
1264 const char *pc_filename
= (const char *)0;
1265 const char *pc_function
= (const char *)0;
1266 unsigned int pc_linenum
= 0;
1268 if (bfd_find_nearest_line (STATE_PROG_BFD (CPU_STATE (cpu
)),
1269 STATE_TEXT_SECTION (CPU_STATE (cpu
)),
1270 (struct bfd_symbol
**) 0,
1271 pc
- STATE_TEXT_START (CPU_STATE (cpu
)),
1272 &pc_filename
, &pc_function
, &pc_linenum
))
1277 sprintf (p
, "#%-*d ", SIZE_LINE_NUMBER
, pc_linenum
);
1282 sprintf (p
, "%-*s ", SIZE_LINE_NUMBER
+1, "---");
1283 p
+= SIZE_LINE_NUMBER
+2;
1288 sprintf (p
, "%s ", pc_function
);
1291 else if (pc_filename
)
1293 char *q
= (char *) strrchr (pc_filename
, '/');
1294 sprintf (p
, "%s ", (q
) ? q
+1 : pc_filename
);
1303 trace_printf (sd
, cpu
, "%-*s 0x%.*x %-*.*s ",
1304 SIZE_PHASE
+1, phase
,
1305 SIZE_PC
, (unsigned) pc
,
1306 SIZE_LOCATION
, SIZE_LOCATION
, buf
);
1308 trace_vprintf (sd
, cpu
, fmt
, ap
);
1310 trace_printf (sd
, cpu
, "\n");
1315 trace_printf
VPARAMS ((SIM_DESC sd
, sim_cpu
*cpu
, const char *fmt
, ...))
1317 #if !defined __STDC__ && !defined ALMOST_STDC
1325 #if !defined __STDC__ && !defined ALMOST_STDC
1326 sd
= va_arg (ap
, SIM_DESC
);
1327 cpu
= va_arg (ap
, sim_cpu
*);
1328 fmt
= va_arg (ap
, const char *);
1331 trace_vprintf (sd
, cpu
, fmt
, ap
);
1337 debug_printf
VPARAMS ((sim_cpu
*cpu
, const char *fmt
, ...))
1339 #if !defined __STDC__ && !defined ALMOST_STDC
1346 #if !defined __STDC__ && !defined ALMOST_STDC
1347 cpu
= va_arg (ap
, sim_cpu
*);
1348 fmt
= va_arg (ap
, const char *);
1351 if (CPU_DEBUG_FILE (cpu
) == NULL
)
1352 (* STATE_CALLBACK (CPU_STATE (cpu
))->evprintf_filtered
)
1353 (STATE_CALLBACK (CPU_STATE (cpu
)), fmt
, ap
);
1355 vfprintf (CPU_DEBUG_FILE (cpu
), fmt
, ap
);