/* Simulator tracing/debugging support. Copyright (C) 1997, 1998, 2001 Free Software Foundation, Inc. Contributed by Cygnus Support. This file is part of GDB, the GNU debugger. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "sim-main.h" #include "sim-io.h" #include "sim-options.h" #include "sim-fpu.h" #include "bfd.h" #include "libiberty.h" #include "sim-assert.h" #ifdef HAVE_STRING_H #include #else #ifdef HAVE_STRINGS_H #include #endif #endif #ifdef HAVE_STDLIB_H #include #endif #ifndef SIZE_PHASE #define SIZE_PHASE 8 #endif #ifndef SIZE_LOCATION #define SIZE_LOCATION 20 #endif #ifndef SIZE_PC #define SIZE_PC 6 #endif #ifndef SIZE_LINE_NUMBER #define SIZE_LINE_NUMBER 4 #endif static MODULE_INIT_FN trace_init; static MODULE_UNINSTALL_FN trace_uninstall; static DECLARE_OPTION_HANDLER (trace_option_handler); enum { OPTION_TRACE_INSN = OPTION_START, OPTION_TRACE_DECODE, OPTION_TRACE_EXTRACT, OPTION_TRACE_LINENUM, OPTION_TRACE_MEMORY, OPTION_TRACE_MODEL, OPTION_TRACE_ALU, OPTION_TRACE_CORE, OPTION_TRACE_EVENTS, OPTION_TRACE_FPU, OPTION_TRACE_BRANCH, OPTION_TRACE_SEMANTICS, OPTION_TRACE_RANGE, OPTION_TRACE_FUNCTION, OPTION_TRACE_DEBUG, OPTION_TRACE_FILE, OPTION_TRACE_VPU }; static const OPTION trace_options[] = { /* This table is organized to group related instructions together. */ { {"trace", optional_argument, NULL, 't'}, 't', "on|off", "Trace useful things", trace_option_handler }, { {"trace-insn", optional_argument, NULL, OPTION_TRACE_INSN}, '\0', "on|off", "Perform instruction tracing", trace_option_handler }, { {"trace-decode", optional_argument, NULL, OPTION_TRACE_DECODE}, '\0', "on|off", "Trace instruction decoding", trace_option_handler }, { {"trace-extract", optional_argument, NULL, OPTION_TRACE_EXTRACT}, '\0', "on|off", "Trace instruction extraction", trace_option_handler }, { {"trace-linenum", optional_argument, NULL, OPTION_TRACE_LINENUM}, '\0', "on|off", "Perform line number tracing (implies --trace-insn)", trace_option_handler }, { {"trace-memory", optional_argument, NULL, OPTION_TRACE_MEMORY}, '\0', "on|off", "Trace memory operations", trace_option_handler }, { {"trace-alu", optional_argument, NULL, OPTION_TRACE_ALU}, '\0', "on|off", "Trace ALU operations", trace_option_handler }, { {"trace-fpu", optional_argument, NULL, OPTION_TRACE_FPU}, '\0', "on|off", "Trace FPU operations", trace_option_handler }, { {"trace-vpu", optional_argument, NULL, OPTION_TRACE_VPU}, '\0', "on|off", "Trace VPU operations", trace_option_handler }, { {"trace-branch", optional_argument, NULL, OPTION_TRACE_BRANCH}, '\0', "on|off", "Trace branching", trace_option_handler }, { {"trace-semantics", optional_argument, NULL, OPTION_TRACE_SEMANTICS}, '\0', "on|off", "Perform ALU, FPU, MEMORY, and BRANCH tracing", trace_option_handler }, { {"trace-model", optional_argument, NULL, OPTION_TRACE_MODEL}, '\0', "on|off", "Include model performance data", trace_option_handler }, { {"trace-core", optional_argument, NULL, OPTION_TRACE_CORE}, '\0', "on|off", "Trace core operations", trace_option_handler }, { {"trace-events", optional_argument, NULL, OPTION_TRACE_EVENTS}, '\0', "on|off", "Trace events", trace_option_handler }, #ifdef SIM_HAVE_ADDR_RANGE { {"trace-range", required_argument, NULL, OPTION_TRACE_RANGE}, '\0', "START,END", "Specify range of addresses for instruction tracing", trace_option_handler }, #if 0 /*wip*/ { {"trace-function", required_argument, NULL, OPTION_TRACE_FUNCTION}, '\0', "FUNCTION", "Specify function to trace", trace_option_handler }, #endif #endif { {"trace-debug", optional_argument, NULL, OPTION_TRACE_DEBUG}, '\0', "on|off", "Add information useful for debugging the simulator to the tracing output", trace_option_handler }, { {"trace-file", required_argument, NULL, OPTION_TRACE_FILE}, '\0', "FILE NAME", "Specify tracing output file", trace_option_handler }, { {NULL, no_argument, NULL, 0}, '\0', NULL, NULL, NULL } }; /* Set/reset the trace options indicated in MASK. */ static SIM_RC set_trace_option_mask (sd, name, mask, arg) SIM_DESC sd; const char *name; int mask; const char *arg; { int trace_nr; int cpu_nr; int trace_val = 1; if (arg != NULL) { if (strcmp (arg, "yes") == 0 || strcmp (arg, "on") == 0 || strcmp (arg, "1") == 0) trace_val = 1; else if (strcmp (arg, "no") == 0 || strcmp (arg, "off") == 0 || strcmp (arg, "0") == 0) trace_val = 0; else { sim_io_eprintf (sd, "Argument `%s' for `--trace%s' invalid, one of `on', `off', `yes', `no' expected\n", arg, name); return SIM_RC_FAIL; } } /* update applicable trace bits */ for (trace_nr = 0; trace_nr < MAX_TRACE_VALUES; ++trace_nr) { if ((mask & (1 << trace_nr)) == 0) continue; /* Set non-cpu specific values. */ switch (trace_nr) { case TRACE_EVENTS_IDX: STATE_EVENTS (sd)->trace = trace_val; break; case TRACE_DEBUG_IDX: STATE_TRACE_FLAGS (sd)[trace_nr] = trace_val; break; } /* Set cpu values. */ for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; cpu_nr++) { CPU_TRACE_FLAGS (STATE_CPU (sd, cpu_nr))[trace_nr] = trace_val; } } /* Re-compute the cpu trace summary. */ if (trace_val) { for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; cpu_nr++) CPU_TRACE_DATA (STATE_CPU (sd, cpu_nr))->trace_any_p = 1; } else { for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; cpu_nr++) { CPU_TRACE_DATA (STATE_CPU (sd, cpu_nr))->trace_any_p = 0; for (trace_nr = 0; trace_nr < MAX_TRACE_VALUES; ++trace_nr) { if (CPU_TRACE_FLAGS (STATE_CPU (sd, cpu_nr))[trace_nr]) { CPU_TRACE_DATA (STATE_CPU (sd, cpu_nr))->trace_any_p = 1; break; } } } } return SIM_RC_OK; } /* Set one trace option based on its IDX value. */ static SIM_RC set_trace_option (sd, name, idx, arg) SIM_DESC sd; const char *name; int idx; const char *arg; { return set_trace_option_mask (sd, name, 1 << idx, arg); } static SIM_RC trace_option_handler (SIM_DESC sd, sim_cpu *cpu, int opt, char *arg, int is_command) { int n; int cpu_nr; switch (opt) { case 't' : if (! WITH_TRACE) sim_io_eprintf (sd, "Tracing not compiled in, `-t' ignored\n"); else return set_trace_option_mask (sd, "trace", TRACE_USEFUL_MASK, arg); break; case OPTION_TRACE_INSN : if (WITH_TRACE_INSN_P) return set_trace_option (sd, "-insn", TRACE_INSN_IDX, arg); else sim_io_eprintf (sd, "Instruction tracing not compiled in, `--trace-insn' ignored\n"); break; case OPTION_TRACE_DECODE : if (WITH_TRACE_DECODE_P) return set_trace_option (sd, "-decode", TRACE_DECODE_IDX, arg); else sim_io_eprintf (sd, "Decode tracing not compiled in, `--trace-decode' ignored\n"); break; case OPTION_TRACE_EXTRACT : if (WITH_TRACE_EXTRACT_P) return set_trace_option (sd, "-extract", TRACE_EXTRACT_IDX, arg); else sim_io_eprintf (sd, "Extract tracing not compiled in, `--trace-extract' ignored\n"); break; case OPTION_TRACE_LINENUM : if (WITH_TRACE_LINENUM_P && WITH_TRACE_INSN_P) { if (set_trace_option (sd, "-linenum", TRACE_LINENUM_IDX, arg) != SIM_RC_OK || set_trace_option (sd, "-linenum", TRACE_INSN_IDX, arg) != SIM_RC_OK) return SIM_RC_FAIL; } else sim_io_eprintf (sd, "Line number or instruction tracing not compiled in, `--trace-linenum' ignored\n"); break; case OPTION_TRACE_MEMORY : if (WITH_TRACE_MEMORY_P) return set_trace_option (sd, "-memory", TRACE_MEMORY_IDX, arg); else sim_io_eprintf (sd, "Memory tracing not compiled in, `--trace-memory' ignored\n"); break; case OPTION_TRACE_MODEL : if (WITH_TRACE_MODEL_P) return set_trace_option (sd, "-model", TRACE_MODEL_IDX, arg); else sim_io_eprintf (sd, "Model tracing not compiled in, `--trace-model' ignored\n"); break; case OPTION_TRACE_ALU : if (WITH_TRACE_ALU_P) return set_trace_option (sd, "-alu", TRACE_ALU_IDX, arg); else sim_io_eprintf (sd, "ALU tracing not compiled in, `--trace-alu' ignored\n"); break; case OPTION_TRACE_CORE : if (WITH_TRACE_CORE_P) return set_trace_option (sd, "-core", TRACE_CORE_IDX, arg); else sim_io_eprintf (sd, "CORE tracing not compiled in, `--trace-core' ignored\n"); break; case OPTION_TRACE_EVENTS : if (WITH_TRACE_EVENTS_P) return set_trace_option (sd, "-events", TRACE_EVENTS_IDX, arg); else sim_io_eprintf (sd, "EVENTS tracing not compiled in, `--trace-events' ignored\n"); break; case OPTION_TRACE_FPU : if (WITH_TRACE_FPU_P) return set_trace_option (sd, "-fpu", TRACE_FPU_IDX, arg); else sim_io_eprintf (sd, "FPU tracing not compiled in, `--trace-fpu' ignored\n"); break; case OPTION_TRACE_VPU : if (WITH_TRACE_VPU_P) return set_trace_option (sd, "-vpu", TRACE_VPU_IDX, arg); else sim_io_eprintf (sd, "VPU tracing not compiled in, `--trace-vpu' ignored\n"); break; case OPTION_TRACE_BRANCH : if (WITH_TRACE_BRANCH_P) return set_trace_option (sd, "-branch", TRACE_BRANCH_IDX, arg); else sim_io_eprintf (sd, "Branch tracing not compiled in, `--trace-branch' ignored\n"); break; case OPTION_TRACE_SEMANTICS : if (WITH_TRACE_ALU_P && WITH_TRACE_FPU_P && WITH_TRACE_MEMORY_P && WITH_TRACE_BRANCH_P) { if (set_trace_option (sd, "-semantics", TRACE_ALU_IDX, arg) != SIM_RC_OK || set_trace_option (sd, "-semantics", TRACE_FPU_IDX, arg) != SIM_RC_OK || set_trace_option (sd, "-semantics", TRACE_VPU_IDX, arg) != SIM_RC_OK || set_trace_option (sd, "-semantics", TRACE_MEMORY_IDX, arg) != SIM_RC_OK || set_trace_option (sd, "-semantics", TRACE_BRANCH_IDX, arg) != SIM_RC_OK) return SIM_RC_FAIL; } else sim_io_eprintf (sd, "Alu, fpu, memory, and/or branch tracing not compiled in, `--trace-semantics' ignored\n"); break; #ifdef SIM_HAVE_ADDR_RANGE case OPTION_TRACE_RANGE : if (WITH_TRACE) { char *chp = arg; unsigned long start,end; start = strtoul (chp, &chp, 0); if (*chp != ',') { sim_io_eprintf (sd, "--trace-range missing END argument\n"); return SIM_RC_FAIL; } end = strtoul (chp + 1, NULL, 0); /* FIXME: Argument validation. */ if (cpu != NULL) sim_addr_range_add (TRACE_RANGE (CPU_PROFILE_DATA (cpu)), start, end); else for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; ++cpu_nr) sim_addr_range_add (TRACE_RANGE (CPU_TRACE_DATA (STATE_CPU (sd, cpu_nr))), start, end); } else sim_io_eprintf (sd, "Tracing not compiled in, `--trace-range' ignored\n"); break; case OPTION_TRACE_FUNCTION : if (WITH_TRACE) { /*wip: need to compute function range given name*/ } else sim_io_eprintf (sd, "Tracing not compiled in, `--trace-function' ignored\n"); break; #endif /* SIM_HAVE_ADDR_RANGE */ case OPTION_TRACE_DEBUG : if (WITH_TRACE_DEBUG_P) return set_trace_option (sd, "-debug", TRACE_DEBUG_IDX, arg); else sim_io_eprintf (sd, "Tracing debug support not compiled in, `--trace-debug' ignored\n"); break; case OPTION_TRACE_FILE : if (! WITH_TRACE) sim_io_eprintf (sd, "Tracing not compiled in, `--trace-file' ignored\n"); else { FILE *f = fopen (arg, "w"); if (f == NULL) { sim_io_eprintf (sd, "Unable to open trace output file `%s'\n", arg); return SIM_RC_FAIL; } for (n = 0; n < MAX_NR_PROCESSORS; ++n) TRACE_FILE (CPU_TRACE_DATA (STATE_CPU (sd, n))) = f; TRACE_FILE (STATE_TRACE_DATA (sd)) = f; } break; } return SIM_RC_OK; } /* Install tracing support. */ SIM_RC trace_install (SIM_DESC sd) { int i; SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); sim_add_option_table (sd, NULL, trace_options); memset (STATE_TRACE_DATA (sd), 0, sizeof (* STATE_TRACE_DATA (sd))); for (i = 0; i < MAX_NR_PROCESSORS; ++i) memset (CPU_TRACE_DATA (STATE_CPU (sd, i)), 0, sizeof (* CPU_TRACE_DATA (STATE_CPU (sd, i)))); sim_module_add_init_fn (sd, trace_init); sim_module_add_uninstall_fn (sd, trace_uninstall); return SIM_RC_OK; } static SIM_RC trace_init (SIM_DESC sd) { #ifdef SIM_HAVE_ADDR_RANGE /* Check if a range has been specified without specifying what to collect. */ { int i; for (i = 0; i < MAX_NR_PROCESSORS; ++i) { sim_cpu *cpu = STATE_CPU (sd, i); if (ADDR_RANGE_RANGES (TRACE_RANGE (CPU_TRACE_DATA (cpu))) && ! TRACE_INSN_P (cpu)) { sim_io_eprintf_cpu (cpu, "Tracing address range specified without --trace-insn.\n"); sim_io_eprintf_cpu (cpu, "Address range ignored.\n"); sim_addr_range_delete (TRACE_RANGE (CPU_TRACE_DATA (cpu)), 0, ~ (address_word) 0); } } } #endif return SIM_RC_OK; } static void trace_uninstall (SIM_DESC sd) { int i,j; FILE *sfile = TRACE_FILE (STATE_TRACE_DATA (sd)); if (sfile != NULL) fclose (sfile); for (i = 0; i < MAX_NR_PROCESSORS; ++i) { FILE *cfile = TRACE_FILE (CPU_TRACE_DATA (STATE_CPU (sd, i))); if (cfile != NULL && cfile != sfile) { /* If output from different cpus is going to the same file, avoid closing the file twice. */ for (j = 0; j < i; ++j) if (TRACE_FILE (CPU_TRACE_DATA (STATE_CPU (sd, j))) == cfile) break; if (i == j) fclose (cfile); } } } typedef enum { trace_fmt_invalid, trace_fmt_word, trace_fmt_fp, trace_fmt_fpu, trace_fmt_string, trace_fmt_bool, trace_fmt_addr, trace_fmt_instruction_incomplete, } data_fmt; /* compute the nr of trace data units consumed by data */ static int save_data_size (TRACE_DATA *data, long size) { return ((size + sizeof (TRACE_INPUT_DATA (data) [0]) - 1) / sizeof (TRACE_INPUT_DATA (data) [0])); } /* Archive DATA into the trace buffer */ static void save_data (SIM_DESC sd, TRACE_DATA *data, data_fmt fmt, long size, void *buf) { int i = TRACE_INPUT_IDX (data); if (i == sizeof (TRACE_INPUT_FMT (data))) sim_io_error (sd, "trace buffer overflow"); TRACE_INPUT_FMT (data) [i] = fmt; TRACE_INPUT_SIZE (data) [i] = size; memcpy (&TRACE_INPUT_DATA (data) [i], buf, size); i += save_data_size (data, size); TRACE_INPUT_IDX (data) = i; } static void print_data (SIM_DESC sd, sim_cpu *cpu, data_fmt fmt, long size, void *data) { switch (fmt) { case trace_fmt_instruction_incomplete: trace_printf (sd, cpu, " (instruction incomplete)"); break; case trace_fmt_word: case trace_fmt_addr: { switch (size) { case sizeof (unsigned32): trace_printf (sd, cpu, " 0x%08lx", (long) * (unsigned32*) data); break; case sizeof (unsigned64): trace_printf (sd, cpu, " 0x%08lx%08lx", (long) ((* (unsigned64*) data) >> 32), (long) * (unsigned64*) data); break; default: abort (); } break; } case trace_fmt_bool: { SIM_ASSERT (size == sizeof (int)); trace_printf (sd, cpu, " %-8s", (* (int*) data) ? "true" : "false"); break; } case trace_fmt_fp: { sim_fpu fp; switch (size) { /* FIXME: Assumes sizeof float == 4; sizeof double == 8 */ case 4: sim_fpu_32to (&fp, *(unsigned32*)data); break; case 8: sim_fpu_64to (&fp, *(unsigned64*)data); break; default: abort (); } trace_printf (sd, cpu, " %8g", sim_fpu_2d (&fp)); switch (size) { case 4: trace_printf (sd, cpu, " (0x%08lx)", (long) *(unsigned32*)data); break; case 8: trace_printf (sd, cpu, " (0x%08lx%08lx)", (long) (*(unsigned64*)data >> 32), (long) (*(unsigned64*)data)); break; default: abort (); } break; } case trace_fmt_fpu: /* FIXME: At present sim_fpu data is stored as a double */ trace_printf (sd, cpu, " %8g", * (double*) data); break; case trace_fmt_string: trace_printf (sd, cpu, " %-8s", (char*) data); break; default: abort (); } } static const char * trace_idx_to_str (int trace_idx) { static char num[8]; switch (trace_idx) { case TRACE_ALU_IDX: return "alu: "; case TRACE_INSN_IDX: return "insn: "; case TRACE_DECODE_IDX: return "decode: "; case TRACE_EXTRACT_IDX: return "extract: "; case TRACE_MEMORY_IDX: return "memory: "; case TRACE_CORE_IDX: return "core: "; case TRACE_EVENTS_IDX: return "events: "; case TRACE_FPU_IDX: return "fpu: "; case TRACE_BRANCH_IDX: return "branch: "; case TRACE_VPU_IDX: return "vpu: "; default: sprintf (num, "?%d?", trace_idx); return num; } } static void trace_results (SIM_DESC sd, sim_cpu *cpu, int trace_idx, int last_input) { TRACE_DATA *data = CPU_TRACE_DATA (cpu); int nr_out; int i; /* cross check trace_idx against TRACE_IDX (data)? */ /* prefix */ trace_printf (sd, cpu, "%s %s", trace_idx_to_str (TRACE_IDX (data)), TRACE_PREFIX (data)); TRACE_IDX (data) = 0; for (i = 0, nr_out = 0; i < TRACE_INPUT_IDX (data); i += save_data_size (data, TRACE_INPUT_SIZE (data) [i]), nr_out++) { if (i == last_input) { int pad = (strlen (" 0x") + sizeof (unsigned_word) * 2); int padding = pad * (3 - nr_out); if (padding < 0) padding = 0; padding += strlen (" ::"); trace_printf (sd, cpu, "%*s", padding, " ::"); } print_data (sd, cpu, TRACE_INPUT_FMT (data) [i], TRACE_INPUT_SIZE (data) [i], &TRACE_INPUT_DATA (data) [i]); } trace_printf (sd, cpu, "\n"); } void trace_prefix (SIM_DESC sd, sim_cpu *cpu, sim_cia cia, address_word pc, int line_p, const char *filename, int linenum, const char *fmt, ...) { TRACE_DATA *data = CPU_TRACE_DATA (cpu); va_list ap; char *prefix = TRACE_PREFIX (data); char *chp; /* FIXME: The TRACE_PREFIX_WIDTH should be determined at build time using known information about the disassembled instructions. */ #ifndef TRACE_PREFIX_WIDTH #define TRACE_PREFIX_WIDTH 48 #endif int width = TRACE_PREFIX_WIDTH; /* if the previous trace data wasn't flushed, flush it now with a note indicating that the trace was incomplete. */ if (TRACE_IDX (data) != 0) { int last_input = TRACE_INPUT_IDX (data); save_data (sd, data, trace_fmt_instruction_incomplete, 1, ""); trace_results (sd, cpu, TRACE_IDX (data), last_input); } TRACE_IDX (data) = 0; TRACE_INPUT_IDX (data) = 0; /* Create the text prefix for this new instruction: */ if (!line_p) { if (filename) { sprintf (prefix, "%s:%-*d 0x%.*lx ", filename, SIZE_LINE_NUMBER, linenum, SIZE_PC, (long) pc); } else { sprintf (prefix, "0x%.*lx ", SIZE_PC, (long) pc); /* Shrink the width by the amount that we didn't print. */ width -= SIZE_LINE_NUMBER + SIZE_PC + 8; } chp = strchr (prefix, '\0'); va_start (ap, fmt); vsprintf (chp, fmt, ap); va_end (ap); } else { char buf[256]; buf[0] = 0; if (STATE_TEXT_SECTION (CPU_STATE (cpu)) && pc >= STATE_TEXT_START (CPU_STATE (cpu)) && pc < STATE_TEXT_END (CPU_STATE (cpu))) { const char *pc_filename = (const char *)0; const char *pc_function = (const char *)0; unsigned int pc_linenum = 0; bfd *abfd; asymbol **asymbols; abfd = STATE_PROG_BFD (CPU_STATE (cpu)); asymbols = STATE_PROG_SYMS (CPU_STATE (cpu)); if (asymbols == NULL) { long symsize; long symbol_count; symsize = bfd_get_symtab_upper_bound (abfd); if (symsize < 0) { sim_engine_abort (sd, cpu, cia, "could not read symbols"); } asymbols = (asymbol **) xmalloc (symsize); symbol_count = bfd_canonicalize_symtab (abfd, asymbols); if (symbol_count < 0) { sim_engine_abort (sd, cpu, cia, "could not canonicalize symbols"); } STATE_PROG_SYMS (CPU_STATE (cpu)) = asymbols; } if (bfd_find_nearest_line (abfd, STATE_TEXT_SECTION (CPU_STATE (cpu)), asymbols, pc - STATE_TEXT_START (CPU_STATE (cpu)), &pc_filename, &pc_function, &pc_linenum)) { char *p = buf; if (pc_linenum) { sprintf (p, "#%-*d ", SIZE_LINE_NUMBER, pc_linenum); p += strlen (p); } else { sprintf (p, "%-*s ", SIZE_LINE_NUMBER+1, "---"); p += SIZE_LINE_NUMBER+2; } if (pc_function) { sprintf (p, "%s ", pc_function); p += strlen (p); } else if (pc_filename) { char *q = (char *) strrchr (pc_filename, '/'); sprintf (p, "%s ", (q) ? q+1 : pc_filename); p += strlen (p); } if (*p == ' ') *p = '\0'; } } sprintf (prefix, "0x%.*x %-*.*s ", SIZE_PC, (unsigned) pc, SIZE_LOCATION, SIZE_LOCATION, buf); chp = strchr (prefix, '\0'); va_start (ap, fmt); vsprintf (chp, fmt, ap); va_end (ap); } /* Pad it out to TRACE_PREFIX_WIDTH. */ chp = strchr (prefix, '\0'); if (chp - prefix < width) { memset (chp, ' ', width - (chp - prefix)); chp = &prefix [width]; *chp = '\0'; } strcpy (chp, " -"); /* check that we've not over flowed the prefix buffer */ if (strlen (prefix) >= sizeof (TRACE_PREFIX (data))) abort (); } void trace_generic (SIM_DESC sd, sim_cpu *cpu, int trace_idx, const char *fmt, ...) { va_list ap; trace_printf (sd, cpu, "%s %s", trace_idx_to_str (trace_idx), TRACE_PREFIX (CPU_TRACE_DATA (cpu))); va_start (ap, fmt); trace_vprintf (sd, cpu, fmt, ap); va_end (ap); trace_printf (sd, cpu, "\n"); } void trace_input0 (SIM_DESC sd, sim_cpu *cpu, int trace_idx) { TRACE_DATA *data = CPU_TRACE_DATA (cpu); TRACE_IDX (data) = trace_idx; } void trace_input_word1 (SIM_DESC sd, sim_cpu *cpu, int trace_idx, unsigned_word d0) { TRACE_DATA *data = CPU_TRACE_DATA (cpu); TRACE_IDX (data) = trace_idx; save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &d0); } void trace_input_word2 (SIM_DESC sd, sim_cpu *cpu, int trace_idx, unsigned_word d0, unsigned_word d1) { TRACE_DATA *data = CPU_TRACE_DATA (cpu); TRACE_IDX (data) = trace_idx; save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &d0); save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &d1); } void trace_input_word3 (SIM_DESC sd, sim_cpu *cpu, int trace_idx, unsigned_word d0, unsigned_word d1, unsigned_word d2) { TRACE_DATA *data = CPU_TRACE_DATA (cpu); TRACE_IDX (data) = trace_idx; save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &d0); save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &d1); save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &d2); } void trace_input_word4 (SIM_DESC sd, sim_cpu *cpu, int trace_idx, unsigned_word d0, unsigned_word d1, unsigned_word d2, unsigned_word d3) { TRACE_DATA *data = CPU_TRACE_DATA (cpu); TRACE_IDX (data) = trace_idx; save_data (sd, data, trace_fmt_word, sizeof (d0), &d0); save_data (sd, data, trace_fmt_word, sizeof (d1), &d1); save_data (sd, data, trace_fmt_word, sizeof (d2), &d2); save_data (sd, data, trace_fmt_word, sizeof (d3), &d3); } void trace_input_bool1 (SIM_DESC sd, sim_cpu *cpu, int trace_idx, int d0) { TRACE_DATA *data = CPU_TRACE_DATA (cpu); TRACE_IDX (data) = trace_idx; save_data (sd, data, trace_fmt_bool, sizeof (d0), &d0); } void trace_input_addr1 (SIM_DESC sd, sim_cpu *cpu, int trace_idx, address_word d0) { TRACE_DATA *data = CPU_TRACE_DATA (cpu); TRACE_IDX (data) = trace_idx; save_data (sd, data, trace_fmt_addr, sizeof (d0), &d0); } void trace_input_fp1 (SIM_DESC sd, sim_cpu *cpu, int trace_idx, fp_word f0) { TRACE_DATA *data = CPU_TRACE_DATA (cpu); TRACE_IDX (data) = trace_idx; save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f0); } void trace_input_fp2 (SIM_DESC sd, sim_cpu *cpu, int trace_idx, fp_word f0, fp_word f1) { TRACE_DATA *data = CPU_TRACE_DATA (cpu); TRACE_IDX (data) = trace_idx; save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f0); save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f1); } void trace_input_fp3 (SIM_DESC sd, sim_cpu *cpu, int trace_idx, fp_word f0, fp_word f1, fp_word f2) { TRACE_DATA *data = CPU_TRACE_DATA (cpu); TRACE_IDX (data) = trace_idx; save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f0); save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f1); save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f2); } void trace_input_fpu1 (SIM_DESC sd, sim_cpu *cpu, int trace_idx, sim_fpu *f0) { double d; TRACE_DATA *data = CPU_TRACE_DATA (cpu); TRACE_IDX (data) = trace_idx; d = sim_fpu_2d (f0); save_data (sd, data, trace_fmt_fp, sizeof (double), &d); } void trace_input_fpu2 (SIM_DESC sd, sim_cpu *cpu, int trace_idx, sim_fpu *f0, sim_fpu *f1) { double d; TRACE_DATA *data = CPU_TRACE_DATA (cpu); TRACE_IDX (data) = trace_idx; d = sim_fpu_2d (f0); save_data (sd, data, trace_fmt_fp, sizeof (double), &d); d = sim_fpu_2d (f1); save_data (sd, data, trace_fmt_fp, sizeof (double), &d); } void trace_input_fpu3 (SIM_DESC sd, sim_cpu *cpu, int trace_idx, sim_fpu *f0, sim_fpu *f1, sim_fpu *f2) { double d; TRACE_DATA *data = CPU_TRACE_DATA (cpu); TRACE_IDX (data) = trace_idx; d = sim_fpu_2d (f0); save_data (sd, data, trace_fmt_fp, sizeof (double), &d); d = sim_fpu_2d (f1); save_data (sd, data, trace_fmt_fp, sizeof (double), &d); d = sim_fpu_2d (f2); save_data (sd, data, trace_fmt_fp, sizeof (double), &d); } void trace_result_word1 (SIM_DESC sd, sim_cpu *cpu, int trace_idx, unsigned_word r0) { TRACE_DATA *data = CPU_TRACE_DATA (cpu); int last_input; /* Append any results to the end of the inputs */ last_input = TRACE_INPUT_IDX (data); save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &r0); trace_results (sd, cpu, trace_idx, last_input); } void trace_result0 (SIM_DESC sd, sim_cpu *cpu, int trace_idx) { TRACE_DATA *data = CPU_TRACE_DATA (cpu); int last_input; /* Append any results to the end of the inputs */ last_input = TRACE_INPUT_IDX (data); trace_results (sd, cpu, trace_idx, last_input); } void trace_result_word2 (SIM_DESC sd, sim_cpu *cpu, int trace_idx, unsigned_word r0, unsigned_word r1) { TRACE_DATA *data = CPU_TRACE_DATA (cpu); int last_input; /* Append any results to the end of the inputs */ last_input = TRACE_INPUT_IDX (data); save_data (sd, data, trace_fmt_word, sizeof (r0), &r0); save_data (sd, data, trace_fmt_word, sizeof (r1), &r1); trace_results (sd, cpu, trace_idx, last_input); } void trace_result_word4 (SIM_DESC sd, sim_cpu *cpu, int trace_idx, unsigned_word r0, unsigned_word r1, unsigned_word r2, unsigned_word r3) { TRACE_DATA *data = CPU_TRACE_DATA (cpu); int last_input; /* Append any results to the end of the inputs */ last_input = TRACE_INPUT_IDX (data); save_data (sd, data, trace_fmt_word, sizeof (r0), &r0); save_data (sd, data, trace_fmt_word, sizeof (r1), &r1); save_data (sd, data, trace_fmt_word, sizeof (r2), &r2); save_data (sd, data, trace_fmt_word, sizeof (r3), &r3); trace_results (sd, cpu, trace_idx, last_input); } void trace_result_bool1 (SIM_DESC sd, sim_cpu *cpu, int trace_idx, int r0) { TRACE_DATA *data = CPU_TRACE_DATA (cpu); int last_input; /* Append any results to the end of the inputs */ last_input = TRACE_INPUT_IDX (data); save_data (sd, data, trace_fmt_bool, sizeof (r0), &r0); trace_results (sd, cpu, trace_idx, last_input); } void trace_result_addr1 (SIM_DESC sd, sim_cpu *cpu, int trace_idx, address_word r0) { TRACE_DATA *data = CPU_TRACE_DATA (cpu); int last_input; /* Append any results to the end of the inputs */ last_input = TRACE_INPUT_IDX (data); save_data (sd, data, trace_fmt_addr, sizeof (r0), &r0); trace_results (sd, cpu, trace_idx, last_input); } void trace_result_fp1 (SIM_DESC sd, sim_cpu *cpu, int trace_idx, fp_word f0) { TRACE_DATA *data = CPU_TRACE_DATA (cpu); int last_input; /* Append any results to the end of the inputs */ last_input = TRACE_INPUT_IDX (data); save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f0); trace_results (sd, cpu, trace_idx, last_input); } void trace_result_fp2 (SIM_DESC sd, sim_cpu *cpu, int trace_idx, fp_word f0, fp_word f1) { TRACE_DATA *data = CPU_TRACE_DATA (cpu); int last_input; /* Append any results to the end of the inputs */ last_input = TRACE_INPUT_IDX (data); save_data (sd, data, trace_fmt_fp, sizeof (f0), &f0); save_data (sd, data, trace_fmt_fp, sizeof (f1), &f1); trace_results (sd, cpu, trace_idx, last_input); } void trace_result_fpu1 (SIM_DESC sd, sim_cpu *cpu, int trace_idx, sim_fpu *f0) { double d; TRACE_DATA *data = CPU_TRACE_DATA (cpu); int last_input; /* Append any results to the end of the inputs */ last_input = TRACE_INPUT_IDX (data); d = sim_fpu_2d (f0); save_data (sd, data, trace_fmt_fp, sizeof (double), &d); trace_results (sd, cpu, trace_idx, last_input); } void trace_result_string1 (SIM_DESC sd, sim_cpu *cpu, int trace_idx, char *s0) { TRACE_DATA *data = CPU_TRACE_DATA (cpu); int last_input; /* Append any results to the end of the inputs */ last_input = TRACE_INPUT_IDX (data); save_data (sd, data, trace_fmt_string, strlen (s0) + 1, s0); trace_results (sd, cpu, trace_idx, last_input); } void trace_result_word1_string1 (SIM_DESC sd, sim_cpu *cpu, int trace_idx, unsigned_word r0, char *s0) { TRACE_DATA *data = CPU_TRACE_DATA (cpu); int last_input; /* Append any results to the end of the inputs */ last_input = TRACE_INPUT_IDX (data); save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &r0); save_data (sd, data, trace_fmt_string, strlen (s0) + 1, s0); trace_results (sd, cpu, trace_idx, last_input); } void trace_vprintf (SIM_DESC sd, sim_cpu *cpu, const char *fmt, va_list ap) { if (cpu != NULL) { if (TRACE_FILE (CPU_TRACE_DATA (cpu)) != NULL) vfprintf (TRACE_FILE (CPU_TRACE_DATA (cpu)), fmt, ap); else sim_io_evprintf (sd, fmt, ap); } else { if (TRACE_FILE (STATE_TRACE_DATA (sd)) != NULL) vfprintf (TRACE_FILE (STATE_TRACE_DATA (sd)), fmt, ap); else sim_io_evprintf (sd, fmt, ap); } } /* The function trace_one_insn has been replaced by the function pair trace_prefix() + trace_generic(). It is still used. */ void trace_one_insn (SIM_DESC sd, sim_cpu *cpu, address_word pc, int line_p, const char *filename, int linenum, const char *phase_wo_colon, const char *fmt, ...) { va_list ap; char phase[SIZE_PHASE+2]; strncpy (phase, phase_wo_colon, SIZE_PHASE); strcat (phase, ":"); if (!line_p) { trace_printf (sd, cpu, "%-*s %s:%-*d 0x%.*lx ", SIZE_PHASE+1, phase, filename, SIZE_LINE_NUMBER, linenum, SIZE_PC, (long)pc); va_start (ap, fmt); trace_vprintf (sd, cpu, fmt, ap); va_end (ap); trace_printf (sd, cpu, "\n"); } else { char buf[256]; buf[0] = 0; if (STATE_TEXT_SECTION (CPU_STATE (cpu)) && pc >= STATE_TEXT_START (CPU_STATE (cpu)) && pc < STATE_TEXT_END (CPU_STATE (cpu))) { const char *pc_filename = (const char *)0; const char *pc_function = (const char *)0; unsigned int pc_linenum = 0; if (bfd_find_nearest_line (STATE_PROG_BFD (CPU_STATE (cpu)), STATE_TEXT_SECTION (CPU_STATE (cpu)), (struct bfd_symbol **) 0, pc - STATE_TEXT_START (CPU_STATE (cpu)), &pc_filename, &pc_function, &pc_linenum)) { char *p = buf; if (pc_linenum) { sprintf (p, "#%-*d ", SIZE_LINE_NUMBER, pc_linenum); p += strlen (p); } else { sprintf (p, "%-*s ", SIZE_LINE_NUMBER+1, "---"); p += SIZE_LINE_NUMBER+2; } if (pc_function) { sprintf (p, "%s ", pc_function); p += strlen (p); } else if (pc_filename) { char *q = (char *) strrchr (pc_filename, '/'); sprintf (p, "%s ", (q) ? q+1 : pc_filename); p += strlen (p); } if (*p == ' ') *p = '\0'; } } trace_printf (sd, cpu, "%-*s 0x%.*x %-*.*s ", SIZE_PHASE+1, phase, SIZE_PC, (unsigned) pc, SIZE_LOCATION, SIZE_LOCATION, buf); va_start (ap, fmt); trace_vprintf (sd, cpu, fmt, ap); va_end (ap); trace_printf (sd, cpu, "\n"); } } void trace_printf VPARAMS ((SIM_DESC sd, sim_cpu *cpu, const char *fmt, ...)) { #if !defined __STDC__ && !defined ALMOST_STDC SIM_DESC sd; sim_cpu *cpu; const char *fmt; #endif va_list ap; VA_START (ap, fmt); #if !defined __STDC__ && !defined ALMOST_STDC sd = va_arg (ap, SIM_DESC); cpu = va_arg (ap, sim_cpu *); fmt = va_arg (ap, const char *); #endif trace_vprintf (sd, cpu, fmt, ap); va_end (ap); } void debug_printf VPARAMS ((sim_cpu *cpu, const char *fmt, ...)) { #if !defined __STDC__ && !defined ALMOST_STDC sim_cpu *cpu; const char *fmt; #endif va_list ap; VA_START (ap, fmt); #if !defined __STDC__ && !defined ALMOST_STDC cpu = va_arg (ap, sim_cpu *); fmt = va_arg (ap, const char *); #endif if (CPU_DEBUG_FILE (cpu) == NULL) (* STATE_CALLBACK (CPU_STATE (cpu))->evprintf_filtered) (STATE_CALLBACK (CPU_STATE (cpu)), fmt, ap); else vfprintf (CPU_DEBUG_FILE (cpu), fmt, ap); va_end (ap); }