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 /* Install tracing support.  */
 440
 441 SIM_RC
 442 trace_install (SIM_DESC sd)
 443 {
 444   int i;
 445
 446   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 447
 448   sim_add_option_table (sd, NULL, trace_options);
 449   memset (STATE_TRACE_DATA (sd), 0, sizeof (* STATE_TRACE_DATA (sd)));
 450   for (i = 0; i < MAX_NR_PROCESSORS; ++i)
 451     memset (CPU_TRACE_DATA (STATE_CPU (sd, i)), 0,
 452             sizeof (* CPU_TRACE_DATA (STATE_CPU (sd, i))));
 453   sim_module_add_init_fn (sd, trace_init);
 454   sim_module_add_uninstall_fn (sd, trace_uninstall);
 455   return SIM_RC_OK;
 456 }
 457
 458 static SIM_RC
 459 trace_init (SIM_DESC sd)
 460 {
 461 #ifdef SIM_HAVE_ADDR_RANGE
 462   /* Check if a range has been specified without specifying what to
 463      collect.  */
 464   {
 465     int i;
 466
 467     for (i = 0; i < MAX_NR_PROCESSORS; ++i)
 468       {
 469         sim_cpu *cpu = STATE_CPU (sd, i);
 470
 471         if (ADDR_RANGE_RANGES (TRACE_RANGE (CPU_TRACE_DATA (cpu)))
 472             && ! TRACE_INSN_P (cpu))
 473           {
 474             sim_io_eprintf_cpu (cpu, "Tracing address range specified without --trace-insn.\n");
 475             sim_io_eprintf_cpu (cpu, "Address range ignored.\n");
 476             sim_addr_range_delete (TRACE_RANGE (CPU_TRACE_DATA (cpu)),
 477                                    0, ~ (address_word) 0);
 478           }
 479       }
 480   }
 481 #endif
 482
 483   return SIM_RC_OK;
 484 }
 485
 486 static void
 487 trace_uninstall (SIM_DESC sd)
 488 {
 489   int i,j;
 490   FILE *sfile = TRACE_FILE (STATE_TRACE_DATA (sd));
 491
 492   if (sfile != NULL)
 493     fclose (sfile);
 494
 495   for (i = 0; i < MAX_NR_PROCESSORS; ++i)
 496     {
 497       FILE *cfile = TRACE_FILE (CPU_TRACE_DATA (STATE_CPU (sd, i)));
 498       if (cfile != NULL && cfile != sfile)
 499         {
 500           /* If output from different cpus is going to the same file,
 501              avoid closing the file twice.  */
 502           for (j = 0; j < i; ++j)
 503             if (TRACE_FILE (CPU_TRACE_DATA (STATE_CPU (sd, j))) == cfile)
 504               break;
 505           if (i == j)
 506             fclose (cfile);
 507         }
 508     }
 509
 510   if (STATE_PROG_SYMS (sd))
 511     free (STATE_PROG_SYMS (sd));
 512 }
 513 \f
 514 /* compute the nr of trace data units consumed by data */
 515 static int
 516 save_data_size (TRACE_DATA *data,
 517                 long size)
 518 {
 519   return ((size + sizeof (TRACE_INPUT_DATA (data) [0]) - 1)
 520           / sizeof (TRACE_INPUT_DATA (data) [0]));
 521 }
 522
 523
 524 /* Archive DATA into the trace buffer */
 525 void
 526 save_data (SIM_DESC sd,
 527            TRACE_DATA *data,
 528            data_fmt fmt,
 529            long size,
 530            const void *buf)
 531 {
 532   int i = TRACE_INPUT_IDX (data);
 533   if (i == sizeof (TRACE_INPUT_FMT (data)))
 534     sim_io_error (sd, "trace buffer overflow");
 535   TRACE_INPUT_FMT (data) [i] = fmt;
 536   TRACE_INPUT_SIZE (data) [i] = size;
 537   memcpy (&TRACE_INPUT_DATA (data) [i], buf, size);
 538   i += save_data_size (data, size);
 539   TRACE_INPUT_IDX (data) = i;
 540 }
 541
 542 static void
 543 print_data (SIM_DESC sd,
 544             sim_cpu *cpu,
 545             data_fmt fmt,
 546             long size,
 547             void *data)
 548 {
 549   switch (fmt)
 550     {
 551     case trace_fmt_instruction_incomplete:
 552       trace_printf (sd, cpu, " (instruction incomplete)");
 553       break;
 554     case trace_fmt_word:
 555     case trace_fmt_addr:
 556       {
 557         switch (size)
 558           {
 559           case sizeof (unsigned32):
 560             trace_printf (sd, cpu, " 0x%08lx", (long) * (unsigned32*) data);
 561             break;
 562           case sizeof (unsigned64):
 563             trace_printf (sd, cpu, " 0x%08lx%08lx",
 564                           (long) ((* (unsigned64*) data) >> 32),
 565                           (long) * (unsigned64*) data);
 566             break;
 567           default:
 568             abort ();
 569           }
 570         break;
 571       }
 572     case trace_fmt_bool:
 573       {
 574         SIM_ASSERT (size == sizeof (int));
 575         trace_printf (sd, cpu, " %-8s",
 576                       (* (int*) data) ? "true" : "false");
 577         break;
 578       }
 579     case trace_fmt_fp:
 580       {
 581         sim_fpu fp;
 582         switch (size)
 583           {
 584             /* FIXME: Assumes sizeof float == 4; sizeof double == 8 */
 585           case 4:
 586             sim_fpu_32to (&fp, *(unsigned32*)data);
 587             break;
 588           case 8:
 589             sim_fpu_64to (&fp, *(unsigned64*)data);
 590             break;
 591           default:
 592             abort ();
 593           }
 594         trace_printf (sd, cpu, " %8g", sim_fpu_2d (&fp));
 595         switch (size)
 596           {
 597           case 4:
 598             trace_printf (sd, cpu, " (0x%08lx)",
 599                           (long) *(unsigned32*)data);
 600             break;
 601           case 8:
 602             trace_printf (sd, cpu, " (0x%08lx%08lx)",
 603                           (long) (*(unsigned64*)data >> 32),
 604                           (long) (*(unsigned64*)data));
 605             break;
 606           default:
 607             abort ();
 608           }
 609         break;
 610       }
 611     case trace_fmt_fpu:
 612       /* FIXME: At present sim_fpu data is stored as a double */
 613       trace_printf (sd, cpu, " %8g", * (double*) data);
 614       break;
 615     case trace_fmt_string:
 616       trace_printf (sd, cpu, " %-8s", (char*) data);
 617       break;
 618     default:
 619       abort ();
 620     }
 621 }
 622
 623 static const char *
 624 trace_idx_to_str (int trace_idx)
 625 {
 626   static char num[8];
 627   switch (trace_idx)
 628     {
 629     case TRACE_ALU_IDX:      return "alu:     ";
 630     case TRACE_INSN_IDX:     return "insn:    ";
 631     case TRACE_DISASM_IDX:   return "disasm:  ";
 632     case TRACE_DECODE_IDX:   return "decode:  ";
 633     case TRACE_EXTRACT_IDX:  return "extract: ";
 634     case TRACE_MEMORY_IDX:   return "memory:  ";
 635     case TRACE_CORE_IDX:     return "core:    ";
 636     case TRACE_EVENTS_IDX:   return "events:  ";
 637     case TRACE_FPU_IDX:      return "fpu:     ";
 638     case TRACE_BRANCH_IDX:   return "branch:  ";
 639     case TRACE_SYSCALL_IDX:  return "syscall: ";
 640     case TRACE_REGISTER_IDX: return "reg:     ";
 641     case TRACE_VPU_IDX:      return "vpu:     ";
 642     default:
 643       sprintf (num, "?%d?", trace_idx);
 644       return num;
 645     }
 646 }
 647
 648 static void
 649 trace_results (SIM_DESC sd,
 650                sim_cpu *cpu,
 651                int trace_idx,
 652                int last_input)
 653 {
 654   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
 655   int nr_out;
 656   int i;
 657
 658   /* cross check trace_idx against TRACE_IDX (data)? */
 659
 660   /* prefix */
 661   trace_printf (sd, cpu, "%s %s",
 662                 trace_idx_to_str (TRACE_IDX (data)),
 663                 TRACE_PREFIX (data));
 664   TRACE_IDX (data) = 0;
 665
 666   for (i = 0, nr_out = 0;
 667        i < TRACE_INPUT_IDX (data);
 668        i += save_data_size (data, TRACE_INPUT_SIZE (data) [i]), nr_out++)
 669     {
 670       if (i == last_input)
 671         {
 672           int pad = (strlen (" 0x") + sizeof (unsigned_word) * 2);
 673           int padding = pad * (3 - nr_out);
 674           if (padding < 0)
 675             padding = 0;
 676           padding += strlen (" ::");
 677           trace_printf (sd, cpu, "%*s", padding, " ::");
 678         }
 679       print_data (sd, cpu,
 680                   TRACE_INPUT_FMT (data) [i],
 681                   TRACE_INPUT_SIZE (data) [i],
 682                   &TRACE_INPUT_DATA (data) [i]);
 683     }
 684   trace_printf (sd, cpu, "\n");
 685 }
 686
 687 int
 688 trace_load_symbols (SIM_DESC sd)
 689 {
 690   bfd *abfd;
 691   asymbol **asymbols;
 692   long symsize;
 693   long symbol_count;
 694
 695   /* Already loaded, so nothing to do.  */
 696   if (STATE_PROG_SYMS (sd))
 697     return 1;
 698
 699   abfd = STATE_PROG_BFD (sd);
 700   if (abfd == NULL)
 701     return 0;
 702
 703   symsize = bfd_get_symtab_upper_bound (abfd);
 704   if (symsize < 0)
 705     return 0;
 706
 707   asymbols = xmalloc (symsize);
 708   symbol_count = bfd_canonicalize_symtab (abfd, asymbols);
 709   if (symbol_count < 0)
 710     {
 711       free (asymbols);
 712       return 0;
 713     }
 714
 715   STATE_PROG_SYMS (sd) = asymbols;
 716   STATE_PROG_SYMS_COUNT (sd) = symbol_count;
 717   return 1;
 718 }
 719
 720 bfd_vma
 721 trace_sym_value (SIM_DESC sd, const char *name)
 722 {
 723   asymbol **asymbols;
 724   long i;
 725
 726   if (!trace_load_symbols (sd))
 727     return -1;
 728
 729   asymbols = STATE_PROG_SYMS (sd);
 730
 731   for (i = 0; i < STATE_PROG_SYMS_COUNT (sd); ++i)
 732     if (strcmp (asymbols[i]->name, name) == 0)
 733       return bfd_asymbol_value (asymbols[i]);
 734
 735   return -1;
 736 }
 737
 738 void
 739 trace_prefix (SIM_DESC sd,
 740               sim_cpu *cpu,
 741               sim_cia cia,
 742               address_word pc,
 743               int line_p,
 744               const char *filename,
 745               int linenum,
 746               const char *fmt,
 747               ...)
 748 {
 749   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
 750   va_list ap;
 751   char *prefix = TRACE_PREFIX (data);
 752   char *chp;
 753  /* FIXME: The TRACE_PREFIX_WIDTH should be determined at build time using
 754     known information about the disassembled instructions. */
 755 #ifndef TRACE_PREFIX_WIDTH
 756 #define TRACE_PREFIX_WIDTH 48
 757 #endif
 758   int width = TRACE_PREFIX_WIDTH;
 759
 760   /* if the previous trace data wasn't flushed, flush it now with a
 761      note indicating that the trace was incomplete. */
 762   if (TRACE_IDX (data) != 0)
 763     {
 764       int last_input = TRACE_INPUT_IDX (data);
 765       save_data (sd, data, trace_fmt_instruction_incomplete, 1, "");
 766       trace_results (sd, cpu, TRACE_IDX (data), last_input);
 767     }
 768   TRACE_IDX (data) = 0;
 769   TRACE_INPUT_IDX (data) = 0;
 770
 771   /* Create the text prefix for this new instruction: */
 772   if (!line_p)
 773     {
 774       if (filename)
 775         {
 776           sprintf (prefix, "%s:%-*d 0x%.*lx ",
 777                    filename,
 778                    SIZE_LINE_NUMBER, linenum,
 779                    SIZE_PC, (long) pc);
 780         }
 781       else
 782         {
 783           sprintf (prefix, "0x%.*lx ",
 784                    SIZE_PC, (long) pc);
 785           /* Shrink the width by the amount that we didn't print.  */
 786           width -= SIZE_LINE_NUMBER + SIZE_PC + 8;
 787         }
 788       chp = strchr (prefix, '\0');
 789       va_start (ap, fmt);
 790       vsprintf (chp, fmt, ap);
 791       va_end (ap);
 792     }
 793   else
 794     {
 795       char buf[256];
 796       buf[0] = 0;
 797       if (STATE_TEXT_SECTION (sd)
 798           && pc >= STATE_TEXT_START (sd)
 799           && pc < STATE_TEXT_END (sd))
 800         {
 801           const char *pc_filename = (const char *)0;
 802           const char *pc_function = (const char *)0;
 803           unsigned int pc_linenum = 0;
 804           bfd *abfd;
 805           asymbol **asymbols;
 806
 807           if (!trace_load_symbols (sd))
 808             sim_engine_abort (sd, cpu, cia, "could not load symbols");
 809
 810           abfd = STATE_PROG_BFD (sd);
 811           asymbols = STATE_PROG_SYMS (sd);
 812
 813           if (bfd_find_nearest_line (abfd, STATE_TEXT_SECTION (sd), asymbols,
 814                                      pc - STATE_TEXT_START (sd),
 815                                      &pc_filename, &pc_function, &pc_linenum))
 816             {
 817               char *p = buf;
 818               if (pc_linenum)
 819                 {
 820                   sprintf (p, "#%-*d ", SIZE_LINE_NUMBER, pc_linenum);
 821                   p += strlen (p);
 822                 }
 823               else
 824                 {
 825                   sprintf (p, "%-*s ", SIZE_LINE_NUMBER+1, "---");
 826                   p += SIZE_LINE_NUMBER+2;
 827                 }
 828
 829               if (pc_function)
 830                 {
 831                   sprintf (p, "%s ", pc_function);
 832                   p += strlen (p);
 833                 }
 834               else if (pc_filename)
 835                 {
 836                   char *q = (char *) strrchr (pc_filename, '/');
 837                   sprintf (p, "%s ", (q) ? q+1 : pc_filename);
 838                   p += strlen (p);
 839                 }
 840
 841               if (*p == ' ')
 842                 *p = '\0';
 843             }
 844         }
 845
 846       sprintf (prefix, "0x%.*x %-*.*s ",
 847                SIZE_PC, (unsigned) pc,
 848                SIZE_LOCATION, SIZE_LOCATION, buf);
 849       chp = strchr (prefix, '\0');
 850       va_start (ap, fmt);
 851       vsprintf (chp, fmt, ap);
 852       va_end (ap);
 853     }
 854
 855   /* Pad it out to TRACE_PREFIX_WIDTH.  */
 856   chp = strchr (prefix, '\0');
 857   if (chp - prefix < width)
 858     {
 859       memset (chp, ' ', width - (chp - prefix));
 860       chp = &prefix [width];
 861       *chp = '\0';
 862     }
 863   strcpy (chp, " -");
 864
 865   /* check that we've not over flowed the prefix buffer */
 866   if (strlen (prefix) >= sizeof (TRACE_PREFIX (data)))
 867     abort ();
 868 }
 869
 870 void
 871 trace_generic (SIM_DESC sd,
 872                sim_cpu *cpu,
 873                int trace_idx,
 874                const char *fmt,
 875                ...)
 876 {
 877   va_list ap;
 878   trace_printf (sd, cpu, "%s %s",
 879                 trace_idx_to_str (trace_idx),
 880                 TRACE_PREFIX (CPU_TRACE_DATA (cpu)));
 881   va_start (ap, fmt);
 882   trace_vprintf (sd, cpu, fmt, ap);
 883   va_end (ap);
 884   trace_printf (sd, cpu, "\n");
 885 }
 886
 887 static int
 888 dis_read (bfd_vma memaddr, bfd_byte *myaddr, unsigned int length,
 889           struct disassemble_info *dinfo)
 890 {
 891   SIM_CPU *cpu = dinfo->application_data;
 892   sim_core_read_buffer (CPU_STATE (cpu), cpu, NULL_CIA, myaddr, memaddr, length);
 893   return 0;
 894 }
 895
 896 static int ATTRIBUTE_PRINTF (2, 3)
 897 dis_printf (SIM_CPU *cpu, const char *fmt, ...)
 898 {
 899   SIM_DESC sd = CPU_STATE (cpu);
 900   va_list ap;
 901   va_start (ap, fmt);
 902   trace_vprintf (sd, cpu, fmt, ap);
 903   va_end (ap);
 904   return 0;
 905 }
 906
 907 void
 908 trace_disasm (SIM_DESC sd, sim_cpu *cpu, address_word addr)
 909 {
 910   struct bfd *bfd = STATE_PROG_BFD (sd);
 911   TRACE_DATA *trace_data = CPU_TRACE_DATA (cpu);
 912   disassemble_info *info = &trace_data->dis_info;
 913
 914   /* See if we need to set up the disassembly func.  */
 915   if (trace_data->dis_bfd != bfd)
 916     {
 917       trace_data->dis_bfd = bfd;
 918       trace_data->disassembler
 919         = disassembler (bfd_get_arch (trace_data->dis_bfd),
 920                         bfd_big_endian (trace_data->dis_bfd),
 921                         bfd_get_mach (trace_data->dis_bfd),
 922                         trace_data->dis_bfd);
 923       INIT_DISASSEMBLE_INFO (*info, cpu, dis_printf);
 924       info->read_memory_func = dis_read;
 925       info->arch = bfd_get_arch (bfd);
 926       info->mach = bfd_get_mach (bfd);
 927       disassemble_init_for_target (info);
 928     }
 929
 930   info->application_data = cpu;
 931
 932   trace_printf (sd, cpu, "%s %s",
 933                 trace_idx_to_str (TRACE_DISASM_IDX),
 934                 TRACE_PREFIX (trace_data));
 935   trace_data->disassembler (addr, info);
 936   trace_printf (sd, cpu, "\n");
 937 }
 938
 939 void
 940 trace_input0 (SIM_DESC sd,
 941               sim_cpu *cpu,
 942               int trace_idx)
 943 {
 944   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
 945   TRACE_IDX (data) = trace_idx;
 946 }
 947
 948 void
 949 trace_input_word1 (SIM_DESC sd,
 950                    sim_cpu *cpu,
 951                    int trace_idx,
 952                    unsigned_word d0)
 953 {
 954   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
 955   TRACE_IDX (data) = trace_idx;
 956   save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &d0);
 957 }
 958
 959 void
 960 trace_input_word2 (SIM_DESC sd,
 961                    sim_cpu *cpu,
 962                    int trace_idx,
 963                    unsigned_word d0,
 964                    unsigned_word d1)
 965 {
 966   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
 967   TRACE_IDX (data) = trace_idx;
 968   save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &d0);
 969   save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &d1);
 970 }
 971
 972 void
 973 trace_input_word3 (SIM_DESC sd,
 974                    sim_cpu *cpu,
 975                    int trace_idx,
 976                    unsigned_word d0,
 977                    unsigned_word d1,
 978                    unsigned_word d2)
 979 {
 980   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
 981   TRACE_IDX (data) = trace_idx;
 982   save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &d0);
 983   save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &d1);
 984   save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &d2);
 985 }
 986
 987 void
 988 trace_input_word4 (SIM_DESC sd,
 989                    sim_cpu *cpu,
 990                    int trace_idx,
 991                    unsigned_word d0,
 992                    unsigned_word d1,
 993                    unsigned_word d2,
 994                    unsigned_word d3)
 995 {
 996   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
 997   TRACE_IDX (data) = trace_idx;
 998   save_data (sd, data, trace_fmt_word, sizeof (d0), &d0);
 999   save_data (sd, data, trace_fmt_word, sizeof (d1), &d1);
1000   save_data (sd, data, trace_fmt_word, sizeof (d2), &d2);
1001   save_data (sd, data, trace_fmt_word, sizeof (d3), &d3);
1002 }
1003
1004 void
1005 trace_input_bool1 (SIM_DESC sd,
1006                    sim_cpu *cpu,
1007                    int trace_idx,
1008                    int d0)
1009 {
1010   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1011   TRACE_IDX (data) = trace_idx;
1012   save_data (sd, data, trace_fmt_bool, sizeof (d0), &d0);
1013 }
1014
1015 void
1016 trace_input_addr1 (SIM_DESC sd,
1017                    sim_cpu *cpu,
1018                    int trace_idx,
1019                    address_word d0)
1020 {
1021   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1022   TRACE_IDX (data) = trace_idx;
1023   save_data (sd, data, trace_fmt_addr, sizeof (d0), &d0);
1024 }
1025
1026 void
1027 trace_input_fp1 (SIM_DESC sd,
1028                  sim_cpu *cpu,
1029                  int trace_idx,
1030                  fp_word f0)
1031 {
1032   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1033   TRACE_IDX (data) = trace_idx;
1034   save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f0);
1035 }
1036
1037 void
1038 trace_input_fp2 (SIM_DESC sd,
1039                  sim_cpu *cpu,
1040                  int trace_idx,
1041                  fp_word f0,
1042                  fp_word f1)
1043 {
1044   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1045   TRACE_IDX (data) = trace_idx;
1046   save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f0);
1047   save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f1);
1048 }
1049
1050 void
1051 trace_input_fp3 (SIM_DESC sd,
1052                  sim_cpu *cpu,
1053                  int trace_idx,
1054                  fp_word f0,
1055                  fp_word f1,
1056                  fp_word f2)
1057 {
1058   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1059   TRACE_IDX (data) = trace_idx;
1060   save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f0);
1061   save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f1);
1062   save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f2);
1063 }
1064
1065 void
1066 trace_input_fpu1 (SIM_DESC sd,
1067                   sim_cpu *cpu,
1068                   int trace_idx,
1069                   sim_fpu *f0)
1070 {
1071   double d;
1072   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1073   TRACE_IDX (data) = trace_idx;
1074   d = sim_fpu_2d (f0);
1075   save_data (sd, data, trace_fmt_fp, sizeof (double), &d);
1076 }
1077
1078 void
1079 trace_input_fpu2 (SIM_DESC sd,
1080                   sim_cpu *cpu,
1081                   int trace_idx,
1082                   sim_fpu *f0,
1083                   sim_fpu *f1)
1084 {
1085   double d;
1086   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1087   TRACE_IDX (data) = trace_idx;
1088   d = sim_fpu_2d (f0);
1089   save_data (sd, data, trace_fmt_fp, sizeof (double), &d);
1090   d = sim_fpu_2d (f1);
1091   save_data (sd, data, trace_fmt_fp, sizeof (double), &d);
1092 }
1093
1094 void
1095 trace_input_fpu3 (SIM_DESC sd,
1096                   sim_cpu *cpu,
1097                   int trace_idx,
1098                   sim_fpu *f0,
1099                   sim_fpu *f1,
1100                   sim_fpu *f2)
1101 {
1102   double d;
1103   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1104   TRACE_IDX (data) = trace_idx;
1105   d = sim_fpu_2d (f0);
1106   save_data (sd, data, trace_fmt_fp, sizeof (double), &d);
1107   d = sim_fpu_2d (f1);
1108   save_data (sd, data, trace_fmt_fp, sizeof (double), &d);
1109   d = sim_fpu_2d (f2);
1110   save_data (sd, data, trace_fmt_fp, sizeof (double), &d);
1111 }
1112
1113 void
1114 trace_result_word1 (SIM_DESC sd,
1115                     sim_cpu *cpu,
1116                     int trace_idx,
1117                     unsigned_word r0)
1118 {
1119   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1120   int last_input;
1121
1122   /* Append any results to the end of the inputs */
1123   last_input = TRACE_INPUT_IDX (data);
1124   save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &r0);
1125
1126   trace_results (sd, cpu, trace_idx, last_input);
1127 }
1128
1129 void
1130 trace_result0 (SIM_DESC sd,
1131                sim_cpu *cpu,
1132                int trace_idx)
1133 {
1134   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1135   int last_input;
1136
1137   /* Append any results to the end of the inputs */
1138   last_input = TRACE_INPUT_IDX (data);
1139
1140   trace_results (sd, cpu, trace_idx, last_input);
1141 }
1142
1143 void
1144 trace_result_word2 (SIM_DESC sd,
1145                     sim_cpu *cpu,
1146                     int trace_idx,
1147                     unsigned_word r0,
1148                     unsigned_word r1)
1149 {
1150   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1151   int last_input;
1152
1153   /* Append any results to the end of the inputs */
1154   last_input = TRACE_INPUT_IDX (data);
1155   save_data (sd, data, trace_fmt_word, sizeof (r0), &r0);
1156   save_data (sd, data, trace_fmt_word, sizeof (r1), &r1);
1157
1158   trace_results (sd, cpu, trace_idx, last_input);
1159 }
1160
1161 void
1162 trace_result_word4 (SIM_DESC sd,
1163                     sim_cpu *cpu,
1164                     int trace_idx,
1165                     unsigned_word r0,
1166                     unsigned_word r1,
1167                     unsigned_word r2,
1168                     unsigned_word r3)
1169 {
1170   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1171   int last_input;
1172
1173   /* Append any results to the end of the inputs */
1174   last_input = TRACE_INPUT_IDX (data);
1175   save_data (sd, data, trace_fmt_word, sizeof (r0), &r0);
1176   save_data (sd, data, trace_fmt_word, sizeof (r1), &r1);
1177   save_data (sd, data, trace_fmt_word, sizeof (r2), &r2);
1178   save_data (sd, data, trace_fmt_word, sizeof (r3), &r3);
1179
1180   trace_results (sd, cpu, trace_idx, last_input);
1181 }
1182
1183 void
1184 trace_result_bool1 (SIM_DESC sd,
1185                     sim_cpu *cpu,
1186                     int trace_idx,
1187                     int r0)
1188 {
1189   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1190   int last_input;
1191
1192   /* Append any results to the end of the inputs */
1193   last_input = TRACE_INPUT_IDX (data);
1194   save_data (sd, data, trace_fmt_bool, sizeof (r0), &r0);
1195
1196   trace_results (sd, cpu, trace_idx, last_input);
1197 }
1198
1199 void
1200 trace_result_addr1 (SIM_DESC sd,
1201                     sim_cpu *cpu,
1202                     int trace_idx,
1203                     address_word r0)
1204 {
1205   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1206   int last_input;
1207
1208   /* Append any results to the end of the inputs */
1209   last_input = TRACE_INPUT_IDX (data);
1210   save_data (sd, data, trace_fmt_addr, sizeof (r0), &r0);
1211
1212   trace_results (sd, cpu, trace_idx, last_input);
1213 }
1214
1215 void
1216 trace_result_fp1 (SIM_DESC sd,
1217                   sim_cpu *cpu,
1218                   int trace_idx,
1219                   fp_word f0)
1220 {
1221   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1222   int last_input;
1223
1224   /* Append any results to the end of the inputs */
1225   last_input = TRACE_INPUT_IDX (data);
1226   save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f0);
1227
1228   trace_results (sd, cpu, trace_idx, last_input);
1229 }
1230
1231 void
1232 trace_result_fp2 (SIM_DESC sd,
1233                   sim_cpu *cpu,
1234                   int trace_idx,
1235                   fp_word f0,
1236                   fp_word f1)
1237 {
1238   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1239   int last_input;
1240
1241   /* Append any results to the end of the inputs */
1242   last_input = TRACE_INPUT_IDX (data);
1243   save_data (sd, data, trace_fmt_fp, sizeof (f0), &f0);
1244   save_data (sd, data, trace_fmt_fp, sizeof (f1), &f1);
1245
1246   trace_results (sd, cpu, trace_idx, last_input);
1247 }
1248
1249 void
1250 trace_result_fpu1 (SIM_DESC sd,
1251                    sim_cpu *cpu,
1252                    int trace_idx,
1253                    sim_fpu *f0)
1254 {
1255   double d;
1256   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1257   int last_input;
1258
1259   /* Append any results to the end of the inputs */
1260   last_input = TRACE_INPUT_IDX (data);
1261   d = sim_fpu_2d (f0);
1262   save_data (sd, data, trace_fmt_fp, sizeof (double), &d);
1263
1264   trace_results (sd, cpu, trace_idx, last_input);
1265 }
1266
1267 void
1268 trace_result_string1 (SIM_DESC sd,
1269                       sim_cpu *cpu,
1270                       int trace_idx,
1271                       char *s0)
1272 {
1273   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1274   int last_input;
1275
1276   /* Append any results to the end of the inputs */
1277   last_input = TRACE_INPUT_IDX (data);
1278   save_data (sd, data, trace_fmt_string, strlen (s0) + 1, s0);
1279
1280   trace_results (sd, cpu, trace_idx, last_input);
1281 }
1282
1283 void
1284 trace_result_word1_string1 (SIM_DESC sd,
1285                             sim_cpu *cpu,
1286                             int trace_idx,
1287                             unsigned_word r0,
1288                             char *s0)
1289 {
1290   TRACE_DATA *data = CPU_TRACE_DATA (cpu);
1291   int last_input;
1292
1293   /* Append any results to the end of the inputs */
1294   last_input = TRACE_INPUT_IDX (data);
1295   save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &r0);
1296   save_data (sd, data, trace_fmt_string, strlen (s0) + 1, s0);
1297
1298   trace_results (sd, cpu, trace_idx, last_input);
1299 }
1300 \f
1301 void
1302 trace_vprintf (SIM_DESC sd, sim_cpu *cpu, const char *fmt, va_list ap)
1303 {
1304   if (cpu != NULL)
1305     {
1306       if (TRACE_FILE (CPU_TRACE_DATA (cpu)) != NULL)
1307         vfprintf (TRACE_FILE (CPU_TRACE_DATA (cpu)), fmt, ap);
1308       else
1309         sim_io_evprintf (sd, fmt, ap);
1310     }
1311   else
1312     {
1313       if (TRACE_FILE (STATE_TRACE_DATA (sd)) != NULL)
1314         vfprintf (TRACE_FILE (STATE_TRACE_DATA (sd)), fmt, ap);
1315       else
1316         sim_io_evprintf (sd, fmt, ap);
1317     }
1318 }
1319
1320 void
1321 trace_printf (SIM_DESC sd, sim_cpu *cpu, const char *fmt, ...)
1322 {
1323   va_list ap;
1324
1325   va_start (ap, fmt);
1326
1327   trace_vprintf (sd, cpu, fmt, ap);
1328
1329   va_end (ap);
1330 }
1331
1332 void
1333 sim_debug_printf (sim_cpu *cpu, const char *fmt, ...)
1334 {
1335   va_list ap;
1336
1337   va_start (ap, fmt);
1338
1339   if (CPU_DEBUG_FILE (cpu) == NULL)
1340     (* STATE_CALLBACK (CPU_STATE (cpu))->evprintf_filtered)
1341       (STATE_CALLBACK (CPU_STATE (cpu)), fmt, ap);
1342   else
1343     vfprintf (CPU_DEBUG_FILE (cpu), fmt, ap);
1344
1345   va_end (ap);
1346 }