Initial creation of sourceware repositorygdb-4_18-branchpoint

1 files changed, 1341 insertions, 0 deletions

diff --git a/sim/common/sim-trace.c b/sim/common/sim-trace.c
new file mode 100644
index 0000000..0fa2313
--- /dev/null
+++ b/sim/common/sim-trace.c
@@ -0,0 +1,1341 @@
+/* Simulator tracing/debugging support.
+   Copyright (C) 1997, 1998 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 <string.h>
+#else
+#ifdef HAVE_STRINGS_H
+#include <strings.h>
+#endif
+#endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#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
+};
+
+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-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_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_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:  ";
+    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 symbol_cache_entry **) 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);
+}