1 /* Simulator tracing/debugging support.
2 Copyright (C) 1997, 1998 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 2, or (at your option)
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 along
18 with this program; if not, write to the Free Software Foundation, Inc.,
19 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
23 #include "sim-options.h"
27 #include "sim-assert.h"
42 #define SIZE_LOCATION 20
49 #ifndef SIZE_LINE_NUMBER
50 #define SIZE_LINE_NUMBER 4
53 static MODULE_UNINSTALL_FN trace_uninstall;
55 static DECLARE_OPTION_HANDLER (trace_option_handler);
58 OPTION_TRACE_INSN = OPTION_START,
69 OPTION_TRACE_SEMANTICS,
74 static const OPTION trace_options[] =
76 /* This table is organized to group related instructions together. */
77 { {"trace", optional_argument, NULL, 't'},
78 't', "on|off", "Trace useful things",
79 trace_option_handler },
80 { {"trace-insn", optional_argument, NULL, OPTION_TRACE_INSN},
81 '\0', "on|off", "Perform instruction tracing",
82 trace_option_handler },
83 { {"trace-decode", optional_argument, NULL, OPTION_TRACE_DECODE},
84 '\0', "on|off", "Trace instruction decoding",
85 trace_option_handler },
86 { {"trace-extract", optional_argument, NULL, OPTION_TRACE_EXTRACT},
87 '\0', "on|off", "Trace instruction extraction",
88 trace_option_handler },
89 { {"trace-linenum", optional_argument, NULL, OPTION_TRACE_LINENUM},
90 '\0', "on|off", "Perform line number tracing (implies --trace-insn)",
91 trace_option_handler },
92 { {"trace-memory", optional_argument, NULL, OPTION_TRACE_MEMORY},
93 '\0', "on|off", "Trace memory operations",
94 trace_option_handler },
95 { {"trace-alu", optional_argument, NULL, OPTION_TRACE_ALU},
96 '\0', "on|off", "Trace ALU operations",
97 trace_option_handler },
98 { {"trace-fpu", optional_argument, NULL, OPTION_TRACE_FPU},
99 '\0', "on|off", "Trace FPU operations",
100 trace_option_handler },
101 { {"trace-branch", optional_argument, NULL, OPTION_TRACE_BRANCH},
102 '\0', "on|off", "Trace branching",
103 trace_option_handler },
104 { {"trace-semantics", optional_argument, NULL, OPTION_TRACE_SEMANTICS},
105 '\0', "on|off", "Perform ALU, FPU, MEMORY, and BRANCH tracing",
106 trace_option_handler },
107 { {"trace-model", optional_argument, NULL, OPTION_TRACE_MODEL},
108 '\0', "on|off", "Include model performance data",
109 trace_option_handler },
110 { {"trace-core", optional_argument, NULL, OPTION_TRACE_CORE},
111 '\0', "on|off", "Trace core operations",
112 trace_option_handler },
113 { {"trace-events", optional_argument, NULL, OPTION_TRACE_EVENTS},
114 '\0', "on|off", "Trace events",
115 trace_option_handler },
116 { {"trace-debug", optional_argument, NULL, OPTION_TRACE_DEBUG},
117 '\0', "on|off", "Add information useful for debugging the simulator to the tracing output",
118 trace_option_handler },
119 { {"trace-file", required_argument, NULL, OPTION_TRACE_FILE},
120 '\0', "FILE NAME", "Specify tracing output file",
121 trace_option_handler },
122 { {NULL, no_argument, NULL, 0}, '\0', NULL, NULL, NULL }
125 /* Set/reset the trace options indicated in MASK. */
128 set_trace_option_mask (sd, name, mask, arg)
140 if (strcmp (arg, "yes") == 0
141 || strcmp (arg, "on") == 0
142 || strcmp (arg, "1") == 0)
144 else if (strcmp (arg, "no") == 0
145 || strcmp (arg, "off") == 0
146 || strcmp (arg, "0") == 0)
150 sim_io_eprintf (sd, "Argument `%s' for `--trace%s' invalid, one of `on', `off', `yes', `no' expected\n", arg, name);
155 for (trace_nr = 0; trace_nr < MAX_TRACE_VALUES; ++trace_nr)
157 if ((mask & (1 << trace_nr)) == 0)
160 /* Set non-cpu specific values. */
163 case TRACE_EVENTS_IDX:
164 STATE_EVENTS (sd)->trace = trace_val;
166 case TRACE_DEBUG_IDX:
167 STATE_TRACE_FLAGS (sd)[trace_nr] = trace_val;
171 /* Set cpu values. */
172 for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; cpu_nr++)
174 CPU_TRACE_FLAGS (STATE_CPU (sd, cpu_nr))[trace_nr] = trace_val;
181 /* Set one trace option based on its IDX value. */
184 set_trace_option (sd, name, idx, arg)
190 return set_trace_option_mask (sd, name, 1 << idx, arg);
195 trace_option_handler (SIM_DESC sd, sim_cpu *cpu, int opt,
196 char *arg, int is_command)
204 sim_io_eprintf (sd, "Tracing not compiled in, `-t' ignored\n");
206 return set_trace_option_mask (sd, "trace", TRACE_USEFUL_MASK, arg);
209 case OPTION_TRACE_INSN :
210 if (WITH_TRACE_INSN_P)
211 return set_trace_option (sd, "-insn", TRACE_INSN_IDX, arg);
213 sim_io_eprintf (sd, "Instruction tracing not compiled in, `--trace-insn' ignored\n");
216 case OPTION_TRACE_DECODE :
217 if (WITH_TRACE_DECODE_P)
218 return set_trace_option (sd, "-decode", TRACE_DECODE_IDX, arg);
220 sim_io_eprintf (sd, "Decode tracing not compiled in, `--trace-decode' ignored\n");
223 case OPTION_TRACE_EXTRACT :
224 if (WITH_TRACE_EXTRACT_P)
225 return set_trace_option (sd, "-extract", TRACE_EXTRACT_IDX, arg);
227 sim_io_eprintf (sd, "Extract tracing not compiled in, `--trace-extract' ignored\n");
230 case OPTION_TRACE_LINENUM :
231 if (WITH_TRACE_LINENUM_P && WITH_TRACE_INSN_P)
233 if (set_trace_option (sd, "-linenum", TRACE_LINENUM_IDX, arg) != SIM_RC_OK
234 || set_trace_option (sd, "-linenum", TRACE_INSN_IDX, arg) != SIM_RC_OK)
238 sim_io_eprintf (sd, "Line number or instruction tracing not compiled in, `--trace-linenum' ignored\n");
241 case OPTION_TRACE_MEMORY :
242 if (WITH_TRACE_MEMORY_P)
243 return set_trace_option (sd, "-memory", TRACE_MEMORY_IDX, arg);
245 sim_io_eprintf (sd, "Memory tracing not compiled in, `--trace-memory' ignored\n");
248 case OPTION_TRACE_MODEL :
249 if (WITH_TRACE_MODEL_P)
250 return set_trace_option (sd, "-model", TRACE_MODEL_IDX, arg);
252 sim_io_eprintf (sd, "Model tracing not compiled in, `--trace-model' ignored\n");
255 case OPTION_TRACE_ALU :
256 if (WITH_TRACE_ALU_P)
257 return set_trace_option (sd, "-alu", TRACE_ALU_IDX, arg);
259 sim_io_eprintf (sd, "ALU tracing not compiled in, `--trace-alu' ignored\n");
262 case OPTION_TRACE_CORE :
263 if (WITH_TRACE_CORE_P)
264 return set_trace_option (sd, "-core", TRACE_CORE_IDX, arg);
266 sim_io_eprintf (sd, "CORE tracing not compiled in, `--trace-core' ignored\n");
269 case OPTION_TRACE_EVENTS :
270 if (WITH_TRACE_EVENTS_P)
271 return set_trace_option (sd, "-events", TRACE_EVENTS_IDX, arg);
273 sim_io_eprintf (sd, "EVENTS tracing not compiled in, `--trace-events' ignored\n");
276 case OPTION_TRACE_FPU :
277 if (WITH_TRACE_FPU_P)
278 return set_trace_option (sd, "-fpu", TRACE_FPU_IDX, arg);
280 sim_io_eprintf (sd, "FPU tracing not compiled in, `--trace-fpu' ignored\n");
283 case OPTION_TRACE_BRANCH :
284 if (WITH_TRACE_BRANCH_P)
285 return set_trace_option (sd, "-branch", TRACE_BRANCH_IDX, arg);
287 sim_io_eprintf (sd, "Branch tracing not compiled in, `--trace-branch' ignored\n");
290 case OPTION_TRACE_SEMANTICS :
293 && WITH_TRACE_MEMORY_P
294 && WITH_TRACE_BRANCH_P)
296 if (set_trace_option (sd, "-semantics", TRACE_ALU_IDX, arg) != SIM_RC_OK
297 || set_trace_option (sd, "-semantics", TRACE_FPU_IDX, arg) != SIM_RC_OK
298 || set_trace_option (sd, "-semantics", TRACE_MEMORY_IDX, arg) != SIM_RC_OK
299 || set_trace_option (sd, "-semantics", TRACE_BRANCH_IDX, arg) != SIM_RC_OK)
303 sim_io_eprintf (sd, "Alu, fpu, memory, and/or branch tracing not compiled in, `--trace-semantics' ignored\n");
306 case OPTION_TRACE_DEBUG :
307 if (WITH_TRACE_DEBUG_P)
308 return set_trace_option (sd, "-debug", TRACE_DEBUG_IDX, arg);
310 sim_io_eprintf (sd, "Tracing debug support not compiled in, `--trace-debug' ignored\n");
313 case OPTION_TRACE_FILE :
315 sim_io_eprintf (sd, "Tracing not compiled in, `--trace-file' ignored\n");
318 FILE *f = fopen (arg, "w");
322 sim_io_eprintf (sd, "Unable to open trace output file `%s'\n", arg);
325 for (n = 0; n < MAX_NR_PROCESSORS; ++n)
326 TRACE_FILE (CPU_TRACE_DATA (STATE_CPU (sd, n))) = f;
327 TRACE_FILE (STATE_TRACE_DATA (sd)) = f;
335 /* Install tracing support. */
338 trace_install (SIM_DESC sd)
342 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
344 sim_add_option_table (sd, NULL, trace_options);
345 memset (STATE_TRACE_DATA (sd), 0, sizeof (* STATE_TRACE_DATA (sd)));
346 for (i = 0; i < MAX_NR_PROCESSORS; ++i)
347 memset (CPU_TRACE_DATA (STATE_CPU (sd, i)), 0,
348 sizeof (* CPU_TRACE_DATA (STATE_CPU (sd, i))));
349 sim_module_add_uninstall_fn (sd, trace_uninstall);
354 trace_uninstall (SIM_DESC sd)
357 FILE *sfile = TRACE_FILE (STATE_TRACE_DATA (sd));
362 for (i = 0; i < MAX_NR_PROCESSORS; ++i)
364 FILE *cfile = TRACE_FILE (CPU_TRACE_DATA (STATE_CPU (sd, i)));
365 if (cfile != NULL && cfile != sfile)
367 /* If output from different cpus is going to the same file,
368 avoid closing the file twice. */
369 for (j = 0; j < i; ++j)
370 if (TRACE_FILE (CPU_TRACE_DATA (STATE_CPU (sd, j))) == cfile)
386 trace_fmt_instruction_incomplete,
389 /* compute the nr of trace data units consumed by data */
391 save_data_size (TRACE_DATA *data,
394 return ((size + sizeof (TRACE_INPUT_DATA (data) [0]) - 1)
395 / sizeof (TRACE_INPUT_DATA (data) [0]));
399 /* Archive DATA into the trace buffer */
401 save_data (SIM_DESC sd,
407 int i = TRACE_INPUT_IDX (data);
408 if (i == sizeof (TRACE_INPUT_FMT (data)))
409 sim_io_error (sd, "trace buffer overflow");
410 TRACE_INPUT_FMT (data) [i] = fmt;
411 TRACE_INPUT_SIZE (data) [i] = size;
412 memcpy (&TRACE_INPUT_DATA (data) [i], buf, size);
413 i += save_data_size (data, size);
414 TRACE_INPUT_IDX (data) = i;
418 print_data (SIM_DESC sd,
426 case trace_fmt_instruction_incomplete:
427 trace_printf (sd, cpu, " (instruction incomplete)");
434 case sizeof (unsigned32):
435 trace_printf (sd, cpu, " 0x%08lx", (long) * (unsigned32*) data);
437 case sizeof (unsigned64):
438 trace_printf (sd, cpu, " 0x%08lx%08lx",
439 (long) ((* (unsigned64*) data) >> 32),
440 (long) * (unsigned64*) data);
449 SIM_ASSERT (size == sizeof (int));
450 trace_printf (sd, cpu, " %-8s",
451 (* (int*) data) ? "true" : "false");
459 /* FIXME: Assumes sizeof float == 4; sizeof double == 8 */
461 sim_fpu_32to (&fp, * (unsigned32*) data);
464 sim_fpu_64to (&fp, * (unsigned32*) data);
469 trace_printf (sd, cpu, " %8g", sim_fpu_2d (&fp));
473 /* FIXME: At present sim_fpu data is stored as a double */
474 trace_printf (sd, cpu, " %8g", * (double*) data);
476 case trace_fmt_string:
477 trace_printf (sd, cpu, " %-8s", (char*) data);
485 trace_idx_to_str (int trace_idx)
490 case TRACE_ALU_IDX: return "alu: ";
491 case TRACE_INSN_IDX: return "insn: ";
492 case TRACE_DECODE_IDX: return "decode: ";
493 case TRACE_EXTRACT_IDX: return "extract: ";
494 case TRACE_MEMORY_IDX: return "memory: ";
495 case TRACE_CORE_IDX: return "core: ";
496 case TRACE_EVENTS_IDX: return "events: ";
497 case TRACE_FPU_IDX: return "fpu: ";
498 case TRACE_BRANCH_IDX: return "branch: ";
500 sprintf (num, "?%d?", trace_idx);
506 trace_results (SIM_DESC sd,
511 TRACE_DATA *data = CPU_TRACE_DATA (cpu);
515 /* cross check trace_idx against TRACE_IDX (data)? */
518 trace_printf (sd, cpu, "%s %s",
519 trace_idx_to_str (TRACE_IDX (data)),
520 TRACE_PREFIX (data));
521 TRACE_IDX (data) = 0;
523 for (i = 0, nr_out = 0;
524 i < TRACE_INPUT_IDX (data);
525 i += save_data_size (data, TRACE_INPUT_SIZE (data) [i]), nr_out++)
529 int pad = (strlen (" 0x") + sizeof (unsigned_word) * 2);
530 int padding = pad * (3 - nr_out);
533 padding += strlen (" ::");
534 trace_printf (sd, cpu, "%*s", padding, " ::");
537 TRACE_INPUT_FMT (data) [i],
538 TRACE_INPUT_SIZE (data) [i],
539 &TRACE_INPUT_DATA (data) [i]);
541 trace_printf (sd, cpu, "\n");
545 trace_prefix (SIM_DESC sd,
549 const char *filename,
554 TRACE_DATA *data = CPU_TRACE_DATA (cpu);
556 char *prefix = TRACE_PREFIX (data);
559 /* if the previous trace data wasn't flushed, flush it now with a
560 note indicating that this occured. */
561 if (TRACE_IDX (data) != 0)
563 int last_input = TRACE_INPUT_IDX (data);
564 save_data (sd, data, trace_fmt_instruction_incomplete, 1, "");
565 trace_results (sd, cpu, TRACE_IDX (data), last_input);
567 TRACE_IDX (data) = 0;
568 TRACE_INPUT_IDX (data) = 0;
572 sprintf (prefix, "%s:%-*d 0x%.*lx ",
574 SIZE_LINE_NUMBER, linenum,
576 chp = strchr (prefix, '\0');
578 vsprintf (chp, fmt, ap);
585 if (STATE_TEXT_SECTION (CPU_STATE (cpu))
586 && pc >= STATE_TEXT_START (CPU_STATE (cpu))
587 && pc < STATE_TEXT_END (CPU_STATE (cpu)))
589 const char *pc_filename = (const char *)0;
590 const char *pc_function = (const char *)0;
591 unsigned int pc_linenum = 0;
595 abfd = STATE_PROG_BFD (CPU_STATE (cpu));
596 asymbols = STATE_PROG_SYMS (CPU_STATE (cpu));
597 if (asymbols == NULL)
602 symsize = bfd_get_symtab_upper_bound (abfd);
605 sim_engine_abort (sd, cpu, 0, "could not read symbols\n");
607 asymbols = (asymbol **) xmalloc (symsize);
608 symbol_count = bfd_canonicalize_symtab (abfd, asymbols);
609 if (symbol_count < 0)
611 sim_engine_abort (sd, cpu, 0, "could not canonicalize symbols\n");
613 STATE_PROG_SYMS (CPU_STATE (cpu)) = asymbols;
615 if (bfd_find_nearest_line (abfd,
616 STATE_TEXT_SECTION (CPU_STATE (cpu)),
618 pc - STATE_TEXT_START (CPU_STATE (cpu)),
619 &pc_filename, &pc_function, &pc_linenum))
624 sprintf (p, "#%-*d ", SIZE_LINE_NUMBER, pc_linenum);
629 sprintf (p, "%-*s ", SIZE_LINE_NUMBER+1, "---");
630 p += SIZE_LINE_NUMBER+2;
635 sprintf (p, "%s ", pc_function);
638 else if (pc_filename)
640 char *q = (char *) strrchr (pc_filename, '/');
641 sprintf (p, "%s ", (q) ? q+1 : pc_filename);
650 sprintf (prefix, "0x%.*x %-*.*s ",
651 SIZE_PC, (unsigned) pc,
652 SIZE_LOCATION, SIZE_LOCATION, buf);
653 chp = strchr (prefix, '\0');
655 vsprintf (chp, fmt, ap);
659 /* pad it out to TRACE_PREFIX_WIDTH. FIXME: The TRACE_PREFIX_WIDTH
660 should be determined at build time using known information about
661 the disassembled instructions */
662 #ifndef TRACE_PREFIX_WIDTH
663 #define TRACE_PREFIX_WIDTH 48
665 chp = strchr (prefix, '\0');
666 if (chp - prefix < TRACE_PREFIX_WIDTH)
668 memset (chp, ' ', TRACE_PREFIX_WIDTH - (chp - prefix));
669 chp = &prefix [TRACE_PREFIX_WIDTH];
674 /* check that we've not over flowed the prefix buffer */
675 if (strlen (prefix) >= sizeof (TRACE_PREFIX (data)))
680 trace_generic (SIM_DESC sd,
687 trace_printf (sd, cpu, "%s %s",
688 trace_idx_to_str (trace_idx),
689 TRACE_PREFIX (CPU_TRACE_DATA (cpu)));
691 trace_vprintf (sd, cpu, fmt, ap);
693 trace_printf (sd, cpu, "\n");
697 trace_input0 (SIM_DESC sd,
701 TRACE_DATA *data = CPU_TRACE_DATA (cpu);
702 TRACE_IDX (data) = trace_idx;
706 trace_input_word1 (SIM_DESC sd,
711 TRACE_DATA *data = CPU_TRACE_DATA (cpu);
712 TRACE_IDX (data) = trace_idx;
713 save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &d0);
717 trace_input_word2 (SIM_DESC sd,
723 TRACE_DATA *data = CPU_TRACE_DATA (cpu);
724 TRACE_IDX (data) = trace_idx;
725 save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &d0);
726 save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &d1);
730 trace_input_word3 (SIM_DESC sd,
737 TRACE_DATA *data = CPU_TRACE_DATA (cpu);
738 TRACE_IDX (data) = trace_idx;
739 save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &d0);
740 save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &d1);
741 save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &d2);
745 trace_input_word4 (SIM_DESC sd,
753 TRACE_DATA *data = CPU_TRACE_DATA (cpu);
754 TRACE_IDX (data) = trace_idx;
755 save_data (sd, data, trace_fmt_word, sizeof (d0), &d0);
756 save_data (sd, data, trace_fmt_word, sizeof (d1), &d1);
757 save_data (sd, data, trace_fmt_word, sizeof (d2), &d2);
758 save_data (sd, data, trace_fmt_word, sizeof (d3), &d3);
762 trace_input_bool1 (SIM_DESC sd,
767 TRACE_DATA *data = CPU_TRACE_DATA (cpu);
768 TRACE_IDX (data) = trace_idx;
769 save_data (sd, data, trace_fmt_bool, sizeof (d0), &d0);
773 trace_input_addr1 (SIM_DESC sd,
778 TRACE_DATA *data = CPU_TRACE_DATA (cpu);
779 TRACE_IDX (data) = trace_idx;
780 save_data (sd, data, trace_fmt_addr, sizeof (d0), &d0);
784 trace_input_fp1 (SIM_DESC sd,
789 TRACE_DATA *data = CPU_TRACE_DATA (cpu);
790 TRACE_IDX (data) = trace_idx;
791 save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f0);
795 trace_input_fp2 (SIM_DESC sd,
801 TRACE_DATA *data = CPU_TRACE_DATA (cpu);
802 TRACE_IDX (data) = trace_idx;
803 save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f0);
804 save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f1);
808 trace_input_fp3 (SIM_DESC sd,
815 TRACE_DATA *data = CPU_TRACE_DATA (cpu);
816 TRACE_IDX (data) = trace_idx;
817 save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f0);
818 save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f1);
819 save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f2);
823 trace_input_fpu1 (SIM_DESC sd,
829 TRACE_DATA *data = CPU_TRACE_DATA (cpu);
830 TRACE_IDX (data) = trace_idx;
832 save_data (sd, data, trace_fmt_fp, sizeof (double), &d);
836 trace_input_fpu2 (SIM_DESC sd,
843 TRACE_DATA *data = CPU_TRACE_DATA (cpu);
844 TRACE_IDX (data) = trace_idx;
846 save_data (sd, data, trace_fmt_fp, sizeof (double), &d);
848 save_data (sd, data, trace_fmt_fp, sizeof (double), &d);
852 trace_input_fpu3 (SIM_DESC sd,
860 TRACE_DATA *data = CPU_TRACE_DATA (cpu);
861 TRACE_IDX (data) = trace_idx;
863 save_data (sd, data, trace_fmt_fp, sizeof (double), &d);
865 save_data (sd, data, trace_fmt_fp, sizeof (double), &d);
867 save_data (sd, data, trace_fmt_fp, sizeof (double), &d);
871 trace_result_word1 (SIM_DESC sd,
876 TRACE_DATA *data = CPU_TRACE_DATA (cpu);
879 /* Append any results to the end of the inputs */
880 last_input = TRACE_INPUT_IDX (data);
881 save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &r0);
883 trace_results (sd, cpu, trace_idx, last_input);
887 trace_result0 (SIM_DESC sd,
891 TRACE_DATA *data = CPU_TRACE_DATA (cpu);
894 /* Append any results to the end of the inputs */
895 last_input = TRACE_INPUT_IDX (data);
897 trace_results (sd, cpu, trace_idx, last_input);
901 trace_result_word2 (SIM_DESC sd,
907 TRACE_DATA *data = CPU_TRACE_DATA (cpu);
910 /* Append any results to the end of the inputs */
911 last_input = TRACE_INPUT_IDX (data);
912 save_data (sd, data, trace_fmt_word, sizeof (r0), &r0);
913 save_data (sd, data, trace_fmt_word, sizeof (r1), &r1);
915 trace_results (sd, cpu, trace_idx, last_input);
919 trace_result_word4 (SIM_DESC sd,
927 TRACE_DATA *data = CPU_TRACE_DATA (cpu);
930 /* Append any results to the end of the inputs */
931 last_input = TRACE_INPUT_IDX (data);
932 save_data (sd, data, trace_fmt_word, sizeof (r0), &r0);
933 save_data (sd, data, trace_fmt_word, sizeof (r1), &r1);
934 save_data (sd, data, trace_fmt_word, sizeof (r2), &r2);
935 save_data (sd, data, trace_fmt_word, sizeof (r3), &r3);
937 trace_results (sd, cpu, trace_idx, last_input);
941 trace_result_bool1 (SIM_DESC sd,
946 TRACE_DATA *data = CPU_TRACE_DATA (cpu);
949 /* Append any results to the end of the inputs */
950 last_input = TRACE_INPUT_IDX (data);
951 save_data (sd, data, trace_fmt_bool, sizeof (r0), &r0);
953 trace_results (sd, cpu, trace_idx, last_input);
957 trace_result_addr1 (SIM_DESC sd,
962 TRACE_DATA *data = CPU_TRACE_DATA (cpu);
965 /* Append any results to the end of the inputs */
966 last_input = TRACE_INPUT_IDX (data);
967 save_data (sd, data, trace_fmt_addr, sizeof (r0), &r0);
969 trace_results (sd, cpu, trace_idx, last_input);
973 trace_result_fp1 (SIM_DESC sd,
978 TRACE_DATA *data = CPU_TRACE_DATA (cpu);
981 /* Append any results to the end of the inputs */
982 last_input = TRACE_INPUT_IDX (data);
983 save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f0);
985 trace_results (sd, cpu, trace_idx, last_input);
989 trace_result_fpu1 (SIM_DESC sd,
995 TRACE_DATA *data = CPU_TRACE_DATA (cpu);
998 /* Append any results to the end of the inputs */
999 last_input = TRACE_INPUT_IDX (data);
1000 d = sim_fpu_2d (f0);
1001 save_data (sd, data, trace_fmt_fp, sizeof (double), &d);
1003 trace_results (sd, cpu, trace_idx, last_input);
1007 trace_result_string1 (SIM_DESC sd,
1012 TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1015 /* Append any results to the end of the inputs */
1016 last_input = TRACE_INPUT_IDX (data);
1017 save_data (sd, data, trace_fmt_string, strlen (s0) + 1, s0);
1019 trace_results (sd, cpu, trace_idx, last_input);
1023 trace_result_word1_string1 (SIM_DESC sd,
1029 TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1032 /* Append any results to the end of the inputs */
1033 last_input = TRACE_INPUT_IDX (data);
1034 save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &r0);
1035 save_data (sd, data, trace_fmt_string, strlen (s0) + 1, s0);
1037 trace_results (sd, cpu, trace_idx, last_input);
1041 trace_vprintf (SIM_DESC sd, sim_cpu *cpu, const char *fmt, va_list ap)
1045 if (TRACE_FILE (CPU_TRACE_DATA (cpu)) != NULL)
1046 vfprintf (TRACE_FILE (CPU_TRACE_DATA (cpu)), fmt, ap);
1048 sim_io_evprintf (sd, fmt, ap);
1052 if (TRACE_FILE (STATE_TRACE_DATA (sd)) != NULL)
1053 vfprintf (TRACE_FILE (STATE_TRACE_DATA (sd)), fmt, ap);
1055 sim_io_evprintf (sd, fmt, ap);
1060 trace_one_insn (SIM_DESC sd, sim_cpu *cpu, address_word pc,
1061 int line_p, const char *filename, int linenum,
1062 const char *phase_wo_colon, const char *fmt,
1066 char phase[SIZE_PHASE+2];
1068 strncpy (phase, phase_wo_colon, SIZE_PHASE);
1069 strcat (phase, ":");
1073 trace_printf (sd, cpu, "%-*s %s:%-*d 0x%.*lx ",
1074 SIZE_PHASE+1, phase,
1076 SIZE_LINE_NUMBER, linenum,
1079 trace_vprintf (sd, cpu, fmt, ap);
1081 trace_printf (sd, cpu, "\n");
1088 if (STATE_TEXT_SECTION (CPU_STATE (cpu))
1089 && pc >= STATE_TEXT_START (CPU_STATE (cpu))
1090 && pc < STATE_TEXT_END (CPU_STATE (cpu)))
1092 const char *pc_filename = (const char *)0;
1093 const char *pc_function = (const char *)0;
1094 unsigned int pc_linenum = 0;
1096 if (bfd_find_nearest_line (STATE_PROG_BFD (CPU_STATE (cpu)),
1097 STATE_TEXT_SECTION (CPU_STATE (cpu)),
1098 (struct symbol_cache_entry **) 0,
1099 pc - STATE_TEXT_START (CPU_STATE (cpu)),
1100 &pc_filename, &pc_function, &pc_linenum))
1105 sprintf (p, "#%-*d ", SIZE_LINE_NUMBER, pc_linenum);
1110 sprintf (p, "%-*s ", SIZE_LINE_NUMBER+1, "---");
1111 p += SIZE_LINE_NUMBER+2;
1116 sprintf (p, "%s ", pc_function);
1119 else if (pc_filename)
1121 char *q = (char *) strrchr (pc_filename, '/');
1122 sprintf (p, "%s ", (q) ? q+1 : pc_filename);
1131 trace_printf (sd, cpu, "%-*s 0x%.*x %-*.*s ",
1132 SIZE_PHASE+1, phase,
1133 SIZE_PC, (unsigned) pc,
1134 SIZE_LOCATION, SIZE_LOCATION, buf);
1136 trace_vprintf (sd, cpu, fmt, ap);
1138 trace_printf (sd, cpu, "\n");
1143 trace_printf VPARAMS ((SIM_DESC sd, sim_cpu *cpu, const char *fmt, ...))
1145 #if !defined __STDC__ && !defined ALMOST_STDC
1153 #if !defined __STDC__ && !defined ALMOST_STDC
1154 sd = va_arg (ap, SIM_DESC);
1155 cpu = va_arg (ap, sim_cpu *);
1156 fmt = va_arg (ap, const char *);
1159 trace_vprintf (sd, cpu, fmt, ap);
1165 debug_printf VPARAMS ((sim_cpu *cpu, const char *fmt, ...))
1167 #if !defined __STDC__ && !defined ALMOST_STDC
1174 #if !defined __STDC__ && !defined ALMOST_STDC
1175 cpu = va_arg (ap, sim_cpu *);
1176 fmt = va_arg (ap, const char *);
1179 if (CPU_DEBUG_FILE (cpu) == NULL)
1180 (* STATE_CALLBACK (CPU_STATE (cpu))->evprintf_filtered)
1181 (STATE_CALLBACK (CPU_STATE (cpu)), fmt, ap);
1183 vfprintf (CPU_DEBUG_FILE (cpu), fmt, ap);