1 /* Simulator tracing/debugging support.
2 Copyright (C) 1997-2016 Free Software Foundation, Inc.
3 Contributed by Cygnus Support.
5 This file is part of GDB, the GNU debugger.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "sim-options.h"
26 #include "libiberty.h"
30 #include "sim-assert.h"
48 #define SIZE_LOCATION 20
55 #ifndef SIZE_LINE_NUMBER
56 #define SIZE_LINE_NUMBER 4
59 static MODULE_INIT_FN trace_init
;
60 static MODULE_UNINSTALL_FN trace_uninstall
;
62 static DECLARE_OPTION_HANDLER (trace_option_handler
);
65 OPTION_TRACE_INSN
= OPTION_START
,
77 OPTION_TRACE_SEMANTICS
,
79 OPTION_TRACE_FUNCTION
,
87 static const OPTION trace_options
[] =
89 /* This table is organized to group related instructions together. */
90 { {"trace", optional_argument
, NULL
, 't'},
91 't', "on|off", "Trace useful things",
92 trace_option_handler
, NULL
},
93 { {"trace-insn", optional_argument
, NULL
, OPTION_TRACE_INSN
},
94 '\0', "on|off", "Perform instruction tracing",
95 trace_option_handler
, NULL
},
96 { {"trace-disasm", optional_argument
, NULL
, OPTION_TRACE_DISASM
},
97 '\0', "on|off", "Disassemble instructions (slower, but more accurate)",
98 trace_option_handler
, NULL
},
99 { {"trace-decode", optional_argument
, NULL
, OPTION_TRACE_DECODE
},
100 '\0', "on|off", "Trace instruction decoding",
101 trace_option_handler
, NULL
},
102 { {"trace-extract", optional_argument
, NULL
, OPTION_TRACE_EXTRACT
},
103 '\0', "on|off", "Trace instruction extraction",
104 trace_option_handler
, NULL
},
105 { {"trace-linenum", optional_argument
, NULL
, OPTION_TRACE_LINENUM
},
106 '\0', "on|off", "Perform line number tracing (implies --trace-insn)",
107 trace_option_handler
, NULL
},
108 { {"trace-memory", optional_argument
, NULL
, OPTION_TRACE_MEMORY
},
109 '\0', "on|off", "Trace memory operations",
110 trace_option_handler
, NULL
},
111 { {"trace-alu", optional_argument
, NULL
, OPTION_TRACE_ALU
},
112 '\0', "on|off", "Trace ALU (Arithmetic Logic Unit) operations",
113 trace_option_handler
, NULL
},
114 { {"trace-fpu", optional_argument
, NULL
, OPTION_TRACE_FPU
},
115 '\0', "on|off", "Trace FPU (Floating Point Unit) operations",
116 trace_option_handler
, NULL
},
117 { {"trace-vpu", optional_argument
, NULL
, OPTION_TRACE_VPU
},
118 '\0', "on|off", "Trace VPU (Vector Processing Unit) operations",
119 trace_option_handler
, NULL
},
120 { {"trace-branch", optional_argument
, NULL
, OPTION_TRACE_BRANCH
},
121 '\0', "on|off", "Trace branching",
122 trace_option_handler
, NULL
},
123 { {"trace-semantics", optional_argument
, NULL
, OPTION_TRACE_SEMANTICS
},
124 '\0', "on|off", "Perform ALU, FPU, VPU, MEMORY, and BRANCH tracing",
125 trace_option_handler
, NULL
},
126 { {"trace-model", optional_argument
, NULL
, OPTION_TRACE_MODEL
},
127 '\0', "on|off", "Include model performance data",
128 trace_option_handler
, NULL
},
129 { {"trace-core", optional_argument
, NULL
, OPTION_TRACE_CORE
},
130 '\0', "on|off", "Trace core operations",
131 trace_option_handler
, NULL
},
132 { {"trace-events", optional_argument
, NULL
, OPTION_TRACE_EVENTS
},
133 '\0', "on|off", "Trace events",
134 trace_option_handler
, NULL
},
135 { {"trace-syscall", optional_argument
, NULL
, OPTION_TRACE_SYSCALL
},
136 '\0', "on|off", "Trace system calls",
137 trace_option_handler
, NULL
},
138 { {"trace-register", optional_argument
, NULL
, OPTION_TRACE_REGISTER
},
139 '\0', "on|off", "Trace cpu register accesses",
140 trace_option_handler
, NULL
},
141 #ifdef SIM_HAVE_ADDR_RANGE
142 { {"trace-range", required_argument
, NULL
, OPTION_TRACE_RANGE
},
143 '\0', "START,END", "Specify range of addresses for instruction tracing",
144 trace_option_handler
, NULL
},
146 { {"trace-function", required_argument
, NULL
, OPTION_TRACE_FUNCTION
},
147 '\0', "FUNCTION", "Specify function to trace",
148 trace_option_handler
, NULL
},
151 { {"trace-debug", optional_argument
, NULL
, OPTION_TRACE_DEBUG
},
152 '\0', "on|off", "Add information useful for debugging the simulator to the tracing output",
153 trace_option_handler
, NULL
},
154 { {"trace-file", required_argument
, NULL
, OPTION_TRACE_FILE
},
155 '\0', "FILE NAME", "Specify tracing output file",
156 trace_option_handler
, NULL
},
157 { {NULL
, no_argument
, NULL
, 0}, '\0', NULL
, NULL
, NULL
, NULL
}
160 /* Set/reset the trace options indicated in MASK. */
163 set_trace_option_mask (SIM_DESC sd
, const char *name
, int mask
, const char *arg
)
171 if (strcmp (arg
, "yes") == 0
172 || strcmp (arg
, "on") == 0
173 || strcmp (arg
, "1") == 0)
175 else if (strcmp (arg
, "no") == 0
176 || strcmp (arg
, "off") == 0
177 || strcmp (arg
, "0") == 0)
181 sim_io_eprintf (sd
, "Argument `%s' for `--trace%s' invalid, one of `on', `off', `yes', `no' expected\n", arg
, name
);
186 /* Update applicable trace bits. */
187 for (trace_nr
= 0; trace_nr
< MAX_TRACE_VALUES
; ++trace_nr
)
189 if ((mask
& (1 << trace_nr
)) == 0)
192 /* Set non-cpu specific values. */
193 STATE_TRACE_FLAGS (sd
)[trace_nr
] = trace_val
;
195 /* Set cpu values. */
196 for (cpu_nr
= 0; cpu_nr
< MAX_NR_PROCESSORS
; cpu_nr
++)
198 CPU_TRACE_FLAGS (STATE_CPU (sd
, cpu_nr
))[trace_nr
] = trace_val
;
202 /* Re-compute the cpu trace summary. */
205 for (cpu_nr
= 0; cpu_nr
< MAX_NR_PROCESSORS
; cpu_nr
++)
206 CPU_TRACE_DATA (STATE_CPU (sd
, cpu_nr
))->trace_any_p
= 1;
210 for (cpu_nr
= 0; cpu_nr
< MAX_NR_PROCESSORS
; cpu_nr
++)
212 CPU_TRACE_DATA (STATE_CPU (sd
, cpu_nr
))->trace_any_p
= 0;
213 for (trace_nr
= 0; trace_nr
< MAX_TRACE_VALUES
; ++trace_nr
)
215 if (CPU_TRACE_FLAGS (STATE_CPU (sd
, cpu_nr
))[trace_nr
])
217 CPU_TRACE_DATA (STATE_CPU (sd
, cpu_nr
))->trace_any_p
= 1;
227 /* Set one trace option based on its IDX value. */
230 set_trace_option (SIM_DESC sd
, const char *name
, int idx
, const char *arg
)
232 return set_trace_option_mask (sd
, name
, 1 << idx
, arg
);
237 trace_option_handler (SIM_DESC sd
, sim_cpu
*cpu
, int opt
,
238 char *arg
, int is_command
)
245 if (!WITH_TRACE_ANY_P
)
246 sim_io_eprintf (sd
, "Tracing not compiled in, `-t' ignored\n");
248 return set_trace_option_mask (sd
, "trace", TRACE_USEFUL_MASK
, arg
);
251 case OPTION_TRACE_INSN
:
252 if (WITH_TRACE_INSN_P
)
253 return set_trace_option (sd
, "-insn", TRACE_INSN_IDX
, arg
);
255 sim_io_eprintf (sd
, "Instruction tracing not compiled in, `--trace-insn' ignored\n");
258 case OPTION_TRACE_DISASM
:
259 if (WITH_TRACE_DISASM_P
)
260 return set_trace_option (sd
, "-disasm", TRACE_DISASM_IDX
, arg
);
262 sim_io_eprintf (sd
, "Instruction tracing not compiled in, `--trace-disasm' ignored\n");
265 case OPTION_TRACE_DECODE
:
266 if (WITH_TRACE_DECODE_P
)
267 return set_trace_option (sd
, "-decode", TRACE_DECODE_IDX
, arg
);
269 sim_io_eprintf (sd
, "Decode tracing not compiled in, `--trace-decode' ignored\n");
272 case OPTION_TRACE_EXTRACT
:
273 if (WITH_TRACE_EXTRACT_P
)
274 return set_trace_option (sd
, "-extract", TRACE_EXTRACT_IDX
, arg
);
276 sim_io_eprintf (sd
, "Extract tracing not compiled in, `--trace-extract' ignored\n");
279 case OPTION_TRACE_LINENUM
:
280 if (WITH_TRACE_LINENUM_P
&& WITH_TRACE_INSN_P
)
282 if (set_trace_option (sd
, "-linenum", TRACE_LINENUM_IDX
, arg
) != SIM_RC_OK
283 || set_trace_option (sd
, "-linenum", TRACE_INSN_IDX
, arg
) != SIM_RC_OK
)
287 sim_io_eprintf (sd
, "Line number or instruction tracing not compiled in, `--trace-linenum' ignored\n");
290 case OPTION_TRACE_MEMORY
:
291 if (WITH_TRACE_MEMORY_P
)
292 return set_trace_option (sd
, "-memory", TRACE_MEMORY_IDX
, arg
);
294 sim_io_eprintf (sd
, "Memory tracing not compiled in, `--trace-memory' ignored\n");
297 case OPTION_TRACE_MODEL
:
298 if (WITH_TRACE_MODEL_P
)
299 return set_trace_option (sd
, "-model", TRACE_MODEL_IDX
, arg
);
301 sim_io_eprintf (sd
, "Model tracing not compiled in, `--trace-model' ignored\n");
304 case OPTION_TRACE_ALU
:
305 if (WITH_TRACE_ALU_P
)
306 return set_trace_option (sd
, "-alu", TRACE_ALU_IDX
, arg
);
308 sim_io_eprintf (sd
, "ALU tracing not compiled in, `--trace-alu' ignored\n");
311 case OPTION_TRACE_CORE
:
312 if (WITH_TRACE_CORE_P
)
313 return set_trace_option (sd
, "-core", TRACE_CORE_IDX
, arg
);
315 sim_io_eprintf (sd
, "CORE tracing not compiled in, `--trace-core' ignored\n");
318 case OPTION_TRACE_EVENTS
:
319 if (WITH_TRACE_EVENTS_P
)
320 return set_trace_option (sd
, "-events", TRACE_EVENTS_IDX
, arg
);
322 sim_io_eprintf (sd
, "EVENTS tracing not compiled in, `--trace-events' ignored\n");
325 case OPTION_TRACE_FPU
:
326 if (WITH_TRACE_FPU_P
)
327 return set_trace_option (sd
, "-fpu", TRACE_FPU_IDX
, arg
);
329 sim_io_eprintf (sd
, "FPU tracing not compiled in, `--trace-fpu' ignored\n");
332 case OPTION_TRACE_VPU
:
333 if (WITH_TRACE_VPU_P
)
334 return set_trace_option (sd
, "-vpu", TRACE_VPU_IDX
, arg
);
336 sim_io_eprintf (sd
, "VPU tracing not compiled in, `--trace-vpu' ignored\n");
339 case OPTION_TRACE_BRANCH
:
340 if (WITH_TRACE_BRANCH_P
)
341 return set_trace_option (sd
, "-branch", TRACE_BRANCH_IDX
, arg
);
343 sim_io_eprintf (sd
, "Branch tracing not compiled in, `--trace-branch' ignored\n");
346 case OPTION_TRACE_SYSCALL
:
347 if (WITH_TRACE_SYSCALL_P
)
348 return set_trace_option (sd
, "-syscall", TRACE_SYSCALL_IDX
, arg
);
350 sim_io_eprintf (sd
, "System call tracing not compiled in, `--trace-syscall' ignored\n");
353 case OPTION_TRACE_REGISTER
:
354 if (WITH_TRACE_REGISTER_P
)
355 return set_trace_option (sd
, "-register", TRACE_REGISTER_IDX
, arg
);
357 sim_io_eprintf (sd
, "Register tracing not compiled in, `--trace-register' ignored\n");
360 case OPTION_TRACE_SEMANTICS
:
363 && WITH_TRACE_MEMORY_P
364 && WITH_TRACE_BRANCH_P
)
366 if (set_trace_option (sd
, "-semantics", TRACE_ALU_IDX
, arg
) != SIM_RC_OK
367 || set_trace_option (sd
, "-semantics", TRACE_FPU_IDX
, arg
) != SIM_RC_OK
368 || set_trace_option (sd
, "-semantics", TRACE_VPU_IDX
, arg
) != SIM_RC_OK
369 || set_trace_option (sd
, "-semantics", TRACE_MEMORY_IDX
, arg
) != SIM_RC_OK
370 || set_trace_option (sd
, "-semantics", TRACE_BRANCH_IDX
, arg
) != SIM_RC_OK
)
374 sim_io_eprintf (sd
, "Alu, fpu, memory, and/or branch tracing not compiled in, `--trace-semantics' ignored\n");
377 #ifdef SIM_HAVE_ADDR_RANGE
378 case OPTION_TRACE_RANGE
:
379 if (WITH_TRACE_ANY_P
)
383 unsigned long start
,end
;
384 start
= strtoul (chp
, &chp
, 0);
387 sim_io_eprintf (sd
, "--trace-range missing END argument\n");
390 end
= strtoul (chp
+ 1, NULL
, 0);
391 /* FIXME: Argument validation. */
393 sim_addr_range_add (TRACE_RANGE (CPU_PROFILE_DATA (cpu
)),
396 for (cpu_nr
= 0; cpu_nr
< MAX_NR_PROCESSORS
; ++cpu_nr
)
397 sim_addr_range_add (TRACE_RANGE (CPU_TRACE_DATA (STATE_CPU (sd
, cpu_nr
))),
401 sim_io_eprintf (sd
, "Tracing not compiled in, `--trace-range' ignored\n");
404 case OPTION_TRACE_FUNCTION
:
405 if (WITH_TRACE_ANY_P
)
407 /*wip: need to compute function range given name*/
410 sim_io_eprintf (sd
, "Tracing not compiled in, `--trace-function' ignored\n");
412 #endif /* SIM_HAVE_ADDR_RANGE */
414 case OPTION_TRACE_DEBUG
:
415 if (WITH_TRACE_DEBUG_P
)
416 return set_trace_option (sd
, "-debug", TRACE_DEBUG_IDX
, arg
);
418 sim_io_eprintf (sd
, "Tracing debug support not compiled in, `--trace-debug' ignored\n");
421 case OPTION_TRACE_FILE
:
422 if (!WITH_TRACE_ANY_P
)
423 sim_io_eprintf (sd
, "Tracing not compiled in, `--trace-file' ignored\n");
426 FILE *f
= fopen (arg
, "w");
430 sim_io_eprintf (sd
, "Unable to open trace output file `%s'\n", arg
);
433 for (n
= 0; n
< MAX_NR_PROCESSORS
; ++n
)
434 TRACE_FILE (CPU_TRACE_DATA (STATE_CPU (sd
, n
))) = f
;
435 TRACE_FILE (STATE_TRACE_DATA (sd
)) = f
;
443 /* Install tracing support. */
446 trace_install (SIM_DESC sd
)
450 SIM_ASSERT (STATE_MAGIC (sd
) == SIM_MAGIC_NUMBER
);
452 sim_add_option_table (sd
, NULL
, trace_options
);
453 memset (STATE_TRACE_DATA (sd
), 0, sizeof (* STATE_TRACE_DATA (sd
)));
454 for (i
= 0; i
< MAX_NR_PROCESSORS
; ++i
)
455 memset (CPU_TRACE_DATA (STATE_CPU (sd
, i
)), 0,
456 sizeof (* CPU_TRACE_DATA (STATE_CPU (sd
, i
))));
457 sim_module_add_init_fn (sd
, trace_init
);
458 sim_module_add_uninstall_fn (sd
, trace_uninstall
);
463 trace_init (SIM_DESC sd
)
465 #ifdef SIM_HAVE_ADDR_RANGE
466 /* Check if a range has been specified without specifying what to
471 for (i
= 0; i
< MAX_NR_PROCESSORS
; ++i
)
473 sim_cpu
*cpu
= STATE_CPU (sd
, i
);
475 if (ADDR_RANGE_RANGES (TRACE_RANGE (CPU_TRACE_DATA (cpu
)))
476 && ! TRACE_INSN_P (cpu
))
478 sim_io_eprintf_cpu (cpu
, "Tracing address range specified without --trace-insn.\n");
479 sim_io_eprintf_cpu (cpu
, "Address range ignored.\n");
480 sim_addr_range_delete (TRACE_RANGE (CPU_TRACE_DATA (cpu
)),
481 0, ~ (address_word
) 0);
491 trace_uninstall (SIM_DESC sd
)
494 FILE *sfile
= TRACE_FILE (STATE_TRACE_DATA (sd
));
499 for (i
= 0; i
< MAX_NR_PROCESSORS
; ++i
)
501 FILE *cfile
= TRACE_FILE (CPU_TRACE_DATA (STATE_CPU (sd
, i
)));
502 if (cfile
!= NULL
&& cfile
!= sfile
)
504 /* If output from different cpus is going to the same file,
505 avoid closing the file twice. */
506 for (j
= 0; j
< i
; ++j
)
507 if (TRACE_FILE (CPU_TRACE_DATA (STATE_CPU (sd
, j
))) == cfile
)
515 /* compute the nr of trace data units consumed by data */
517 save_data_size (TRACE_DATA
*data
,
520 return ((size
+ sizeof (TRACE_INPUT_DATA (data
) [0]) - 1)
521 / sizeof (TRACE_INPUT_DATA (data
) [0]));
525 /* Archive DATA into the trace buffer */
527 save_data (SIM_DESC sd
,
533 int i
= TRACE_INPUT_IDX (data
);
534 if (i
== sizeof (TRACE_INPUT_FMT (data
)))
535 sim_io_error (sd
, "trace buffer overflow");
536 TRACE_INPUT_FMT (data
) [i
] = fmt
;
537 TRACE_INPUT_SIZE (data
) [i
] = size
;
538 memcpy (&TRACE_INPUT_DATA (data
) [i
], buf
, size
);
539 i
+= save_data_size (data
, size
);
540 TRACE_INPUT_IDX (data
) = i
;
544 print_data (SIM_DESC sd
,
552 case trace_fmt_instruction_incomplete
:
553 trace_printf (sd
, cpu
, " (instruction incomplete)");
560 case sizeof (unsigned32
):
561 trace_printf (sd
, cpu
, " 0x%08lx", (long) * (unsigned32
*) data
);
563 case sizeof (unsigned64
):
564 trace_printf (sd
, cpu
, " 0x%08lx%08lx",
565 (long) ((* (unsigned64
*) data
) >> 32),
566 (long) * (unsigned64
*) data
);
575 SIM_ASSERT (size
== sizeof (int));
576 trace_printf (sd
, cpu
, " %-8s",
577 (* (int*) data
) ? "true" : "false");
585 /* FIXME: Assumes sizeof float == 4; sizeof double == 8 */
587 sim_fpu_32to (&fp
, *(unsigned32
*)data
);
590 sim_fpu_64to (&fp
, *(unsigned64
*)data
);
595 trace_printf (sd
, cpu
, " %8g", sim_fpu_2d (&fp
));
599 trace_printf (sd
, cpu
, " (0x%08lx)",
600 (long) *(unsigned32
*)data
);
603 trace_printf (sd
, cpu
, " (0x%08lx%08lx)",
604 (long) (*(unsigned64
*)data
>> 32),
605 (long) (*(unsigned64
*)data
));
613 /* FIXME: At present sim_fpu data is stored as a double */
614 trace_printf (sd
, cpu
, " %8g", * (double*) data
);
616 case trace_fmt_string
:
617 trace_printf (sd
, cpu
, " %-8s", (char*) data
);
625 trace_idx_to_str (int trace_idx
)
630 case TRACE_ALU_IDX
: return "alu: ";
631 case TRACE_INSN_IDX
: return "insn: ";
632 case TRACE_DISASM_IDX
: return "disasm: ";
633 case TRACE_DECODE_IDX
: return "decode: ";
634 case TRACE_EXTRACT_IDX
: return "extract: ";
635 case TRACE_MEMORY_IDX
: return "memory: ";
636 case TRACE_CORE_IDX
: return "core: ";
637 case TRACE_EVENTS_IDX
: return "events: ";
638 case TRACE_FPU_IDX
: return "fpu: ";
639 case TRACE_BRANCH_IDX
: return "branch: ";
640 case TRACE_SYSCALL_IDX
: return "syscall: ";
641 case TRACE_REGISTER_IDX
: return "reg: ";
642 case TRACE_VPU_IDX
: return "vpu: ";
644 sprintf (num
, "?%d?", trace_idx
);
650 trace_results (SIM_DESC sd
,
655 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
659 /* cross check trace_idx against TRACE_IDX (data)? */
662 trace_printf (sd
, cpu
, "%s %s",
663 trace_idx_to_str (TRACE_IDX (data
)),
664 TRACE_PREFIX (data
));
665 TRACE_IDX (data
) = 0;
667 for (i
= 0, nr_out
= 0;
668 i
< TRACE_INPUT_IDX (data
);
669 i
+= save_data_size (data
, TRACE_INPUT_SIZE (data
) [i
]), nr_out
++)
673 int pad
= (strlen (" 0x") + sizeof (unsigned_word
) * 2);
674 int padding
= pad
* (3 - nr_out
);
677 padding
+= strlen (" ::");
678 trace_printf (sd
, cpu
, "%*s", padding
, " ::");
681 TRACE_INPUT_FMT (data
) [i
],
682 TRACE_INPUT_SIZE (data
) [i
],
683 &TRACE_INPUT_DATA (data
) [i
]);
685 trace_printf (sd
, cpu
, "\n");
689 trace_prefix (SIM_DESC sd
,
694 const char *filename
,
699 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
701 char *prefix
= TRACE_PREFIX (data
);
703 /* FIXME: The TRACE_PREFIX_WIDTH should be determined at build time using
704 known information about the disassembled instructions. */
705 #ifndef TRACE_PREFIX_WIDTH
706 #define TRACE_PREFIX_WIDTH 48
708 int width
= TRACE_PREFIX_WIDTH
;
710 /* if the previous trace data wasn't flushed, flush it now with a
711 note indicating that the trace was incomplete. */
712 if (TRACE_IDX (data
) != 0)
714 int last_input
= TRACE_INPUT_IDX (data
);
715 save_data (sd
, data
, trace_fmt_instruction_incomplete
, 1, "");
716 trace_results (sd
, cpu
, TRACE_IDX (data
), last_input
);
718 TRACE_IDX (data
) = 0;
719 TRACE_INPUT_IDX (data
) = 0;
721 /* Create the text prefix for this new instruction: */
726 sprintf (prefix
, "%s:%-*d 0x%.*lx ",
728 SIZE_LINE_NUMBER
, linenum
,
733 sprintf (prefix
, "0x%.*lx ",
735 /* Shrink the width by the amount that we didn't print. */
736 width
-= SIZE_LINE_NUMBER
+ SIZE_PC
+ 8;
738 chp
= strchr (prefix
, '\0');
740 vsprintf (chp
, fmt
, ap
);
747 if (STATE_TEXT_SECTION (CPU_STATE (cpu
))
748 && pc
>= STATE_TEXT_START (CPU_STATE (cpu
))
749 && pc
< STATE_TEXT_END (CPU_STATE (cpu
)))
751 const char *pc_filename
= (const char *)0;
752 const char *pc_function
= (const char *)0;
753 unsigned int pc_linenum
= 0;
757 abfd
= STATE_PROG_BFD (CPU_STATE (cpu
));
758 asymbols
= STATE_PROG_SYMS (CPU_STATE (cpu
));
759 if (asymbols
== NULL
)
764 symsize
= bfd_get_symtab_upper_bound (abfd
);
767 sim_engine_abort (sd
, cpu
, cia
, "could not read symbols");
769 asymbols
= (asymbol
**) xmalloc (symsize
);
770 symbol_count
= bfd_canonicalize_symtab (abfd
, asymbols
);
771 if (symbol_count
< 0)
773 sim_engine_abort (sd
, cpu
, cia
, "could not canonicalize symbols");
775 STATE_PROG_SYMS (CPU_STATE (cpu
)) = asymbols
;
778 if (bfd_find_nearest_line (abfd
,
779 STATE_TEXT_SECTION (CPU_STATE (cpu
)),
781 pc
- STATE_TEXT_START (CPU_STATE (cpu
)),
782 &pc_filename
, &pc_function
, &pc_linenum
))
787 sprintf (p
, "#%-*d ", SIZE_LINE_NUMBER
, pc_linenum
);
792 sprintf (p
, "%-*s ", SIZE_LINE_NUMBER
+1, "---");
793 p
+= SIZE_LINE_NUMBER
+2;
798 sprintf (p
, "%s ", pc_function
);
801 else if (pc_filename
)
803 char *q
= (char *) strrchr (pc_filename
, '/');
804 sprintf (p
, "%s ", (q
) ? q
+1 : pc_filename
);
813 sprintf (prefix
, "0x%.*x %-*.*s ",
814 SIZE_PC
, (unsigned) pc
,
815 SIZE_LOCATION
, SIZE_LOCATION
, buf
);
816 chp
= strchr (prefix
, '\0');
818 vsprintf (chp
, fmt
, ap
);
822 /* Pad it out to TRACE_PREFIX_WIDTH. */
823 chp
= strchr (prefix
, '\0');
824 if (chp
- prefix
< width
)
826 memset (chp
, ' ', width
- (chp
- prefix
));
827 chp
= &prefix
[width
];
832 /* check that we've not over flowed the prefix buffer */
833 if (strlen (prefix
) >= sizeof (TRACE_PREFIX (data
)))
838 trace_generic (SIM_DESC sd
,
845 trace_printf (sd
, cpu
, "%s %s",
846 trace_idx_to_str (trace_idx
),
847 TRACE_PREFIX (CPU_TRACE_DATA (cpu
)));
849 trace_vprintf (sd
, cpu
, fmt
, ap
);
851 trace_printf (sd
, cpu
, "\n");
855 dis_read (bfd_vma memaddr
, bfd_byte
*myaddr
, unsigned int length
,
856 struct disassemble_info
*dinfo
)
858 SIM_CPU
*cpu
= dinfo
->application_data
;
859 sim_core_read_buffer (CPU_STATE (cpu
), cpu
, NULL_CIA
, myaddr
, memaddr
, length
);
864 dis_printf (SIM_CPU
*cpu
, const char *fmt
, ...)
866 SIM_DESC sd
= CPU_STATE (cpu
);
869 trace_vprintf (sd
, cpu
, fmt
, ap
);
875 trace_disasm (SIM_DESC sd
, sim_cpu
*cpu
, address_word addr
)
877 struct bfd
*bfd
= STATE_PROG_BFD (sd
);
878 TRACE_DATA
*trace_data
= CPU_TRACE_DATA (cpu
);
879 disassemble_info
*info
= &trace_data
->dis_info
;
881 /* See if we need to set up the disassembly func. */
882 if (trace_data
->dis_bfd
!= bfd
)
884 trace_data
->dis_bfd
= bfd
;
885 trace_data
->disassembler
= disassembler (trace_data
->dis_bfd
);
886 INIT_DISASSEMBLE_INFO (*info
, cpu
, dis_printf
);
887 info
->read_memory_func
= dis_read
;
888 info
->arch
= bfd_get_arch (bfd
);
889 info
->mach
= bfd_get_mach (bfd
);
890 disassemble_init_for_target (info
);
893 info
->application_data
= cpu
;
895 trace_printf (sd
, cpu
, "%s %s",
896 trace_idx_to_str (TRACE_DISASM_IDX
),
897 TRACE_PREFIX (trace_data
));
898 trace_data
->disassembler (addr
, info
);
899 trace_printf (sd
, cpu
, "\n");
903 trace_input0 (SIM_DESC sd
,
907 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
908 TRACE_IDX (data
) = trace_idx
;
912 trace_input_word1 (SIM_DESC sd
,
917 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
918 TRACE_IDX (data
) = trace_idx
;
919 save_data (sd
, data
, trace_fmt_word
, sizeof (unsigned_word
), &d0
);
923 trace_input_word2 (SIM_DESC sd
,
929 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
930 TRACE_IDX (data
) = trace_idx
;
931 save_data (sd
, data
, trace_fmt_word
, sizeof (unsigned_word
), &d0
);
932 save_data (sd
, data
, trace_fmt_word
, sizeof (unsigned_word
), &d1
);
936 trace_input_word3 (SIM_DESC sd
,
943 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
944 TRACE_IDX (data
) = trace_idx
;
945 save_data (sd
, data
, trace_fmt_word
, sizeof (unsigned_word
), &d0
);
946 save_data (sd
, data
, trace_fmt_word
, sizeof (unsigned_word
), &d1
);
947 save_data (sd
, data
, trace_fmt_word
, sizeof (unsigned_word
), &d2
);
951 trace_input_word4 (SIM_DESC sd
,
959 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
960 TRACE_IDX (data
) = trace_idx
;
961 save_data (sd
, data
, trace_fmt_word
, sizeof (d0
), &d0
);
962 save_data (sd
, data
, trace_fmt_word
, sizeof (d1
), &d1
);
963 save_data (sd
, data
, trace_fmt_word
, sizeof (d2
), &d2
);
964 save_data (sd
, data
, trace_fmt_word
, sizeof (d3
), &d3
);
968 trace_input_bool1 (SIM_DESC sd
,
973 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
974 TRACE_IDX (data
) = trace_idx
;
975 save_data (sd
, data
, trace_fmt_bool
, sizeof (d0
), &d0
);
979 trace_input_addr1 (SIM_DESC sd
,
984 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
985 TRACE_IDX (data
) = trace_idx
;
986 save_data (sd
, data
, trace_fmt_addr
, sizeof (d0
), &d0
);
990 trace_input_fp1 (SIM_DESC sd
,
995 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
996 TRACE_IDX (data
) = trace_idx
;
997 save_data (sd
, data
, trace_fmt_fp
, sizeof (fp_word
), &f0
);
1001 trace_input_fp2 (SIM_DESC sd
,
1007 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
1008 TRACE_IDX (data
) = trace_idx
;
1009 save_data (sd
, data
, trace_fmt_fp
, sizeof (fp_word
), &f0
);
1010 save_data (sd
, data
, trace_fmt_fp
, sizeof (fp_word
), &f1
);
1014 trace_input_fp3 (SIM_DESC sd
,
1021 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
1022 TRACE_IDX (data
) = trace_idx
;
1023 save_data (sd
, data
, trace_fmt_fp
, sizeof (fp_word
), &f0
);
1024 save_data (sd
, data
, trace_fmt_fp
, sizeof (fp_word
), &f1
);
1025 save_data (sd
, data
, trace_fmt_fp
, sizeof (fp_word
), &f2
);
1029 trace_input_fpu1 (SIM_DESC sd
,
1035 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
1036 TRACE_IDX (data
) = trace_idx
;
1037 d
= sim_fpu_2d (f0
);
1038 save_data (sd
, data
, trace_fmt_fp
, sizeof (double), &d
);
1042 trace_input_fpu2 (SIM_DESC sd
,
1049 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
1050 TRACE_IDX (data
) = trace_idx
;
1051 d
= sim_fpu_2d (f0
);
1052 save_data (sd
, data
, trace_fmt_fp
, sizeof (double), &d
);
1053 d
= sim_fpu_2d (f1
);
1054 save_data (sd
, data
, trace_fmt_fp
, sizeof (double), &d
);
1058 trace_input_fpu3 (SIM_DESC sd
,
1066 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
1067 TRACE_IDX (data
) = trace_idx
;
1068 d
= sim_fpu_2d (f0
);
1069 save_data (sd
, data
, trace_fmt_fp
, sizeof (double), &d
);
1070 d
= sim_fpu_2d (f1
);
1071 save_data (sd
, data
, trace_fmt_fp
, sizeof (double), &d
);
1072 d
= sim_fpu_2d (f2
);
1073 save_data (sd
, data
, trace_fmt_fp
, sizeof (double), &d
);
1077 trace_result_word1 (SIM_DESC sd
,
1082 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
1085 /* Append any results to the end of the inputs */
1086 last_input
= TRACE_INPUT_IDX (data
);
1087 save_data (sd
, data
, trace_fmt_word
, sizeof (unsigned_word
), &r0
);
1089 trace_results (sd
, cpu
, trace_idx
, last_input
);
1093 trace_result0 (SIM_DESC sd
,
1097 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
1100 /* Append any results to the end of the inputs */
1101 last_input
= TRACE_INPUT_IDX (data
);
1103 trace_results (sd
, cpu
, trace_idx
, last_input
);
1107 trace_result_word2 (SIM_DESC sd
,
1113 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
1116 /* Append any results to the end of the inputs */
1117 last_input
= TRACE_INPUT_IDX (data
);
1118 save_data (sd
, data
, trace_fmt_word
, sizeof (r0
), &r0
);
1119 save_data (sd
, data
, trace_fmt_word
, sizeof (r1
), &r1
);
1121 trace_results (sd
, cpu
, trace_idx
, last_input
);
1125 trace_result_word4 (SIM_DESC sd
,
1133 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
1136 /* Append any results to the end of the inputs */
1137 last_input
= TRACE_INPUT_IDX (data
);
1138 save_data (sd
, data
, trace_fmt_word
, sizeof (r0
), &r0
);
1139 save_data (sd
, data
, trace_fmt_word
, sizeof (r1
), &r1
);
1140 save_data (sd
, data
, trace_fmt_word
, sizeof (r2
), &r2
);
1141 save_data (sd
, data
, trace_fmt_word
, sizeof (r3
), &r3
);
1143 trace_results (sd
, cpu
, trace_idx
, last_input
);
1147 trace_result_bool1 (SIM_DESC sd
,
1152 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
1155 /* Append any results to the end of the inputs */
1156 last_input
= TRACE_INPUT_IDX (data
);
1157 save_data (sd
, data
, trace_fmt_bool
, sizeof (r0
), &r0
);
1159 trace_results (sd
, cpu
, trace_idx
, last_input
);
1163 trace_result_addr1 (SIM_DESC sd
,
1168 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
1171 /* Append any results to the end of the inputs */
1172 last_input
= TRACE_INPUT_IDX (data
);
1173 save_data (sd
, data
, trace_fmt_addr
, sizeof (r0
), &r0
);
1175 trace_results (sd
, cpu
, trace_idx
, last_input
);
1179 trace_result_fp1 (SIM_DESC sd
,
1184 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
1187 /* Append any results to the end of the inputs */
1188 last_input
= TRACE_INPUT_IDX (data
);
1189 save_data (sd
, data
, trace_fmt_fp
, sizeof (fp_word
), &f0
);
1191 trace_results (sd
, cpu
, trace_idx
, last_input
);
1195 trace_result_fp2 (SIM_DESC sd
,
1201 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
1204 /* Append any results to the end of the inputs */
1205 last_input
= TRACE_INPUT_IDX (data
);
1206 save_data (sd
, data
, trace_fmt_fp
, sizeof (f0
), &f0
);
1207 save_data (sd
, data
, trace_fmt_fp
, sizeof (f1
), &f1
);
1209 trace_results (sd
, cpu
, trace_idx
, last_input
);
1213 trace_result_fpu1 (SIM_DESC sd
,
1219 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
1222 /* Append any results to the end of the inputs */
1223 last_input
= TRACE_INPUT_IDX (data
);
1224 d
= sim_fpu_2d (f0
);
1225 save_data (sd
, data
, trace_fmt_fp
, sizeof (double), &d
);
1227 trace_results (sd
, cpu
, trace_idx
, last_input
);
1231 trace_result_string1 (SIM_DESC sd
,
1236 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
1239 /* Append any results to the end of the inputs */
1240 last_input
= TRACE_INPUT_IDX (data
);
1241 save_data (sd
, data
, trace_fmt_string
, strlen (s0
) + 1, s0
);
1243 trace_results (sd
, cpu
, trace_idx
, last_input
);
1247 trace_result_word1_string1 (SIM_DESC sd
,
1253 TRACE_DATA
*data
= CPU_TRACE_DATA (cpu
);
1256 /* Append any results to the end of the inputs */
1257 last_input
= TRACE_INPUT_IDX (data
);
1258 save_data (sd
, data
, trace_fmt_word
, sizeof (unsigned_word
), &r0
);
1259 save_data (sd
, data
, trace_fmt_string
, strlen (s0
) + 1, s0
);
1261 trace_results (sd
, cpu
, trace_idx
, last_input
);
1265 trace_vprintf (SIM_DESC sd
, sim_cpu
*cpu
, const char *fmt
, va_list ap
)
1269 if (TRACE_FILE (CPU_TRACE_DATA (cpu
)) != NULL
)
1270 vfprintf (TRACE_FILE (CPU_TRACE_DATA (cpu
)), fmt
, ap
);
1272 sim_io_evprintf (sd
, fmt
, ap
);
1276 if (TRACE_FILE (STATE_TRACE_DATA (sd
)) != NULL
)
1277 vfprintf (TRACE_FILE (STATE_TRACE_DATA (sd
)), fmt
, ap
);
1279 sim_io_evprintf (sd
, fmt
, ap
);
1284 trace_printf (SIM_DESC sd
, sim_cpu
*cpu
, const char *fmt
, ...)
1290 trace_vprintf (sd
, cpu
, fmt
, ap
);
1296 sim_debug_printf (sim_cpu
*cpu
, const char *fmt
, ...)
1302 if (CPU_DEBUG_FILE (cpu
) == NULL
)
1303 (* STATE_CALLBACK (CPU_STATE (cpu
))->evprintf_filtered
)
1304 (STATE_CALLBACK (CPU_STATE (cpu
)), fmt
, ap
);
1306 vfprintf (CPU_DEBUG_FILE (cpu
), fmt
, ap
);