sim/common/sim-trace.c

   1 /* Simulator tracing/debugging support.
   2    Copyright (C) 1997-2021 Free Software Foundation, Inc.
   3    Contributed by Cygnus Support.
   4
   5 This file is part of GDB, the GNU debugger.
   6
   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.
  11
  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.
  16
  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/>.  */
  19
  20 /* This must come before any other includes.  */
  21 #include "defs.h"
  22
  23 #include "sim-main.h"
  24 #include "sim-io.h"
  25 #include "sim-options.h"
  26 #include "sim-fpu.h"
  27 #include "sim/callback.h"
  28
  29 #include "bfd.h"
  30 #include "libiberty.h"
  31
  32 #include "dis-asm.h"
  33
  34 #include "sim-assert.h"
  35
  36 #include <string.h>
  37 #include <stdlib.h>
  38
  39 #ifndef SIZE_PHASE
  40 #define SIZE_PHASE 8
  41 #endif
  42
  43 #ifndef SIZE_LOCATION
  44 #define SIZE_LOCATION 20
  45 #endif
  46
  47 #ifndef SIZE_PC
  48 #define SIZE_PC 6
  49 #endif
  50
  51 #ifndef SIZE_LINE_NUMBER
  52 #define SIZE_LINE_NUMBER 4
  53 #endif
  54
  55 static MODULE_INIT_FN trace_init;
  56 static MODULE_UNINSTALL_FN trace_uninstall;
  57
  58 static DECLARE_OPTION_HANDLER (trace_option_handler);
  59
  60 enum {
  61   OPTION_TRACE_INSN     = OPTION_START,
  62   OPTION_TRACE_DISASM,
  63   OPTION_TRACE_DECODE,
  64   OPTION_TRACE_EXTRACT,
  65   OPTION_TRACE_LINENUM,
  66   OPTION_TRACE_MEMORY,
  67   OPTION_TRACE_MODEL,
  68   OPTION_TRACE_ALU,
  69   OPTION_TRACE_CORE,
  70   OPTION_TRACE_EVENTS,
  71   OPTION_TRACE_FPU,
  72   OPTION_TRACE_BRANCH,
  73   OPTION_TRACE_SEMANTICS,
  74   OPTION_TRACE_RANGE,
  75   OPTION_TRACE_FUNCTION,
  76   OPTION_TRACE_DEBUG,
  77   OPTION_TRACE_FILE,
  78   OPTION_TRACE_VPU,
  79   OPTION_TRACE_SYSCALL,
  80   OPTION_TRACE_REGISTER
  81 };
  82
  83 static const OPTION trace_options[] =
  84 {
  85   /* This table is organized to group related instructions together.  */
  86   { {"trace", optional_argument, NULL, 't'},
  87       't', "on|off", "Trace useful things",
  88       trace_option_handler, NULL },
  89   { {"trace-insn", optional_argument, NULL, OPTION_TRACE_INSN},
  90       '\0', "on|off", "Perform instruction tracing",
  91       trace_option_handler, NULL },
  92   { {"trace-disasm", optional_argument, NULL, OPTION_TRACE_DISASM},
  93       '\0', "on|off", "Disassemble instructions (slower, but more accurate)",
  94       trace_option_handler, NULL },
  95   { {"trace-decode", optional_argument, NULL, OPTION_TRACE_DECODE},
  96       '\0', "on|off", "Trace instruction decoding",
  97       trace_option_handler, NULL },
  98   { {"trace-extract", optional_argument, NULL, OPTION_TRACE_EXTRACT},
  99       '\0', "on|off", "Trace instruction extraction",
 100       trace_option_handler, NULL },
 101   { {"trace-linenum", optional_argument, NULL, OPTION_TRACE_LINENUM},
 102       '\0', "on|off", "Perform line number tracing (implies --trace-insn)",
 103       trace_option_handler, NULL },
 104   { {"trace-memory", optional_argument, NULL, OPTION_TRACE_MEMORY},
 105       '\0', "on|off", "Trace memory operations",
 106       trace_option_handler, NULL },
 107   { {"trace-alu", optional_argument, NULL, OPTION_TRACE_ALU},
 108       '\0', "on|off", "Trace ALU (Arithmetic Logic Unit) operations",
 109       trace_option_handler, NULL },
 110   { {"trace-fpu", optional_argument, NULL, OPTION_TRACE_FPU},
 111       '\0', "on|off", "Trace FPU (Floating Point Unit) operations",
 112       trace_option_handler, NULL },
 113   { {"trace-vpu", optional_argument, NULL, OPTION_TRACE_VPU},
 114       '\0', "on|off", "Trace VPU (Vector Processing Unit) operations",
 115       trace_option_handler, NULL },
 116   { {"trace-branch", optional_argument, NULL, OPTION_TRACE_BRANCH},
 117       '\0', "on|off", "Trace branching",
 118       trace_option_handler, NULL },
 119   { {"trace-semantics", optional_argument, NULL, OPTION_TRACE_SEMANTICS},
 120       '\0', "on|off", "Perform ALU, FPU, VPU, MEMORY, and BRANCH tracing",
 121       trace_option_handler, NULL },
 122   { {"trace-model", optional_argument, NULL, OPTION_TRACE_MODEL},
 123       '\0', "on|off", "Include model performance data",
 124       trace_option_handler, NULL },
 125   { {"trace-core", optional_argument, NULL, OPTION_TRACE_CORE},
 126       '\0', "on|off", "Trace core operations",
 127       trace_option_handler, NULL },
 128   { {"trace-events", optional_argument, NULL, OPTION_TRACE_EVENTS},
 129       '\0', "on|off", "Trace events",
 130       trace_option_handler, NULL },
 131   { {"trace-syscall", optional_argument, NULL, OPTION_TRACE_SYSCALL},
 132       '\0', "on|off", "Trace system calls",
 133       trace_option_handler, NULL },
 134   { {"trace-register", optional_argument, NULL, OPTION_TRACE_REGISTER},
 135       '\0', "on|off", "Trace cpu register accesses",
 136       trace_option_handler, NULL },
 137 #ifdef SIM_HAVE_ADDR_RANGE
 138   { {"trace-range", required_argument, NULL, OPTION_TRACE_RANGE},
 139       '\0', "START,END", "Specify range of addresses for instruction tracing",
 140       trace_option_handler, NULL },
 141 #if 0 /*wip*/
 142   { {"trace-function", required_argument, NULL, OPTION_TRACE_FUNCTION},
 143       '\0', "FUNCTION", "Specify function to trace",
 144       trace_option_handler, NULL },
 145 #endif
 146 #endif
 147   { {"trace-debug", optional_argument, NULL, OPTION_TRACE_DEBUG},
 148       '\0', "on|off", "Add information useful for debugging the simulator to the tracing output",
 149       trace_option_handler, NULL },
 150   { {"trace-file", required_argument, NULL, OPTION_TRACE_FILE},
 151       '\0', "FILE NAME", "Specify tracing output file",
 152       trace_option_handler, NULL },
 153   { {NULL, no_argument, NULL, 0}, '\0', NULL, NULL, NULL, NULL }
 154 };
 155
 156 /* Set/reset the trace options indicated in MASK.  */
 157
 158 static SIM_RC
 159 set_trace_option_mask (SIM_DESC sd, const char *name, int mask, const char *arg)
 160 {
 161   int trace_nr;
 162   int cpu_nr;
 163   int trace_val = 1;
 164
 165   if (arg != NULL)
 166     {
 167       if (strcmp (arg, "yes") == 0
 168           || strcmp (arg, "on") == 0
 169           || strcmp (arg, "1") == 0)
 170         trace_val = 1;
 171       else if (strcmp (arg, "no") == 0
 172                || strcmp (arg, "off") == 0
 173                || strcmp (arg, "0") == 0)
 174         trace_val = 0;
 175       else
 176         {
 177           sim_io_eprintf (sd, "Argument `%s' for `--trace%s' invalid, one of `on', `off', `yes', `no' expected\n", arg, name);
 178           return SIM_RC_FAIL;
 179         }
 180     }
 181
 182   /* Update applicable trace bits.  */
 183   for (trace_nr = 0; trace_nr < MAX_TRACE_VALUES; ++trace_nr)
 184     {
 185       if ((mask & (1 << trace_nr)) == 0)
 186         continue;
 187
 188       /* Set non-cpu specific values.  */
 189       STATE_TRACE_FLAGS (sd)[trace_nr] = trace_val;
 190
 191       /* Set cpu values.  */
 192       for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; cpu_nr++)
 193         {
 194           CPU_TRACE_FLAGS (STATE_CPU (sd, cpu_nr))[trace_nr] = trace_val;
 195         }
 196     }
 197
 198   /* Re-compute the cpu trace summary.  */
 199   if (trace_val)
 200     {
 201       for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; cpu_nr++)
 202         CPU_TRACE_DATA (STATE_CPU (sd, cpu_nr))->trace_any_p = 1;
 203     }
 204   else
 205     {
 206       for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; cpu_nr++)
 207         {
 208           CPU_TRACE_DATA (STATE_CPU (sd, cpu_nr))->trace_any_p = 0;
 209           for (trace_nr = 0; trace_nr < MAX_TRACE_VALUES; ++trace_nr)
 210             {
 211               if (CPU_TRACE_FLAGS (STATE_CPU (sd, cpu_nr))[trace_nr])
 212                 {
 213                   CPU_TRACE_DATA (STATE_CPU (sd, cpu_nr))->trace_any_p = 1;
 214                   break;
 215                 }
 216             }
 217         }
 218     }
 219
 220   return SIM_RC_OK;
 221 }
 222
 223 /* Set one trace option based on its IDX value.  */
 224
 225 static SIM_RC
 226 set_trace_option (SIM_DESC sd, const char *name, int idx, const char *arg)
 227 {
 228   return set_trace_option_mask (sd, name, 1 << idx, arg);
 229 }
 230
 231
 232 static SIM_RC
 233 trace_option_handler (SIM_DESC sd, sim_cpu *cpu, int opt,
 234                       char *arg, int is_command)
 235 {
 236   int n;
 237
 238   switch (opt)
 239     {
 240     case 't' :
 241       if (!WITH_TRACE_ANY_P)
 242         sim_io_eprintf (sd, "Tracing not compiled in, `-t' ignored\n");
 243       else
 244         return set_trace_option_mask (sd, "trace", TRACE_USEFUL_MASK, arg);
 245       break;
 246
 247     case OPTION_TRACE_INSN :
 248       if (WITH_TRACE_INSN_P)
 249         return set_trace_option (sd, "-insn", TRACE_INSN_IDX, arg);
 250       else
 251         sim_io_eprintf (sd, "Instruction tracing not compiled in, `--trace-insn' ignored\n");
 252       break;
 253
 254     case OPTION_TRACE_DISASM :
 255       if (WITH_TRACE_DISASM_P)
 256         return set_trace_option (sd, "-disasm", TRACE_DISASM_IDX, arg);
 257       else
 258         sim_io_eprintf (sd, "Instruction tracing not compiled in, `--trace-disasm' ignored\n");
 259       break;
 260
 261     case OPTION_TRACE_DECODE :
 262       if (WITH_TRACE_DECODE_P)
 263         return set_trace_option (sd, "-decode", TRACE_DECODE_IDX, arg);
 264       else
 265         sim_io_eprintf (sd, "Decode tracing not compiled in, `--trace-decode' ignored\n");
 266       break;
 267
 268     case OPTION_TRACE_EXTRACT :
 269       if (WITH_TRACE_EXTRACT_P)
 270         return set_trace_option (sd, "-extract", TRACE_EXTRACT_IDX, arg);
 271       else
 272         sim_io_eprintf (sd, "Extract tracing not compiled in, `--trace-extract' ignored\n");
 273       break;
 274
 275     case OPTION_TRACE_LINENUM :
 276       if (WITH_TRACE_LINENUM_P && WITH_TRACE_INSN_P)
 277         {
 278           if (set_trace_option (sd, "-linenum", TRACE_LINENUM_IDX, arg) != SIM_RC_OK
 279               || set_trace_option (sd, "-linenum", TRACE_INSN_IDX, arg) != SIM_RC_OK)
 280             return SIM_RC_FAIL;
 281         }
 282       else
 283         sim_io_eprintf (sd, "Line number or instruction tracing not compiled in, `--trace-linenum' ignored\n");
 284       break;
 285
 286     case OPTION_TRACE_MEMORY :
 287       if (WITH_TRACE_MEMORY_P)
 288         return set_trace_option (sd, "-memory", TRACE_MEMORY_IDX, arg);
 289       else
 290         sim_io_eprintf (sd, "Memory tracing not compiled in, `--trace-memory' ignored\n");
 291       break;
 292
 293     case OPTION_TRACE_MODEL :
 294       if (WITH_TRACE_MODEL_P)
 295         return set_trace_option (sd, "-model", TRACE_MODEL_IDX, arg);
 296       else
 297         sim_io_eprintf (sd, "Model tracing not compiled in, `--trace-model' ignored\n");
 298       break;
 299
 300     case OPTION_TRACE_ALU :
 301       if (WITH_TRACE_ALU_P)
 302         return set_trace_option (sd, "-alu", TRACE_ALU_IDX, arg);
 303       else
 304         sim_io_eprintf (sd, "ALU tracing not compiled in, `--trace-alu' ignored\n");
 305       break;
 306
 307     case OPTION_TRACE_CORE :
 308       if (WITH_TRACE_CORE_P)
 309         return set_trace_option (sd, "-core", TRACE_CORE_IDX, arg);
 310       else
 311         sim_io_eprintf (sd, "CORE tracing not compiled in, `--trace-core' ignored\n");
 312       break;
 313
 314     case OPTION_TRACE_EVENTS :
 315       if (WITH_TRACE_EVENTS_P)
 316         return set_trace_option (sd, "-events", TRACE_EVENTS_IDX, arg);
 317       else
 318         sim_io_eprintf (sd, "EVENTS tracing not compiled in, `--trace-events' ignored\n");
 319       break;
 320
 321     case OPTION_TRACE_FPU :
 322       if (WITH_TRACE_FPU_P)
 323         return set_trace_option (sd, "-fpu", TRACE_FPU_IDX, arg);
 324       else
 325         sim_io_eprintf (sd, "FPU tracing not compiled in, `--trace-fpu' ignored\n");
 326       break;
 327
 328     case OPTION_TRACE_VPU :
 329       if (WITH_TRACE_VPU_P)
 330         return set_trace_option (sd, "-vpu", TRACE_VPU_IDX, arg);
 331       else
 332         sim_io_eprintf (sd, "VPU tracing not compiled in, `--trace-vpu' ignored\n");
 333       break;
 334
 335     case OPTION_TRACE_BRANCH :
 336       if (WITH_TRACE_BRANCH_P)
 337         return set_trace_option (sd, "-branch", TRACE_BRANCH_IDX, arg);
 338       else
 339         sim_io_eprintf (sd, "Branch tracing not compiled in, `--trace-branch' ignored\n");
 340       break;
 341
 342     case OPTION_TRACE_SYSCALL :
 343       if (WITH_TRACE_SYSCALL_P)
 344         return set_trace_option (sd, "-syscall", TRACE_SYSCALL_IDX, arg);
 345       else
 346         sim_io_eprintf (sd, "System call tracing not compiled in, `--trace-syscall' ignored\n");
 347       break;
 348
 349     case OPTION_TRACE_REGISTER :
 350       if (WITH_TRACE_REGISTER_P)
 351         return set_trace_option (sd, "-register", TRACE_REGISTER_IDX, arg);
 352       else
 353         sim_io_eprintf (sd, "Register tracing not compiled in, `--trace-register' ignored\n");
 354       break;
 355
 356     case OPTION_TRACE_SEMANTICS :
 357       if (WITH_TRACE_ALU_P
 358           && WITH_TRACE_FPU_P
 359           && WITH_TRACE_MEMORY_P
 360           && WITH_TRACE_BRANCH_P)
 361         {
 362           if (set_trace_option (sd, "-semantics", TRACE_ALU_IDX, arg) != SIM_RC_OK
 363               || set_trace_option (sd, "-semantics", TRACE_FPU_IDX, arg) != SIM_RC_OK
 364               || set_trace_option (sd, "-semantics", TRACE_VPU_IDX, arg) != SIM_RC_OK
 365               || set_trace_option (sd, "-semantics", TRACE_MEMORY_IDX, arg) != SIM_RC_OK
 366               || set_trace_option (sd, "-semantics", TRACE_BRANCH_IDX, arg) != SIM_RC_OK)
 367             return SIM_RC_FAIL;
 368         }
 369       else
 370         sim_io_eprintf (sd, "Alu, fpu, memory, and/or branch tracing not compiled in, `--trace-semantics' ignored\n");
 371       break;
 372
 373 #ifdef SIM_HAVE_ADDR_RANGE
 374     case OPTION_TRACE_RANGE :
 375       if (WITH_TRACE_ANY_P)
 376         {
 377           int cpu_nr;
 378           char *chp = arg;
 379           unsigned long start,end;
 380           start = strtoul (chp, &chp, 0);
 381           if (*chp != ',')
 382             {
 383               sim_io_eprintf (sd, "--trace-range missing END argument\n");
 384               return SIM_RC_FAIL;
 385             }
 386           end = strtoul (chp + 1, NULL, 0);
 387           /* FIXME: Argument validation.  */
 388           if (cpu != NULL)
 389             sim_addr_range_add (TRACE_RANGE (CPU_PROFILE_DATA (cpu)),
 390                                 start, end);
 391           else
 392             for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; ++cpu_nr)
 393               sim_addr_range_add (TRACE_RANGE (CPU_TRACE_DATA (STATE_CPU (sd, cpu_nr))),
 394                                   start, end);
 395         }
 396       else
 397         sim_io_eprintf (sd, "Tracing not compiled in, `--trace-range' ignored\n");
 398       break;
 399
 400     case OPTION_TRACE_FUNCTION :
 401       if (WITH_TRACE_ANY_P)
 402         {
 403           /*wip: need to compute function range given name*/
 404         }
 405       else
 406         sim_io_eprintf (sd, "Tracing not compiled in, `--trace-function' ignored\n");
 407       break;
 408 #endif /* SIM_HAVE_ADDR_RANGE */
 409
 410     case OPTION_TRACE_DEBUG :
 411       if (WITH_TRACE_DEBUG_P)
 412         return set_trace_option (sd, "-debug", TRACE_DEBUG_IDX, arg);
 413       else
 414         sim_io_eprintf (sd, "Tracing debug support not compiled in, `--trace-debug' ignored\n");
 415       break;
 416
 417     case OPTION_TRACE_FILE :
 418       if (!WITH_TRACE_ANY_P)
 419         sim_io_eprintf (sd, "Tracing not compiled in, `--trace-file' ignored\n");
 420       else
 421         {
 422           FILE *f = fopen (arg, "w");
 423
 424           if (f == NULL)
 425             {
 426               sim_io_eprintf (sd, "Unable to open trace output file `%s'\n", arg);
 427               return SIM_RC_FAIL;
 428             }
 429           for (n = 0; n < MAX_NR_PROCESSORS; ++n)
 430             TRACE_FILE (CPU_TRACE_DATA (STATE_CPU (sd, n))) = f;
 431           TRACE_FILE (STATE_TRACE_DATA (sd)) = f;
 432         }
 433       break;
 434     }
 435
 436   return SIM_RC_OK;
 437 }
 438 \f
 439 /* Provide a prototype to silence -Wmissing-prototypes.  */
 440 SIM_RC sim_install_trace (SIM_DESC sd);
 441
 442 /* Install tracing support.  */
 443 SIM_RC
 444 sim_install_trace (SIM_DESC sd)
 445 {
 446   int i;
 447
 448   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 449
 450   sim_add_option_table (sd, NULL, trace_options);
 451   memset (STATE_TRACE_DATA (sd), 0, sizeof (* STATE_TRACE_DATA (sd)));
 452   for (i = 0; i < MAX_NR_PROCESSORS; ++i)
 453     memset (CPU_TRACE_DATA (STATE_CPU (sd, i)), 0,
 454             sizeof (* CPU_TRACE_DATA (STATE_CPU (sd, i))));
 455   sim_module_add_init_fn (sd, trace_init);
 456   sim_module_add_uninstall_fn (sd, trace_uninstall);
 457   return SIM_RC_OK;
 458 }
 459
 460 static SIM_RC
 461 trace_init (SIM_DESC sd)
 462 {
 463 #ifdef SIM_HAVE_ADDR_RANGE
 464   /* Check if a range has been specified without specifying what to
 465      collect.  */
 466   {
 467     int i;
 468
 469     for (i = 0; i < MAX_NR_PROCESSORS; ++i)
 470       {
 471         sim_cpu *cpu = STATE_CPU (sd, i);
 472
 473         if (ADDR_RANGE_RANGES (TRACE_RANGE (CPU_TRACE_DATA (cpu)))
 474             && ! TRACE_INSN_P (cpu))
 475           {
 476             sim_io_eprintf_cpu (cpu, "Tracing address range specified without --trace-insn.\n");
 477             sim_io_eprintf_cpu (cpu, "Address range ignored.\n");
 478             sim_addr_range_delete (TRACE_RANGE (CPU_TRACE_DATA (cpu)),
 479                                    0, ~ (address_word) 0);
 480           }
 481       }
 482   }
 483 #endif
 484
 485   return SIM_RC_OK;
 486 }
 487
 488 static void
 489 trace_uninstall (SIM_DESC sd)
 490 {
 491   int i,j;
 492   FILE *sfile = TRACE_FILE (STATE_TRACE_DATA (sd));
 493
 494   if (sfile != NULL)
 495     fclose (sfile);
 496
 497   for (i = 0; i < MAX_NR_PROCESSORS; ++i)
 498     {
 499       FILE *cfile = TRACE_FILE (CPU_TRACE_DATA (STATE_CPU (sd, i)));
 500       if (cfile != NULL && cfile != sfile)
 501         {
 502           /* If output from different cpus is going to the same file,
 503              avoid closing the file twice.  */
 504           for (j = 0; j < i; ++j)
 505             if (TRACE_FILE (CPU_TRACE_DATA (STATE_CPU (sd, j))) == cfile)
 506               break;
 507           if (i == j)
 508             fclose (cfile);
 509         }
 510     }
 511
 512   if (STATE_PROG_SYMS (sd))
 513     free (STATE_PROG_SYMS (sd));
 514 }
 515 \f
 516 /* compute the nr of trace data units consumed by data */
 517 static int
 518 save_data_size (TRACE_DATA *data,
 519                 long size)
 520 {
 521   return ((size + sizeof (TRACE_INPUT_DATA (data) [0]) - 1)
 522           / sizeof (TRACE_INPUT_DATA (data) [0]));
 523 }
 524
 525
 526 /* Archive DATA into the trace buffer */
 527 void
 528 save_data (SIM_DESC sd,
 529            TRACE_DATA *data,
 530            data_fmt fmt,
 531            long size,
 532            const void *buf)
 533 {
 534   int i = TRACE_INPUT_IDX (data);
 535   if (i == sizeof (TRACE_INPUT_FMT (data)))
 536     sim_io_error (sd, "trace buffer overflow");
 537   TRACE_INPUT_FMT (data) [i] = fmt;
 538   TRACE_INPUT_SIZE (data) [i] = size;
 539   memcpy (&TRACE_INPUT_DATA (data) [i], buf, size);
 540   i += save_data_size (data, size);
 541   TRACE_INPUT_IDX (data) = i;
 542 }
 543
 544 static void
 545 print_data (SIM_DESC sd,
 546             sim_cpu *cpu,
 547             data_fmt fmt,
 548             long size,
 549             void *data)
 550 {
 551   switch (fmt)
 552     {
 553     case trace_fmt_instruction_incomplete:
 554       trace_printf (sd, cpu, " (instruction incomplete)");
 555       break;
 556     case trace_fmt_word:
 557     case trace_fmt_addr:
 558       {
 559         switch (size)
 560           {
 561           case sizeof (unsigned32):
 562             trace_printf (sd, cpu, " 0x%08lx", (long) * (unsigned32*) data);
 563             break;
 564           case sizeof (unsigned64):
 565             trace_printf (sd, cpu, " 0x%08lx%08lx",
 566                           (long) ((* (unsigned64*) data) >> 32),
 567                           (long) * (unsigned64*) data);
 568             break;
 569           default:
 570             abort ();
 571           }
 572         break;
 573       }
 574     case trace_fmt_bool:
 575       {
 576         SIM_ASSERT (size == sizeof (int));
 577         trace_printf (sd, cpu, " %-8s",
 578                       (* (int*) data) ? "true" : "false");
 579         break;
 580       }
 581     case trace_fmt_fp:
 582       {
 583         sim_fpu fp;
 584         switch (size)
 585           {
 586             /* FIXME: Assumes sizeof float == 4; sizeof double == 8 */
 587           case 4:
 588             sim_fpu_32to (&fp, *(unsigned32*)data);
 589             break;
 590           case 8:
 591             sim_fpu_64to (&fp, *(unsigned64*)data);
 592             break;
 593           default:
 594             abort ();
 595           }
 596         trace_printf (sd, cpu, " %8g", sim_fpu_2d (&fp));
 597         switch (size)
 598           {
 599           case 4:
 600             trace_printf (sd, cpu, " (0x%08lx)",
 601                           (long) *(unsigned32*)data);
 602             break;
 603           case 8:
 604             trace_printf (sd, cpu, " (0x%08lx%08lx)",
 605                           (long) (*(unsigned64*)data >> 32),
 606                           (long) (*(unsigned64*)data));
 607             break;
 608           default:
 609             abort ();
 610           }
 611         break;
 612       }
 613     case trace_fmt_fpu:
 614       /* FIXME: At present sim_fpu data is stored as a double */
 615       trace_printf (sd, cpu, " %8g", * (double*) data);
 616       break;
 617     case trace_fmt_string:
 618       trace_printf (sd, cpu, " %-8s", (char*) data);
 619       break;
 620     default:
 621       abort ();
 622     }
 623 }
 624
 625 static const char *
 626 trace_idx_to_str (int trace_idx)
 627 {
 628   static char num[8];
 629   switch (trace_idx)
 630     {
 631     case TRACE_ALU_IDX:      return "alu:     ";
 632     case TRACE_INSN_IDX:     return "insn:    ";
 633     case TRACE_DISASM_IDX:   return "disasm:  ";
 634     case TRACE_DECODE_IDX:   return "decode:  ";
 635     case TRACE_EXTRACT_IDX:  return "extract: ";
 636     case TRACE_MEMORY_IDX:   return "memory:  ";
 637     case TRACE_CORE_IDX:     return "core:    ";
 638     case TRACE_EVENTS_IDX:   return "events:  ";
 639     case TRACE_FPU_IDX:      return "fpu:     ";
 640     case TRACE_BRANCH_IDX:   return "branch:  ";
 641     case TRACE_SYSCALL_IDX:  return "syscall: ";
 642     case TRACE_REGISTER_IDX: return "reg:     ";
 643     case TRACE_VPU_IDX:      return "vpu:     ";
 644     default:
 645       sprintf (num, "?%d?", trace_idx);
 646       return num;
 647     }
 648 }
 649
 650 static void
 651 trace_results (SIM_DESC sd,
 652                sim_cpu *cpu,
 653                int trace_idx,
 654                int last_input)
 655 {
 656   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
 657   int nr_out;
 658   int i;
 659
 660   /* cross check trace_idx against TRACE_IDX (data)? */
 661
 662   /* prefix */
 663   trace_printf (sd, cpu, "%s %s",
 664                 trace_idx_to_str (TRACE_IDX (data)),
 665                 TRACE_PREFIX (data));
 666   TRACE_IDX (data) = 0;
 667
 668   for (i = 0, nr_out = 0;
 669        i < TRACE_INPUT_IDX (data);
 670        i += save_data_size (data, TRACE_INPUT_SIZE (data) [i]), nr_out++)
 671     {
 672       if (i == last_input)
 673         {
 674           int pad = (strlen (" 0x") + sizeof (unsigned_word) * 2);
 675           int padding = pad * (3 - nr_out);
 676           if (padding < 0)
 677             padding = 0;
 678           padding += strlen (" ::");
 679           trace_printf (sd, cpu, "%*s", padding, " ::");
 680         }
 681       print_data (sd, cpu,
 682                   TRACE_INPUT_FMT (data) [i],
 683                   TRACE_INPUT_SIZE (data) [i],
 684                   &TRACE_INPUT_DATA (data) [i]);
 685     }
 686   trace_printf (sd, cpu, "\n");
 687 }
 688
 689 int
 690 trace_load_symbols (SIM_DESC sd)
 691 {
 692   bfd *abfd;
 693   asymbol **asymbols;
 694   long symsize;
 695   long symbol_count;
 696
 697   /* Already loaded, so nothing to do.  */
 698   if (STATE_PROG_SYMS (sd))
 699     return 1;
 700
 701   abfd = STATE_PROG_BFD (sd);
 702   if (abfd == NULL)
 703     return 0;
 704
 705   symsize = bfd_get_symtab_upper_bound (abfd);
 706   if (symsize < 0)
 707     return 0;
 708
 709   asymbols = xmalloc (symsize);
 710   symbol_count = bfd_canonicalize_symtab (abfd, asymbols);
 711   if (symbol_count < 0)
 712     {
 713       free (asymbols);
 714       return 0;
 715     }
 716
 717   STATE_PROG_SYMS (sd) = asymbols;
 718   STATE_PROG_SYMS_COUNT (sd) = symbol_count;
 719   return 1;
 720 }
 721
 722 bfd_vma
 723 trace_sym_value (SIM_DESC sd, const char *name)
 724 {
 725   asymbol **asymbols;
 726   long i;
 727
 728   if (!trace_load_symbols (sd))
 729     return -1;
 730
 731   asymbols = STATE_PROG_SYMS (sd);
 732
 733   for (i = 0; i < STATE_PROG_SYMS_COUNT (sd); ++i)
 734     if (strcmp (asymbols[i]->name, name) == 0)
 735       return bfd_asymbol_value (asymbols[i]);
 736
 737   return -1;
 738 }
 739
 740 void
 741 trace_prefix (SIM_DESC sd,
 742               sim_cpu *cpu,
 743               sim_cia cia,
 744               address_word pc,
 745               int line_p,
 746               const char *filename,
 747               int linenum,
 748               const char *fmt,
 749               ...)
 750 {
 751   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
 752   va_list ap;
 753   char *prefix = TRACE_PREFIX (data);
 754   char *chp;
 755  /* FIXME: The TRACE_PREFIX_WIDTH should be determined at build time using
 756     known information about the disassembled instructions. */
 757 #ifndef TRACE_PREFIX_WIDTH
 758 #define TRACE_PREFIX_WIDTH 48
 759 #endif
 760   int width = TRACE_PREFIX_WIDTH;
 761
 762   /* if the previous trace data wasn't flushed, flush it now with a
 763      note indicating that the trace was incomplete. */
 764   if (TRACE_IDX (data) != 0)
 765     {
 766       int last_input = TRACE_INPUT_IDX (data);
 767       save_data (sd, data, trace_fmt_instruction_incomplete, 1, "");
 768       trace_results (sd, cpu, TRACE_IDX (data), last_input);
 769     }
 770   TRACE_IDX (data) = 0;
 771   TRACE_INPUT_IDX (data) = 0;
 772
 773   /* Create the text prefix for this new instruction: */
 774   if (!line_p)
 775     {
 776       if (filename)
 777         {
 778           sprintf (prefix, "%s:%-*d 0x%.*lx ",
 779                    filename,
 780                    SIZE_LINE_NUMBER, linenum,
 781                    SIZE_PC, (long) pc);
 782         }
 783       else
 784         {
 785           sprintf (prefix, "0x%.*lx ",
 786                    SIZE_PC, (long) pc);
 787           /* Shrink the width by the amount that we didn't print.  */
 788           width -= SIZE_LINE_NUMBER + SIZE_PC + 8;
 789         }
 790       chp = strchr (prefix, '\0');
 791       va_start (ap, fmt);
 792       vsprintf (chp, fmt, ap);
 793       va_end (ap);
 794     }
 795   else
 796     {
 797       char buf[256];
 798       buf[0] = 0;
 799       if (STATE_TEXT_SECTION (sd)
 800           && pc >= STATE_TEXT_START (sd)
 801           && pc < STATE_TEXT_END (sd))
 802         {
 803           const char *pc_filename = (const char *)0;
 804           const char *pc_function = (const char *)0;
 805           unsigned int pc_linenum = 0;
 806           bfd *abfd;
 807           asymbol **asymbols;
 808
 809           if (!trace_load_symbols (sd))
 810             sim_engine_abort (sd, cpu, cia, "could not load symbols");
 811
 812           abfd = STATE_PROG_BFD (sd);
 813           asymbols = STATE_PROG_SYMS (sd);
 814
 815           if (bfd_find_nearest_line (abfd, STATE_TEXT_SECTION (sd), asymbols,
 816                                      pc - STATE_TEXT_START (sd),
 817                                      &pc_filename, &pc_function, &pc_linenum))
 818             {
 819               char *p = buf;
 820               if (pc_linenum)
 821                 {
 822                   sprintf (p, "#%-*d ", SIZE_LINE_NUMBER, pc_linenum);
 823                   p += strlen (p);
 824                 }
 825               else
 826                 {
 827                   sprintf (p, "%-*s ", SIZE_LINE_NUMBER+1, "---");
 828                   p += SIZE_LINE_NUMBER+2;
 829                 }
 830
 831               if (pc_function)
 832                 {
 833                   sprintf (p, "%s ", pc_function);
 834                   p += strlen (p);
 835                 }
 836               else if (pc_filename)
 837                 {
 838                   char *q = (char *) strrchr (pc_filename, '/');
 839                   sprintf (p, "%s ", (q) ? q+1 : pc_filename);
 840                   p += strlen (p);
 841                 }
 842
 843               if (*p == ' ')
 844                 *p = '\0';
 845             }
 846         }
 847
 848       sprintf (prefix, "0x%.*x %-*.*s ",
 849                SIZE_PC, (unsigned) pc,
 850                SIZE_LOCATION, SIZE_LOCATION, buf);
 851       chp = strchr (prefix, '\0');
 852       va_start (ap, fmt);
 853       vsprintf (chp, fmt, ap);
 854       va_end (ap);
 855     }
 856
 857   /* Pad it out to TRACE_PREFIX_WIDTH.  */
 858   chp = strchr (prefix, '\0');
 859   if (chp - prefix < width)
 860     {
 861       memset (chp, ' ', width - (chp - prefix));
 862       chp = &prefix [width];
 863       *chp = '\0';
 864     }
 865   strcpy (chp, " -");
 866
 867   /* check that we've not over flowed the prefix buffer */
 868   if (strlen (prefix) >= sizeof (TRACE_PREFIX (data)))
 869     abort ();
 870 }
 871
 872 void
 873 trace_generic (SIM_DESC sd,
 874                sim_cpu *cpu,
 875                int trace_idx,
 876                const char *fmt,
 877                ...)
 878 {
 879   va_list ap;
 880   trace_printf (sd, cpu, "%s %s",
 881                 trace_idx_to_str (trace_idx),
 882                 TRACE_PREFIX (CPU_TRACE_DATA (cpu)));
 883   va_start (ap, fmt);
 884   trace_vprintf (sd, cpu, fmt, ap);
 885   va_end (ap);
 886   trace_printf (sd, cpu, "\n");
 887 }
 888
 889 static int
 890 dis_read (bfd_vma memaddr, bfd_byte *myaddr, unsigned int length,
 891           struct disassemble_info *dinfo)
 892 {
 893   SIM_CPU *cpu = dinfo->application_data;
 894   sim_core_read_buffer (CPU_STATE (cpu), cpu, NULL_CIA, myaddr, memaddr, length);
 895   return 0;
 896 }
 897
 898 static int ATTRIBUTE_PRINTF (2, 3)
 899 dis_printf (SIM_CPU *cpu, const char *fmt, ...)
 900 {
 901   SIM_DESC sd = CPU_STATE (cpu);
 902   va_list ap;
 903   va_start (ap, fmt);
 904   trace_vprintf (sd, cpu, fmt, ap);
 905   va_end (ap);
 906   return 0;
 907 }
 908
 909 void
 910 trace_disasm (SIM_DESC sd, sim_cpu *cpu, address_word addr)
 911 {
 912   struct bfd *bfd = STATE_PROG_BFD (sd);
 913   TRACE_DATA *trace_data = CPU_TRACE_DATA (cpu);
 914   disassemble_info *info = &trace_data->dis_info;
 915
 916   /* See if we need to set up the disassembly func.  */
 917   if (trace_data->dis_bfd != bfd)
 918     {
 919       trace_data->dis_bfd = bfd;
 920       trace_data->disassembler
 921         = disassembler (bfd_get_arch (trace_data->dis_bfd),
 922                         bfd_big_endian (trace_data->dis_bfd),
 923                         bfd_get_mach (trace_data->dis_bfd),
 924                         trace_data->dis_bfd);
 925       INIT_DISASSEMBLE_INFO (*info, cpu, dis_printf);
 926       info->read_memory_func = dis_read;
 927       info->arch = bfd_get_arch (bfd);
 928       info->mach = bfd_get_mach (bfd);
 929       disassemble_init_for_target (info);
 930     }
 931
 932   info->application_data = cpu;
 933
 934   trace_printf (sd, cpu, "%s %s",
 935                 trace_idx_to_str (TRACE_DISASM_IDX),
 936                 TRACE_PREFIX (trace_data));
 937   trace_data->disassembler (addr, info);
 938   trace_printf (sd, cpu, "\n");
 939 }
 940
 941 void
 942 trace_input0 (SIM_DESC sd,
 943               sim_cpu *cpu,
 944               int trace_idx)
 945 {
 946   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
 947   TRACE_IDX (data) = trace_idx;
 948 }
 949
 950 void
 951 trace_input_word1 (SIM_DESC sd,
 952                    sim_cpu *cpu,
 953                    int trace_idx,
 954                    unsigned_word d0)
 955 {
 956   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
 957   TRACE_IDX (data) = trace_idx;
 958   save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &d0);
 959 }
 960
 961 void
 962 trace_input_word2 (SIM_DESC sd,
 963                    sim_cpu *cpu,
 964                    int trace_idx,
 965                    unsigned_word d0,
 966                    unsigned_word d1)
 967 {
 968   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
 969   TRACE_IDX (data) = trace_idx;
 970   save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &d0);
 971   save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &d1);
 972 }
 973
 974 void
 975 trace_input_word3 (SIM_DESC sd,
 976                    sim_cpu *cpu,
 977                    int trace_idx,
 978                    unsigned_word d0,
 979                    unsigned_word d1,
 980                    unsigned_word d2)
 981 {
 982   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
 983   TRACE_IDX (data) = trace_idx;
 984   save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &d0);
 985   save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &d1);
 986   save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &d2);
 987 }
 988
 989 void
 990 trace_input_word4 (SIM_DESC sd,
 991                    sim_cpu *cpu,
 992                    int trace_idx,
 993                    unsigned_word d0,
 994                    unsigned_word d1,
 995                    unsigned_word d2,
 996                    unsigned_word d3)
 997 {
 998   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
 999   TRACE_IDX (data) = trace_idx;
1000   save_data (sd, data, trace_fmt_word, sizeof (d0), &d0);
1001   save_data (sd, data, trace_fmt_word, sizeof (d1), &d1);
1002   save_data (sd, data, trace_fmt_word, sizeof (d2), &d2);
1003   save_data (sd, data, trace_fmt_word, sizeof (d3), &d3);
1004 }
1005
1006 void
1007 trace_input_bool1 (SIM_DESC sd,
1008                    sim_cpu *cpu,
1009                    int trace_idx,
1010                    int d0)
1011 {
1012   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1013   TRACE_IDX (data) = trace_idx;
1014   save_data (sd, data, trace_fmt_bool, sizeof (d0), &d0);
1015 }
1016
1017 void
1018 trace_input_addr1 (SIM_DESC sd,
1019                    sim_cpu *cpu,
1020                    int trace_idx,
1021                    address_word d0)
1022 {
1023   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1024   TRACE_IDX (data) = trace_idx;
1025   save_data (sd, data, trace_fmt_addr, sizeof (d0), &d0);
1026 }
1027
1028 void
1029 trace_input_fp1 (SIM_DESC sd,
1030                  sim_cpu *cpu,
1031                  int trace_idx,
1032                  fp_word f0)
1033 {
1034   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1035   TRACE_IDX (data) = trace_idx;
1036   save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f0);
1037 }
1038
1039 void
1040 trace_input_fp2 (SIM_DESC sd,
1041                  sim_cpu *cpu,
1042                  int trace_idx,
1043                  fp_word f0,
1044                  fp_word f1)
1045 {
1046   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1047   TRACE_IDX (data) = trace_idx;
1048   save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f0);
1049   save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f1);
1050 }
1051
1052 void
1053 trace_input_fp3 (SIM_DESC sd,
1054                  sim_cpu *cpu,
1055                  int trace_idx,
1056                  fp_word f0,
1057                  fp_word f1,
1058                  fp_word f2)
1059 {
1060   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1061   TRACE_IDX (data) = trace_idx;
1062   save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f0);
1063   save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f1);
1064   save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f2);
1065 }
1066
1067 void
1068 trace_input_fpu1 (SIM_DESC sd,
1069                   sim_cpu *cpu,
1070                   int trace_idx,
1071                   sim_fpu *f0)
1072 {
1073   double d;
1074   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1075   TRACE_IDX (data) = trace_idx;
1076   d = sim_fpu_2d (f0);
1077   save_data (sd, data, trace_fmt_fp, sizeof (double), &d);
1078 }
1079
1080 void
1081 trace_input_fpu2 (SIM_DESC sd,
1082                   sim_cpu *cpu,
1083                   int trace_idx,
1084                   sim_fpu *f0,
1085                   sim_fpu *f1)
1086 {
1087   double d;
1088   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1089   TRACE_IDX (data) = trace_idx;
1090   d = sim_fpu_2d (f0);
1091   save_data (sd, data, trace_fmt_fp, sizeof (double), &d);
1092   d = sim_fpu_2d (f1);
1093   save_data (sd, data, trace_fmt_fp, sizeof (double), &d);
1094 }
1095
1096 void
1097 trace_input_fpu3 (SIM_DESC sd,
1098                   sim_cpu *cpu,
1099                   int trace_idx,
1100                   sim_fpu *f0,
1101                   sim_fpu *f1,
1102                   sim_fpu *f2)
1103 {
1104   double d;
1105   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1106   TRACE_IDX (data) = trace_idx;
1107   d = sim_fpu_2d (f0);
1108   save_data (sd, data, trace_fmt_fp, sizeof (double), &d);
1109   d = sim_fpu_2d (f1);
1110   save_data (sd, data, trace_fmt_fp, sizeof (double), &d);
1111   d = sim_fpu_2d (f2);
1112   save_data (sd, data, trace_fmt_fp, sizeof (double), &d);
1113 }
1114
1115 void
1116 trace_result_word1 (SIM_DESC sd,
1117                     sim_cpu *cpu,
1118                     int trace_idx,
1119                     unsigned_word r0)
1120 {
1121   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1122   int last_input;
1123
1124   /* Append any results to the end of the inputs */
1125   last_input = TRACE_INPUT_IDX (data);
1126   save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &r0);
1127
1128   trace_results (sd, cpu, trace_idx, last_input);
1129 }
1130
1131 void
1132 trace_result0 (SIM_DESC sd,
1133                sim_cpu *cpu,
1134                int trace_idx)
1135 {
1136   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1137   int last_input;
1138
1139   /* Append any results to the end of the inputs */
1140   last_input = TRACE_INPUT_IDX (data);
1141
1142   trace_results (sd, cpu, trace_idx, last_input);
1143 }
1144
1145 void
1146 trace_result_word2 (SIM_DESC sd,
1147                     sim_cpu *cpu,
1148                     int trace_idx,
1149                     unsigned_word r0,
1150                     unsigned_word r1)
1151 {
1152   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1153   int last_input;
1154
1155   /* Append any results to the end of the inputs */
1156   last_input = TRACE_INPUT_IDX (data);
1157   save_data (sd, data, trace_fmt_word, sizeof (r0), &r0);
1158   save_data (sd, data, trace_fmt_word, sizeof (r1), &r1);
1159
1160   trace_results (sd, cpu, trace_idx, last_input);
1161 }
1162
1163 void
1164 trace_result_word4 (SIM_DESC sd,
1165                     sim_cpu *cpu,
1166                     int trace_idx,
1167                     unsigned_word r0,
1168                     unsigned_word r1,
1169                     unsigned_word r2,
1170                     unsigned_word r3)
1171 {
1172   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1173   int last_input;
1174
1175   /* Append any results to the end of the inputs */
1176   last_input = TRACE_INPUT_IDX (data);
1177   save_data (sd, data, trace_fmt_word, sizeof (r0), &r0);
1178   save_data (sd, data, trace_fmt_word, sizeof (r1), &r1);
1179   save_data (sd, data, trace_fmt_word, sizeof (r2), &r2);
1180   save_data (sd, data, trace_fmt_word, sizeof (r3), &r3);
1181
1182   trace_results (sd, cpu, trace_idx, last_input);
1183 }
1184
1185 void
1186 trace_result_bool1 (SIM_DESC sd,
1187                     sim_cpu *cpu,
1188                     int trace_idx,
1189                     int r0)
1190 {
1191   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1192   int last_input;
1193
1194   /* Append any results to the end of the inputs */
1195   last_input = TRACE_INPUT_IDX (data);
1196   save_data (sd, data, trace_fmt_bool, sizeof (r0), &r0);
1197
1198   trace_results (sd, cpu, trace_idx, last_input);
1199 }
1200
1201 void
1202 trace_result_addr1 (SIM_DESC sd,
1203                     sim_cpu *cpu,
1204                     int trace_idx,
1205                     address_word r0)
1206 {
1207   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1208   int last_input;
1209
1210   /* Append any results to the end of the inputs */
1211   last_input = TRACE_INPUT_IDX (data);
1212   save_data (sd, data, trace_fmt_addr, sizeof (r0), &r0);
1213
1214   trace_results (sd, cpu, trace_idx, last_input);
1215 }
1216
1217 void
1218 trace_result_fp1 (SIM_DESC sd,
1219                   sim_cpu *cpu,
1220                   int trace_idx,
1221                   fp_word f0)
1222 {
1223   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1224   int last_input;
1225
1226   /* Append any results to the end of the inputs */
1227   last_input = TRACE_INPUT_IDX (data);
1228   save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f0);
1229
1230   trace_results (sd, cpu, trace_idx, last_input);
1231 }
1232
1233 void
1234 trace_result_fp2 (SIM_DESC sd,
1235                   sim_cpu *cpu,
1236                   int trace_idx,
1237                   fp_word f0,
1238                   fp_word f1)
1239 {
1240   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1241   int last_input;
1242
1243   /* Append any results to the end of the inputs */
1244   last_input = TRACE_INPUT_IDX (data);
1245   save_data (sd, data, trace_fmt_fp, sizeof (f0), &f0);
1246   save_data (sd, data, trace_fmt_fp, sizeof (f1), &f1);
1247
1248   trace_results (sd, cpu, trace_idx, last_input);
1249 }
1250
1251 void
1252 trace_result_fpu1 (SIM_DESC sd,
1253                    sim_cpu *cpu,
1254                    int trace_idx,
1255                    sim_fpu *f0)
1256 {
1257   double d;
1258   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1259   int last_input;
1260
1261   /* Append any results to the end of the inputs */
1262   last_input = TRACE_INPUT_IDX (data);
1263   d = sim_fpu_2d (f0);
1264   save_data (sd, data, trace_fmt_fp, sizeof (double), &d);
1265
1266   trace_results (sd, cpu, trace_idx, last_input);
1267 }
1268
1269 void
1270 trace_result_string1 (SIM_DESC sd,
1271                       sim_cpu *cpu,
1272                       int trace_idx,
1273                       char *s0)
1274 {
1275   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1276   int last_input;
1277
1278   /* Append any results to the end of the inputs */
1279   last_input = TRACE_INPUT_IDX (data);
1280   save_data (sd, data, trace_fmt_string, strlen (s0) + 1, s0);
1281
1282   trace_results (sd, cpu, trace_idx, last_input);
1283 }
1284
1285 void
1286 trace_result_word1_string1 (SIM_DESC sd,
1287                             sim_cpu *cpu,
1288                             int trace_idx,
1289                             unsigned_word r0,
1290                             char *s0)
1291 {
1292   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1293   int last_input;
1294
1295   /* Append any results to the end of the inputs */
1296   last_input = TRACE_INPUT_IDX (data);
1297   save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &r0);
1298   save_data (sd, data, trace_fmt_string, strlen (s0) + 1, s0);
1299
1300   trace_results (sd, cpu, trace_idx, last_input);
1301 }
1302 \f
1303 void
1304 trace_vprintf (SIM_DESC sd, sim_cpu *cpu, const char *fmt, va_list ap)
1305 {
1306   if (cpu != NULL)
1307     {
1308       if (TRACE_FILE (CPU_TRACE_DATA (cpu)) != NULL)
1309         vfprintf (TRACE_FILE (CPU_TRACE_DATA (cpu)), fmt, ap);
1310       else
1311         sim_io_evprintf (sd, fmt, ap);
1312     }
1313   else
1314     {
1315       if (TRACE_FILE (STATE_TRACE_DATA (sd)) != NULL)
1316         vfprintf (TRACE_FILE (STATE_TRACE_DATA (sd)), fmt, ap);
1317       else
1318         sim_io_evprintf (sd, fmt, ap);
1319     }
1320 }
1321
1322 void
1323 trace_printf (SIM_DESC sd, sim_cpu *cpu, const char *fmt, ...)
1324 {
1325   va_list ap;
1326
1327   va_start (ap, fmt);
1328
1329   trace_vprintf (sd, cpu, fmt, ap);
1330
1331   va_end (ap);
1332 }
1333
1334 void
1335 sim_debug_printf (sim_cpu *cpu, const char *fmt, ...)
1336 {
1337   va_list ap;
1338
1339   va_start (ap, fmt);
1340
1341   if (CPU_DEBUG_FILE (cpu) == NULL)
1342     (* STATE_CALLBACK (CPU_STATE (cpu))->evprintf_filtered)
1343       (STATE_CALLBACK (CPU_STATE (cpu)), fmt, ap);
1344   else
1345     vfprintf (CPU_DEBUG_FILE (cpu), fmt, ap);
1346
1347   va_end (ap);
1348 }