sim/common/sim-trace.h

   1 /* Simulator tracing/debugging support.
   2    Copyright (C) 1997-2015 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 file is meant to be included by sim-basics.h.  */
  21
  22 #ifndef SIM_TRACE_H
  23 #define SIM_TRACE_H
  24
  25 /* Standard traceable entities.  */
  26
  27 enum {
  28   /* Trace insn execution.  */
  29   TRACE_INSN_IDX = 1,
  30
  31   /* Trace insn decoding.
  32      ??? This is more of a simulator debugging operation and might best be
  33      moved to --debug-decode.  */
  34   TRACE_DECODE_IDX,
  35
  36   /* Trace insn extraction.
  37      ??? This is more of a simulator debugging operation and might best be
  38      moved to --debug-extract.  */
  39   TRACE_EXTRACT_IDX,
  40
  41   /* Trace insn execution but include line numbers.  */
  42   TRACE_LINENUM_IDX,
  43
  44   /* Trace memory operations.
  45      The difference between this and TRACE_CORE_IDX is (I think) that this
  46      is intended to apply to a higher level.  TRACE_CORE_IDX applies to the
  47      low level core operations.  */
  48   TRACE_MEMORY_IDX,
  49
  50   /* Include model performance data in tracing output.  */
  51   TRACE_MODEL_IDX,
  52
  53   /* Trace ALU operations.  */
  54   TRACE_ALU_IDX,
  55
  56   /* Trace memory core operations.  */
  57   TRACE_CORE_IDX,
  58
  59   /* Trace events.  */
  60   TRACE_EVENTS_IDX,
  61
  62   /* Trace fpu operations.  */
  63   TRACE_FPU_IDX,
  64
  65   /* Trace vpu operations.  */
  66   TRACE_VPU_IDX,
  67
  68   /* Trace branching.  */
  69   TRACE_BRANCH_IDX,
  70
  71   /* Trace syscalls.  */
  72   TRACE_SYSCALL_IDX,
  73
  74   /* Add information useful for debugging the simulator to trace output.  */
  75   TRACE_DEBUG_IDX,
  76
  77   /* Simulator specific trace bits begin here.  */
  78   TRACE_NEXT_IDX,
  79
  80 };
  81 /* Maximum number of traceable entities.  */
  82 #ifndef MAX_TRACE_VALUES
  83 #define MAX_TRACE_VALUES 32
  84 #endif
  85
  86 /* The -t option only prints useful values.  It's easy to type and shouldn't
  87    splat on the screen everything under the sun making nothing easy to
  88    find.  */
  89 #define TRACE_USEFUL_MASK \
  90   (TRACE_insn | TRACE_linenum | TRACE_memory | TRACE_model)
  91 \f
  92 /* Masks so WITH_TRACE can have symbolic values.
  93    The case choice here is on purpose.  The lowercase parts are args to
  94    --with-trace.  */
  95 #define TRACE_insn     (1 << TRACE_INSN_IDX)
  96 #define TRACE_decode   (1 << TRACE_DECODE_IDX)
  97 #define TRACE_extract  (1 << TRACE_EXTRACT_IDX)
  98 #define TRACE_linenum  (1 << TRACE_LINENUM_IDX)
  99 #define TRACE_memory   (1 << TRACE_MEMORY_IDX)
 100 #define TRACE_model    (1 << TRACE_MODEL_IDX)
 101 #define TRACE_alu      (1 << TRACE_ALU_IDX)
 102 #define TRACE_core     (1 << TRACE_CORE_IDX)
 103 #define TRACE_events   (1 << TRACE_EVENTS_IDX)
 104 #define TRACE_fpu      (1 << TRACE_FPU_IDX)
 105 #define TRACE_vpu      (1 << TRACE_VPU_IDX)
 106 #define TRACE_branch   (1 << TRACE_BRANCH_IDX)
 107 #define TRACE_syscall  (1 << TRACE_SYSCALL_IDX)
 108 #define TRACE_debug    (1 << TRACE_DEBUG_IDX)
 109
 110 /* Return non-zero if tracing of idx is enabled (compiled in).  */
 111 #define WITH_TRACE_P(idx)       (WITH_TRACE & (1 << idx))
 112
 113 /* Preprocessor macros to simplify tests of WITH_TRACE.  */
 114 #define WITH_TRACE_ANY_P        (WITH_TRACE)
 115 #define WITH_TRACE_INSN_P       WITH_TRACE_P (TRACE_INSN_IDX)
 116 #define WITH_TRACE_DECODE_P     WITH_TRACE_P (TRACE_DECODE_IDX)
 117 #define WITH_TRACE_EXTRACT_P    WITH_TRACE_P (TRACE_EXTRACT_IDX)
 118 #define WITH_TRACE_LINENUM_P    WITH_TRACE_P (TRACE_LINENUM_IDX)
 119 #define WITH_TRACE_MEMORY_P     WITH_TRACE_P (TRACE_MEMORY_IDX)
 120 #define WITH_TRACE_MODEL_P      WITH_TRACE_P (TRACE_MODEL_IDX)
 121 #define WITH_TRACE_ALU_P        WITH_TRACE_P (TRACE_ALU_IDX)
 122 #define WITH_TRACE_CORE_P       WITH_TRACE_P (TRACE_CORE_IDX)
 123 #define WITH_TRACE_EVENTS_P     WITH_TRACE_P (TRACE_EVENTS_IDX)
 124 #define WITH_TRACE_FPU_P        WITH_TRACE_P (TRACE_FPU_IDX)
 125 #define WITH_TRACE_VPU_P        WITH_TRACE_P (TRACE_VPU_IDX)
 126 #define WITH_TRACE_BRANCH_P     WITH_TRACE_P (TRACE_BRANCH_IDX)
 127 #define WITH_TRACE_SYSCALL_P    WITH_TRACE_P (TRACE_SYSCALL_IDX)
 128 #define WITH_TRACE_DEBUG_P      WITH_TRACE_P (TRACE_DEBUG_IDX)
 129
 130 /* Tracing install handler.  */
 131 MODULE_INSTALL_FN trace_install;
 132 \f
 133 /* Struct containing all system and cpu trace data.
 134
 135    System trace data is stored with the associated module.
 136    System and cpu tracing must share the same space of bitmasks as they
 137    are arguments to --with-trace.  One could have --with-trace and
 138    --with-cpu-trace or some such but that's an over-complication at this point
 139    in time.  Also, there may be occasions where system and cpu tracing may
 140    wish to share a name.  */
 141
 142 typedef struct _trace_data {
 143
 144   /* Global summary of all the current trace options */
 145   char trace_any_p;
 146
 147   /* Boolean array of specified tracing flags.  */
 148   /* ??? It's not clear that using an array vs a bit mask is faster.
 149      Consider the case where one wants to test whether any of several bits
 150      are set.  */
 151   char trace_flags[MAX_TRACE_VALUES];
 152 #define TRACE_FLAGS(t) ((t)->trace_flags)
 153
 154   /* Tracing output goes to this or stderr if NULL.
 155      We can't store `stderr' here as stderr goes through a callback.  */
 156   FILE *trace_file;
 157 #define TRACE_FILE(t) ((t)->trace_file)
 158
 159   /* Buffer to store the prefix to be printed before any trace line.  */
 160   char trace_prefix[256];
 161 #define TRACE_PREFIX(t) ((t)->trace_prefix)
 162
 163   /* Buffer to save the inputs for the current instruction.  Use a
 164      union to force the buffer into correct alignment */
 165   union {
 166     unsigned8 i8;
 167     unsigned16 i16;
 168     unsigned32 i32;
 169     unsigned64 i64;
 170   } trace_input_data[16];
 171   unsigned8 trace_input_fmt[16];
 172   unsigned8 trace_input_size[16];
 173   int trace_input_idx;
 174 #define TRACE_INPUT_DATA(t) ((t)->trace_input_data)
 175 #define TRACE_INPUT_FMT(t) ((t)->trace_input_fmt)
 176 #define TRACE_INPUT_SIZE(t) ((t)->trace_input_size)
 177 #define TRACE_INPUT_IDX(t) ((t)->trace_input_idx)
 178
 179   /* Category of trace being performed */
 180   int trace_idx;
 181 #define TRACE_IDX(t) ((t)->trace_idx)
 182
 183   /* Trace range.
 184      ??? Not all cpu's support this.  */
 185   ADDR_RANGE range;
 186 #define TRACE_RANGE(t) (& (t)->range)
 187 } TRACE_DATA;
 188 \f
 189 /* System tracing support.  */
 190
 191 #define STATE_TRACE_FLAGS(sd) TRACE_FLAGS (STATE_TRACE_DATA (sd))
 192
 193 /* Return non-zero if tracing of IDX is enabled for non-cpu specific
 194    components.  The "S" in "STRACE" refers to "System".  */
 195 #define STRACE_P(sd,idx) \
 196   (WITH_TRACE_P (idx) && STATE_TRACE_FLAGS (sd)[idx] != 0)
 197
 198 /* Non-zero if --trace-<xxxx> was specified for SD.  */
 199 #define STRACE_ANY_P(sd)        (WITH_TRACE_ANY_P && (STATE_TRACE_DATA (sd)->trace_any_p))
 200 #define STRACE_INSN_P(sd)       STRACE_P (sd, TRACE_INSN_IDX)
 201 #define STRACE_DECODE_P(sd)     STRACE_P (sd, TRACE_DECODE_IDX)
 202 #define STRACE_EXTRACT_P(sd)    STRACE_P (sd, TRACE_EXTRACT_IDX)
 203 #define STRACE_LINENUM_P(sd)    STRACE_P (sd, TRACE_LINENUM_IDX)
 204 #define STRACE_MEMORY_P(sd)     STRACE_P (sd, TRACE_MEMORY_IDX)
 205 #define STRACE_MODEL_P(sd)      STRACE_P (sd, TRACE_MODEL_IDX)
 206 #define STRACE_ALU_P(sd)        STRACE_P (sd, TRACE_ALU_IDX)
 207 #define STRACE_CORE_P(sd)       STRACE_P (sd, TRACE_CORE_IDX)
 208 #define STRACE_EVENTS_P(sd)     STRACE_P (sd, TRACE_EVENTS_IDX)
 209 #define STRACE_FPU_P(sd)        STRACE_P (sd, TRACE_FPU_IDX)
 210 #define STRACE_VPU_P(sd)        STRACE_P (sd, TRACE_VPU_IDX)
 211 #define STRACE_BRANCH_P(sd)     STRACE_P (sd, TRACE_BRANCH_IDX)
 212 #define STRACE_SYSCALL_P(sd)    STRACE_P (sd, TRACE_SYSCALL_IDX)
 213 #define STRACE_DEBUG_P(sd)      STRACE_P (sd, TRACE_DEBUG_IDX)
 214 \f
 215 /* CPU tracing support.  */
 216
 217 #define CPU_TRACE_FLAGS(cpu) TRACE_FLAGS (CPU_TRACE_DATA (cpu))
 218
 219 /* Return non-zero if tracing of IDX is enabled for CPU.  */
 220 #define TRACE_P(cpu,idx) \
 221   (WITH_TRACE_P (idx) && CPU_TRACE_FLAGS (cpu)[idx] != 0)
 222
 223 /* Non-zero if --trace-<xxxx> was specified for CPU.  */
 224 #define TRACE_ANY_P(cpu)        (WITH_TRACE_ANY_P && (CPU_TRACE_DATA (cpu)->trace_any_p))
 225 #define TRACE_INSN_P(cpu)       TRACE_P (cpu, TRACE_INSN_IDX)
 226 #define TRACE_DECODE_P(cpu)     TRACE_P (cpu, TRACE_DECODE_IDX)
 227 #define TRACE_EXTRACT_P(cpu)    TRACE_P (cpu, TRACE_EXTRACT_IDX)
 228 #define TRACE_LINENUM_P(cpu)    TRACE_P (cpu, TRACE_LINENUM_IDX)
 229 #define TRACE_MEMORY_P(cpu)     TRACE_P (cpu, TRACE_MEMORY_IDX)
 230 #define TRACE_MODEL_P(cpu)      TRACE_P (cpu, TRACE_MODEL_IDX)
 231 #define TRACE_ALU_P(cpu)        TRACE_P (cpu, TRACE_ALU_IDX)
 232 #define TRACE_CORE_P(cpu)       TRACE_P (cpu, TRACE_CORE_IDX)
 233 #define TRACE_EVENTS_P(cpu)     TRACE_P (cpu, TRACE_EVENTS_IDX)
 234 #define TRACE_FPU_P(cpu)        TRACE_P (cpu, TRACE_FPU_IDX)
 235 #define TRACE_VPU_P(cpu)        TRACE_P (cpu, TRACE_VPU_IDX)
 236 #define TRACE_BRANCH_P(cpu)     TRACE_P (cpu, TRACE_BRANCH_IDX)
 237 #define TRACE_SYSCALL_P(cpu)    TRACE_P (cpu, TRACE_SYSCALL_IDX)
 238 #define TRACE_DEBUG_P(cpu)      TRACE_P (cpu, TRACE_DEBUG_IDX)
 239
 240 /* Helper functions for printing messages.  */
 241 #define TRACE(cpu, idx, fmt, args...) \
 242   do { \
 243     if (TRACE_P (cpu, idx)) \
 244       trace_generic (CPU_STATE (cpu), cpu, idx, fmt, ## args); \
 245   } while (0)
 246 #define TRACE_INSN(cpu, fmt, args...)           TRACE (cpu, TRACE_INSN_IDX, fmt, ## args)
 247 #define TRACE_DECODE(cpu, fmt, args...)         TRACE (cpu, TRACE_DECODE_IDX, fmt, ## args)
 248 #define TRACE_EXTRACT(cpu, fmt, args...)        TRACE (cpu, TRACE_EXTRACT_IDX, fmt, ## args)
 249 #define TRACE_LINENUM(cpu, fmt, args...)        TRACE (cpu, TRACE_LINENUM_IDX, fmt, ## args)
 250 #define TRACE_MEMORY(cpu, fmt, args...)         TRACE (cpu, TRACE_MEMORY_IDX, fmt, ## args)
 251 #define TRACE_MODEL(cpu, fmt, args...)          TRACE (cpu, TRACE_MODEL_IDX, fmt, ## args)
 252 #define TRACE_ALU(cpu, fmt, args...)            TRACE (cpu, TRACE_ALU_IDX, fmt, ## args)
 253 #define TRACE_CORE(cpu, fmt, args...)           TRACE (cpu, TRACE_CORE_IDX, fmt, ## args)
 254 #define TRACE_EVENTS(cpu, fmt, args...)         TRACE (cpu, TRACE_EVENTS_IDX, fmt, ## args)
 255 #define TRACE_FPU(cpu, fmt, args...)            TRACE (cpu, TRACE_FPU_IDX, fmt, ## args)
 256 #define TRACE_VPU(cpu, fmt, args...)            TRACE (cpu, TRACE_VPU_IDX, fmt, ## args)
 257 #define TRACE_BRANCH(cpu, fmt, args...)         TRACE (cpu, TRACE_BRANCH_IDX, fmt, ## args)
 258 #define TRACE_SYSCALL(cpu, fmt, args...)        TRACE (cpu, TRACE_SYSCALL_IDX, fmt, ## args)
 259 #define TRACE_DEBUG(cpu, fmt, args...)          TRACE (cpu, TRACE_DEBUG_IDX, fmt, ## args)
 260 \f
 261 /* Tracing functions.  */
 262
 263 /* Prime the trace buffers ready for any trace output.
 264    Must be called prior to any other trace operation */
 265 extern void trace_prefix (SIM_DESC sd,
 266                           sim_cpu *cpu,
 267                           sim_cia cia,
 268                           address_word pc,
 269                           int print_linenum_p,
 270                           const char *file_name,
 271                           int line_nr,
 272                           const char *fmt,
 273                           ...)
 274        __attribute__((format (printf, 8, 9)));
 275
 276 /* Generic trace print, assumes trace_prefix() has been called */
 277
 278 extern void trace_generic (SIM_DESC sd,
 279                            sim_cpu *cpu,
 280                            int trace_idx,
 281                            const char *fmt,
 282                            ...)
 283      __attribute__((format (printf, 4, 5)));
 284
 285 typedef enum {
 286   trace_fmt_invalid,
 287   trace_fmt_word,
 288   trace_fmt_fp,
 289   trace_fmt_fpu,
 290   trace_fmt_string,
 291   trace_fmt_bool,
 292   trace_fmt_addr,
 293   trace_fmt_instruction_incomplete,
 294 } data_fmt;
 295
 296 /* Trace a varying number of word sized inputs/outputs.  trace_result*
 297    must be called to close the trace operation. */
 298
 299 extern void save_data (SIM_DESC sd,
 300                        TRACE_DATA *data,
 301                        data_fmt fmt,
 302                        long size,
 303                        const void *buf);
 304
 305 extern void trace_input0 (SIM_DESC sd,
 306                           sim_cpu *cpu,
 307                           int trace_idx);
 308
 309 extern void trace_input_word1 (SIM_DESC sd,
 310                                sim_cpu *cpu,
 311                                int trace_idx,
 312                                unsigned_word d0);
 313
 314 extern void trace_input_word2 (SIM_DESC sd,
 315                                sim_cpu *cpu,
 316                                int trace_idx,
 317                                unsigned_word d0,
 318                                unsigned_word d1);
 319
 320 extern void trace_input_word3 (SIM_DESC sd,
 321                                        sim_cpu *cpu,
 322                                        int trace_idx,
 323                                        unsigned_word d0,
 324                                        unsigned_word d1,
 325                                        unsigned_word d2);
 326
 327 extern void trace_input_word4 (SIM_DESC sd,
 328                                sim_cpu *cpu,
 329                                int trace_idx,
 330                                unsigned_word d0,
 331                                unsigned_word d1,
 332                                unsigned_word d2,
 333                                unsigned_word d3);
 334
 335 extern void trace_input_addr1 (SIM_DESC sd,
 336                                sim_cpu *cpu,
 337                                int trace_idx,
 338                                address_word d0);
 339
 340 extern void trace_input_bool1 (SIM_DESC sd,
 341                                sim_cpu *cpu,
 342                                int trace_idx,
 343                                int d0);
 344
 345 extern void trace_input_fp1 (SIM_DESC sd,
 346                              sim_cpu *cpu,
 347                              int trace_idx,
 348                              fp_word f0);
 349
 350 extern void trace_input_fp2 (SIM_DESC sd,
 351                              sim_cpu *cpu,
 352                              int trace_idx,
 353                              fp_word f0,
 354                              fp_word f1);
 355
 356 extern void trace_input_fp3 (SIM_DESC sd,
 357                              sim_cpu *cpu,
 358                              int trace_idx,
 359                              fp_word f0,
 360                              fp_word f1,
 361                              fp_word f2);
 362
 363 extern void trace_input_fpu1 (SIM_DESC sd,
 364                               sim_cpu *cpu,
 365                               int trace_idx,
 366                               struct _sim_fpu *f0);
 367
 368 extern void trace_input_fpu2 (SIM_DESC sd,
 369                               sim_cpu *cpu,
 370                               int trace_idx,
 371                               struct _sim_fpu *f0,
 372                               struct _sim_fpu *f1);
 373
 374 extern void trace_input_fpu3 (SIM_DESC sd,
 375                               sim_cpu *cpu,
 376                               int trace_idx,
 377                               struct _sim_fpu *f0,
 378                               struct _sim_fpu *f1,
 379                               struct _sim_fpu *f2);
 380
 381 /* Other trace_input{_<fmt><nr-inputs>} functions can go here */
 382
 383 extern void trace_result0 (SIM_DESC sd,
 384                            sim_cpu *cpu,
 385                            int trace_idx);
 386
 387 extern void trace_result_word1 (SIM_DESC sd,
 388                                 sim_cpu *cpu,
 389                                 int trace_idx,
 390                                 unsigned_word r0);
 391
 392 extern void trace_result_word2 (SIM_DESC sd,
 393                                 sim_cpu *cpu,
 394                                 int trace_idx,
 395                                 unsigned_word r0,
 396                                 unsigned_word r1);
 397
 398 extern void trace_result_word4 (SIM_DESC sd,
 399                                 sim_cpu *cpu,
 400                                 int trace_idx,
 401                                 unsigned_word r0,
 402                                 unsigned_word r1,
 403                                 unsigned_word r2,
 404                                 unsigned_word r3);
 405
 406 extern void trace_result_bool1 (SIM_DESC sd,
 407                                 sim_cpu *cpu,
 408                                 int trace_idx,
 409                                 int r0);
 410
 411 extern void trace_result_addr1 (SIM_DESC sd,
 412                                 sim_cpu *cpu,
 413                                 int trace_idx,
 414                                 address_word r0);
 415
 416 extern void trace_result_fp1 (SIM_DESC sd,
 417                               sim_cpu *cpu,
 418                               int trace_idx,
 419                               fp_word f0);
 420
 421 extern void trace_result_fp2 (SIM_DESC sd,
 422                               sim_cpu *cpu,
 423                               int trace_idx,
 424                               fp_word f0,
 425                               fp_word f1);
 426
 427 extern void trace_result_fpu1 (SIM_DESC sd,
 428                                sim_cpu *cpu,
 429                                int trace_idx,
 430                                struct _sim_fpu *f0);
 431
 432 extern void trace_result_string1 (SIM_DESC sd,
 433                                   sim_cpu *cpu,
 434                                   int trace_idx,
 435                                   char *str0);
 436
 437 extern void trace_result_word1_string1 (SIM_DESC sd,
 438                                         sim_cpu *cpu,
 439                                         int trace_idx,
 440                                         unsigned_word r0,
 441                                         char *s0);
 442
 443 /* Other trace_result{_<type><nr-results>} */
 444
 445
 446 /* Macros for tracing ALU instructions */
 447
 448 #define TRACE_ALU_INPUT0() \
 449 do { \
 450   if (TRACE_ALU_P (CPU)) \
 451     trace_input0 (SD, CPU, TRACE_ALU_IDX); \
 452 } while (0)
 453
 454 #define TRACE_ALU_INPUT1(V0) \
 455 do { \
 456   if (TRACE_ALU_P (CPU)) \
 457     trace_input_word1 (SD, CPU, TRACE_ALU_IDX, (V0)); \
 458 } while (0)
 459
 460 #define TRACE_ALU_INPUT2(V0,V1) \
 461 do { \
 462   if (TRACE_ALU_P (CPU)) \
 463     trace_input_word2 (SD, CPU, TRACE_ALU_IDX, (V0), (V1)); \
 464 } while (0)
 465
 466 #define TRACE_ALU_INPUT3(V0,V1,V2) \
 467 do { \
 468   if (TRACE_ALU_P (CPU)) \
 469     trace_input_word3 (SD, CPU, TRACE_ALU_IDX, (V0), (V1), (V2)); \
 470 } while (0)
 471
 472 #define TRACE_ALU_INPUT4(V0,V1,V2,V3) \
 473 do { \
 474   if (TRACE_ALU_P (CPU)) \
 475     trace_input_word4 (SD, CPU, TRACE_ALU_IDX, (V0), (V1), (V2), (V3)); \
 476 } while (0)
 477
 478 #define TRACE_ALU_RESULT(R0) TRACE_ALU_RESULT1(R0)
 479
 480 #define TRACE_ALU_RESULT0() \
 481 do { \
 482   if (TRACE_ALU_P (CPU)) \
 483     trace_result0 (SD, CPU, TRACE_ALU_IDX); \
 484 } while (0)
 485
 486 #define TRACE_ALU_RESULT1(R0) \
 487 do { \
 488   if (TRACE_ALU_P (CPU)) \
 489     trace_result_word1 (SD, CPU, TRACE_ALU_IDX, (R0)); \
 490 } while (0)
 491
 492 #define TRACE_ALU_RESULT2(R0,R1) \
 493 do { \
 494   if (TRACE_ALU_P (CPU)) \
 495     trace_result_word2 (SD, CPU, TRACE_ALU_IDX, (R0), (R1)); \
 496 } while (0)
 497
 498 #define TRACE_ALU_RESULT4(R0,R1,R2,R3) \
 499 do { \
 500   if (TRACE_ALU_P (CPU)) \
 501     trace_result_word4 (SD, CPU, TRACE_ALU_IDX, (R0), (R1), (R2), (R3)); \
 502 } while (0)
 503
 504 /* Macros for tracing inputs to comparative branch instructions. */
 505
 506 #define TRACE_BRANCH_INPUT1(V0) \
 507 do { \
 508   if (TRACE_BRANCH_P (CPU)) \
 509     trace_input_word1 (SD, CPU, TRACE_BRANCH_IDX, (V0)); \
 510 } while (0)
 511
 512 #define TRACE_BRANCH_INPUT2(V0,V1) \
 513 do { \
 514   if (TRACE_BRANCH_P (CPU)) \
 515     trace_input_word2 (SD, CPU, TRACE_BRANCH_IDX, (V0), (V1)); \
 516 } while (0)
 517
 518 /* Macros for tracing FPU instructions */
 519
 520 #define TRACE_FP_INPUT0() \
 521 do { \
 522   if (TRACE_FPU_P (CPU)) \
 523     trace_input0 (SD, CPU, TRACE_FPU_IDX); \
 524 } while (0)
 525
 526 #define TRACE_FP_INPUT1(V0) \
 527 do { \
 528   if (TRACE_FPU_P (CPU)) \
 529     trace_input_fp1 (SD, CPU, TRACE_FPU_IDX, (V0)); \
 530 } while (0)
 531
 532 #define TRACE_FP_INPUT2(V0,V1) \
 533 do { \
 534   if (TRACE_FPU_P (CPU)) \
 535     trace_input_fp2 (SD, CPU, TRACE_FPU_IDX, (V0), (V1)); \
 536 } while (0)
 537
 538 #define TRACE_FP_INPUT3(V0,V1,V2) \
 539 do { \
 540   if (TRACE_FPU_P (CPU)) \
 541     trace_input_fp3 (SD, CPU, TRACE_FPU_IDX, (V0), (V1), (V2)); \
 542 } while (0)
 543
 544 #define TRACE_FP_INPUT_WORD1(V0) \
 545 do { \
 546   if (TRACE_FPU_P (CPU)) \
 547     trace_input_word1 (SD, CPU, TRACE_FPU_IDX, (V0)); \
 548 } while (0)
 549
 550 #define TRACE_FP_RESULT(R0) \
 551 do { \
 552   if (TRACE_FPU_P (CPU)) \
 553     trace_result_fp1 (SD, CPU, TRACE_FPU_IDX, (R0)); \
 554 } while (0)
 555
 556 #define TRACE_FP_RESULT2(R0,R1) \
 557 do { \
 558   if (TRACE_FPU_P (CPU)) \
 559     trace_result_fp2 (SD, CPU, TRACE_FPU_IDX, (R0), (R1)); \
 560 } while (0)
 561
 562 #define TRACE_FP_RESULT_BOOL(R0) \
 563 do { \
 564   if (TRACE_FPU_P (CPU)) \
 565     trace_result_bool1 (SD, CPU, TRACE_FPU_IDX, (R0)); \
 566 } while (0)
 567
 568 #define TRACE_FP_RESULT_WORD(R0) \
 569 do { \
 570   if (TRACE_FPU_P (CPU)) \
 571     trace_result_word1 (SD, CPU, TRACE_FPU_IDX, (R0)); \
 572 } while (0)
 573
 574
 575 /* Macros for tracing branches */
 576
 577 #define TRACE_BRANCH_INPUT(COND) \
 578 do { \
 579   if (TRACE_BRANCH_P (CPU)) \
 580     trace_input_bool1 (SD, CPU, TRACE_BRANCH_IDX, (COND)); \
 581 } while (0)
 582
 583 #define TRACE_BRANCH_RESULT(DEST) \
 584 do { \
 585   if (TRACE_BRANCH_P (CPU)) \
 586     trace_result_addr1 (SD, CPU, TRACE_BRANCH_IDX, (DEST)); \
 587 } while (0)
 588
 589 \f
 590 /* The function trace_one_insn has been replaced by the function pair
 591    trace_prefix() + trace_generic() */
 592 extern void trace_one_insn (SIM_DESC sd,
 593                             sim_cpu * cpu,
 594                             address_word cia,
 595                             int print_linenum_p,
 596                             const char *file_name,
 597                             int line_nr,
 598                             const char *unit,
 599                             const char *fmt,
 600                             ...)
 601      __attribute__((format (printf, 8, 9)));
 602
 603 extern void trace_printf (SIM_DESC, sim_cpu *, const char *, ...)
 604      __attribute__((format (printf, 3, 4)));
 605
 606 extern void trace_vprintf (SIM_DESC, sim_cpu *, const char *, va_list);
 607
 608 /* Debug support.
 609    This is included here because there isn't enough of it to justify
 610    a sim-debug.h.  */
 611
 612 /* Return non-zero if debugging of IDX for CPU is enabled.  */
 613 #define DEBUG_P(cpu, idx) \
 614 ((WITH_DEBUG & (1 << (idx))) != 0 \
 615  && CPU_DEBUG_FLAGS (cpu)[idx] != 0)
 616
 617 /* Non-zero if "--debug-insn" specified.  */
 618 #define DEBUG_INSN_P(cpu) DEBUG_P (cpu, DEBUG_INSN_IDX)
 619
 620 /* GDB also has a debug_printf, so we shadow ours.  */
 621 #define debug_printf sim_debug_printf
 622
 623 extern void debug_printf (sim_cpu *, const char *, ...)
 624      __attribute__((format (printf, 2, 3)));
 625
 626 #endif /* SIM_TRACE_H */