sim/common/sim-trace.c

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