sim/common/sim-trace.h

   1 /* Simulator tracing/debugging support.
   2    Copyright (C) 1997-1998, 2001, 2007-2012 Free Software Foundation,
   3    Inc.
   4    Contributed by Cygnus Support.
   5
   6 This file is part of GDB, the GNU debugger.
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 3 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 /* This file is meant to be included by sim-basics.h.  */
  22
  23 #ifndef SIM_TRACE_H
  24 #define SIM_TRACE_H
  25
  26 /* Standard traceable entities.  */
  27
  28 enum {
  29   /* Trace insn execution.  */
  30   TRACE_INSN_IDX = 1,
  31
  32   /* Trace insn decoding.
  33      ??? This is more of a simulator debugging operation and might best be
  34      moved to --debug-decode.  */
  35   TRACE_DECODE_IDX,
  36
  37   /* Trace insn extraction.
  38      ??? This is more of a simulator debugging operation and might best be
  39      moved to --debug-extract.  */
  40   TRACE_EXTRACT_IDX,
  41
  42   /* Trace insn execution but include line numbers.  */
  43   TRACE_LINENUM_IDX,
  44
  45   /* Trace memory operations.
  46      The difference between this and TRACE_CORE_IDX is (I think) that this
  47      is intended to apply to a higher level.  TRACE_CORE_IDX applies to the
  48      low level core operations.  */
  49   TRACE_MEMORY_IDX,
  50
  51   /* Include model performance data in tracing output.  */
  52   TRACE_MODEL_IDX,
  53
  54   /* Trace ALU operations.  */
  55   TRACE_ALU_IDX,
  56
  57   /* Trace memory core operations.  */
  58   TRACE_CORE_IDX,
  59
  60   /* Trace events.  */
  61   TRACE_EVENTS_IDX,
  62
  63   /* Trace fpu operations.  */
  64   TRACE_FPU_IDX,
  65
  66   /* Trace vpu operations.  */
  67   TRACE_VPU_IDX,
  68
  69   /* Trace branching.  */
  70   TRACE_BRANCH_IDX,
  71
  72   /* Trace syscalls.  */
  73   TRACE_SYSCALL_IDX,
  74
  75   /* Add information useful for debugging the simulator to trace output.  */
  76   TRACE_DEBUG_IDX,
  77
  78   /* Simulator specific trace bits begin here.  */
  79   TRACE_NEXT_IDX,
  80
  81 };
  82 /* Maximum number of traceable entities.  */
  83 #ifndef MAX_TRACE_VALUES
  84 #define MAX_TRACE_VALUES 32
  85 #endif
  86
  87 /* The -t option only prints useful values.  It's easy to type and shouldn't
  88    splat on the screen everything under the sun making nothing easy to
  89    find.  */
  90 #define TRACE_USEFUL_MASK \
  91 ((1 << TRACE_INSN_IDX) \
  92  | (1 << TRACE_LINENUM_IDX) \
  93  | (1 << TRACE_MEMORY_IDX) \
  94  | (1 << TRACE_MODEL_IDX))
  95 \f
  96 /* Masks so WITH_TRACE can have symbolic values.
  97    The case choice here is on purpose.  The lowercase parts are args to
  98    --with-trace.  */
  99 #define TRACE_insn     (1 << TRACE_INSN_IDX)
 100 #define TRACE_decode   (1 << TRACE_DECODE_IDX)
 101 #define TRACE_extract  (1 << TRACE_EXTRACT_IDX)
 102 #define TRACE_linenum  (1 << TRACE_LINENUM_IDX)
 103 #define TRACE_memory   (1 << TRACE_MEMORY_IDX)
 104 #define TRACE_model    (1 << TRACE_MODEL_IDX)
 105 #define TRACE_alu      (1 << TRACE_ALU_IDX)
 106 #define TRACE_core     (1 << TRACE_CORE_IDX)
 107 #define TRACE_events   (1 << TRACE_EVENTS_IDX)
 108 #define TRACE_fpu      (1 << TRACE_FPU_IDX)
 109 #define TRACE_vpu      (1 << TRACE_VPU_IDX)
 110 #define TRACE_branch   (1 << TRACE_BRANCH_IDX)
 111 #define TRACE_syscall  (1 << TRACE_SYSCALL_IDX)
 112 #define TRACE_debug    (1 << TRACE_DEBUG_IDX)
 113
 114 /* Preprocessor macros to simplify tests of WITH_TRACE.  */
 115 #define WITH_TRACE_INSN_P       (WITH_TRACE & TRACE_insn)
 116 #define WITH_TRACE_DECODE_P     (WITH_TRACE & TRACE_decode)
 117 #define WITH_TRACE_EXTRACT_P    (WITH_TRACE & TRACE_extract)
 118 #define WITH_TRACE_LINENUM_P    (WITH_TRACE & TRACE_linenum)
 119 #define WITH_TRACE_MEMORY_P     (WITH_TRACE & TRACE_memory)
 120 #define WITH_TRACE_MODEL_P      (WITH_TRACE & TRACE_model)
 121 #define WITH_TRACE_ALU_P        (WITH_TRACE & TRACE_alu)
 122 #define WITH_TRACE_CORE_P       (WITH_TRACE & TRACE_core)
 123 #define WITH_TRACE_EVENTS_P     (WITH_TRACE & TRACE_events)
 124 #define WITH_TRACE_FPU_P        (WITH_TRACE & TRACE_fpu)
 125 #define WITH_TRACE_VPU_P        (WITH_TRACE & TRACE_vpu)
 126 #define WITH_TRACE_BRANCH_P     (WITH_TRACE & TRACE_branch)
 127 #define WITH_TRACE_SYSCALL_P    (WITH_TRACE & TRACE_syscall)
 128 #define WITH_TRACE_DEBUG_P      (WITH_TRACE & TRACE_debug)
 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 & (1 << (idx))) != 0 \
 197  && STATE_TRACE_FLAGS (sd)[idx] != 0)
 198
 199 /* Non-zero if --trace-<xxxx> was specified for SD.  */
 200 #define STRACE_DEBUG_P(sd)      STRACE_P (sd, TRACE_DEBUG_IDX)
 201 \f
 202 /* CPU tracing support.  */
 203
 204 #define CPU_TRACE_FLAGS(cpu) TRACE_FLAGS (CPU_TRACE_DATA (cpu))
 205
 206 /* Return non-zero if tracing of IDX is enabled for CPU.  */
 207 #define TRACE_P(cpu,idx) \
 208 ((WITH_TRACE & (1 << (idx))) != 0 \
 209  && CPU_TRACE_FLAGS (cpu)[idx] != 0)
 210
 211 /* Non-zero if --trace-<xxxx> was specified for CPU.  */
 212 #define TRACE_ANY_P(cpu)        ((WITH_TRACE) && (CPU_TRACE_DATA (cpu)->trace_any_p))
 213 #define TRACE_INSN_P(cpu)       TRACE_P (cpu, TRACE_INSN_IDX)
 214 #define TRACE_DECODE_P(cpu)     TRACE_P (cpu, TRACE_DECODE_IDX)
 215 #define TRACE_EXTRACT_P(cpu)    TRACE_P (cpu, TRACE_EXTRACT_IDX)
 216 #define TRACE_LINENUM_P(cpu)    TRACE_P (cpu, TRACE_LINENUM_IDX)
 217 #define TRACE_MEMORY_P(cpu)     TRACE_P (cpu, TRACE_MEMORY_IDX)
 218 #define TRACE_MODEL_P(cpu)      TRACE_P (cpu, TRACE_MODEL_IDX)
 219 #define TRACE_ALU_P(cpu)        TRACE_P (cpu, TRACE_ALU_IDX)
 220 #define TRACE_CORE_P(cpu)       TRACE_P (cpu, TRACE_CORE_IDX)
 221 #define TRACE_EVENTS_P(cpu)     TRACE_P (cpu, TRACE_EVENTS_IDX)
 222 #define TRACE_FPU_P(cpu)        TRACE_P (cpu, TRACE_FPU_IDX)
 223 #define TRACE_VPU_P(cpu)        TRACE_P (cpu, TRACE_VPU_IDX)
 224 #define TRACE_BRANCH_P(cpu)     TRACE_P (cpu, TRACE_BRANCH_IDX)
 225 #define TRACE_SYSCALL_P(cpu)    TRACE_P (cpu, TRACE_SYSCALL_IDX)
 226 #define TRACE_DEBUG_P(cpu)      TRACE_P (cpu, TRACE_DEBUG_IDX)
 227 \f
 228 /* Tracing functions.  */
 229
 230 /* Prime the trace buffers ready for any trace output.
 231    Must be called prior to any other trace operation */
 232 extern void trace_prefix PARAMS ((SIM_DESC sd,
 233                                   sim_cpu *cpu,
 234                                   sim_cia cia,
 235                                   address_word pc,
 236                                   int print_linenum_p,
 237                                   const char *file_name,
 238                                   int line_nr,
 239                                   const char *fmt,
 240                                   ...))
 241        __attribute__((format (printf, 8, 9)));
 242
 243 /* Generic trace print, assumes trace_prefix() has been called */
 244
 245 extern void trace_generic PARAMS ((SIM_DESC sd,
 246                                    sim_cpu *cpu,
 247                                    int trace_idx,
 248                                    const char *fmt,
 249                                    ...))
 250      __attribute__((format (printf, 4, 5)));
 251
 252 typedef enum {
 253   trace_fmt_invalid,
 254   trace_fmt_word,
 255   trace_fmt_fp,
 256   trace_fmt_fpu,
 257   trace_fmt_string,
 258   trace_fmt_bool,
 259   trace_fmt_addr,
 260   trace_fmt_instruction_incomplete,
 261 } data_fmt;
 262
 263 /* Trace a varying number of word sized inputs/outputs.  trace_result*
 264    must be called to close the trace operation. */
 265
 266 extern void save_data PARAMS ((SIM_DESC sd,
 267                                TRACE_DATA *data,
 268                                data_fmt fmt,
 269                                long size,
 270                                const void *buf));
 271
 272 extern void trace_input0 PARAMS ((SIM_DESC sd,
 273                                   sim_cpu *cpu,
 274                                   int trace_idx));
 275
 276 extern void trace_input_word1 PARAMS ((SIM_DESC sd,
 277                                        sim_cpu *cpu,
 278                                        int trace_idx,
 279                                        unsigned_word d0));
 280
 281 extern void trace_input_word2 PARAMS ((SIM_DESC sd,
 282                                        sim_cpu *cpu,
 283                                        int trace_idx,
 284                                        unsigned_word d0,
 285                                        unsigned_word d1));
 286
 287 extern void trace_input_word3 PARAMS ((SIM_DESC sd,
 288                                        sim_cpu *cpu,
 289                                        int trace_idx,
 290                                        unsigned_word d0,
 291                                        unsigned_word d1,
 292                                        unsigned_word d2));
 293
 294 extern void trace_input_word4 PARAMS ((SIM_DESC sd,
 295                                        sim_cpu *cpu,
 296                                        int trace_idx,
 297                                        unsigned_word d0,
 298                                        unsigned_word d1,
 299                                        unsigned_word d2,
 300                                        unsigned_word d3));
 301
 302 extern void trace_input_addr1 PARAMS ((SIM_DESC sd,
 303                                        sim_cpu *cpu,
 304                                        int trace_idx,
 305                                        address_word d0));
 306
 307 extern void trace_input_bool1 PARAMS ((SIM_DESC sd,
 308                                        sim_cpu *cpu,
 309                                        int trace_idx,
 310                                        int d0));
 311
 312 extern void trace_input_fp1 PARAMS ((SIM_DESC sd,
 313                                      sim_cpu *cpu,
 314                                      int trace_idx,
 315                                      fp_word f0));
 316
 317 extern void trace_input_fp2 PARAMS ((SIM_DESC sd,
 318                                      sim_cpu *cpu,
 319                                      int trace_idx,
 320                                      fp_word f0,
 321                                      fp_word f1));
 322
 323 extern void trace_input_fp3 PARAMS ((SIM_DESC sd,
 324                                      sim_cpu *cpu,
 325                                      int trace_idx,
 326                                      fp_word f0,
 327                                      fp_word f1,
 328                                      fp_word f2));
 329
 330 extern void trace_input_fpu1 PARAMS ((SIM_DESC sd,
 331                                      sim_cpu *cpu,
 332                                      int trace_idx,
 333                                      struct _sim_fpu *f0));
 334
 335 extern void trace_input_fpu2 PARAMS ((SIM_DESC sd,
 336                                      sim_cpu *cpu,
 337                                      int trace_idx,
 338                                      struct _sim_fpu *f0,
 339                                      struct _sim_fpu *f1));
 340
 341 extern void trace_input_fpu3 PARAMS ((SIM_DESC sd,
 342                                      sim_cpu *cpu,
 343                                      int trace_idx,
 344                                      struct _sim_fpu *f0,
 345                                      struct _sim_fpu *f1,
 346                                      struct _sim_fpu *f2));
 347
 348 /* Other trace_input{_<fmt><nr-inputs>} functions can go here */
 349
 350 extern void trace_result0 PARAMS ((SIM_DESC sd,
 351                                    sim_cpu *cpu,
 352                                    int trace_idx));
 353
 354 extern void trace_result_word1 PARAMS ((SIM_DESC sd,
 355                                         sim_cpu *cpu,
 356                                         int trace_idx,
 357                                         unsigned_word r0));
 358
 359 extern void trace_result_word2 PARAMS ((SIM_DESC sd,
 360                                         sim_cpu *cpu,
 361                                         int trace_idx,
 362                                         unsigned_word r0,
 363                                         unsigned_word r1));
 364
 365 extern void trace_result_word4 PARAMS ((SIM_DESC sd,
 366                                         sim_cpu *cpu,
 367                                         int trace_idx,
 368                                         unsigned_word r0,
 369                                         unsigned_word r1,
 370                                         unsigned_word r2,
 371                                         unsigned_word r3));
 372
 373 extern void trace_result_bool1 PARAMS ((SIM_DESC sd,
 374                                         sim_cpu *cpu,
 375                                         int trace_idx,
 376                                         int r0));
 377
 378 extern void trace_result_addr1 PARAMS ((SIM_DESC sd,
 379                                         sim_cpu *cpu,
 380                                         int trace_idx,
 381                                         address_word r0));
 382
 383 extern void trace_result_fp1 PARAMS ((SIM_DESC sd,
 384                                       sim_cpu *cpu,
 385                                       int trace_idx,
 386                                       fp_word f0));
 387
 388 extern void trace_result_fp2 PARAMS ((SIM_DESC sd,
 389                                       sim_cpu *cpu,
 390                                       int trace_idx,
 391                                       fp_word f0,
 392                                       fp_word f1));
 393
 394 extern void trace_result_fpu1 PARAMS ((SIM_DESC sd,
 395                                        sim_cpu *cpu,
 396                                        int trace_idx,
 397                                        struct _sim_fpu *f0));
 398
 399 extern void trace_result_string1 PARAMS ((SIM_DESC sd,
 400                                           sim_cpu *cpu,
 401                                           int trace_idx,
 402                                           char *str0));
 403
 404 extern void trace_result_word1_string1 PARAMS ((SIM_DESC sd,
 405                                                 sim_cpu *cpu,
 406                                                 int trace_idx,
 407                                                 unsigned_word r0,
 408                                                 char *s0));
 409
 410 /* Other trace_result{_<type><nr-results>} */
 411
 412
 413 /* Macros for tracing ALU instructions */
 414
 415 #define TRACE_ALU_INPUT0() \
 416 do { \
 417   if (TRACE_ALU_P (CPU)) \
 418     trace_input0 (SD, CPU, TRACE_ALU_IDX); \
 419 } while (0)
 420
 421 #define TRACE_ALU_INPUT1(V0) \
 422 do { \
 423   if (TRACE_ALU_P (CPU)) \
 424     trace_input_word1 (SD, CPU, TRACE_ALU_IDX, (V0)); \
 425 } while (0)
 426
 427 #define TRACE_ALU_INPUT2(V0,V1) \
 428 do { \
 429   if (TRACE_ALU_P (CPU)) \
 430     trace_input_word2 (SD, CPU, TRACE_ALU_IDX, (V0), (V1)); \
 431 } while (0)
 432
 433 #define TRACE_ALU_INPUT3(V0,V1,V2) \
 434 do { \
 435   if (TRACE_ALU_P (CPU)) \
 436     trace_input_word3 (SD, CPU, TRACE_ALU_IDX, (V0), (V1), (V2)); \
 437 } while (0)
 438
 439 #define TRACE_ALU_INPUT4(V0,V1,V2,V3) \
 440 do { \
 441   if (TRACE_ALU_P (CPU)) \
 442     trace_input_word4 (SD, CPU, TRACE_ALU_IDX, (V0), (V1), (V2), (V3)); \
 443 } while (0)
 444
 445 #define TRACE_ALU_RESULT(R0) TRACE_ALU_RESULT1(R0)
 446
 447 #define TRACE_ALU_RESULT0() \
 448 do { \
 449   if (TRACE_ALU_P (CPU)) \
 450     trace_result0 (SD, CPU, TRACE_ALU_IDX); \
 451 } while (0)
 452
 453 #define TRACE_ALU_RESULT1(R0) \
 454 do { \
 455   if (TRACE_ALU_P (CPU)) \
 456     trace_result_word1 (SD, CPU, TRACE_ALU_IDX, (R0)); \
 457 } while (0)
 458
 459 #define TRACE_ALU_RESULT2(R0,R1) \
 460 do { \
 461   if (TRACE_ALU_P (CPU)) \
 462     trace_result_word2 (SD, CPU, TRACE_ALU_IDX, (R0), (R1)); \
 463 } while (0)
 464
 465 #define TRACE_ALU_RESULT4(R0,R1,R2,R3) \
 466 do { \
 467   if (TRACE_ALU_P (CPU)) \
 468     trace_result_word4 (SD, CPU, TRACE_ALU_IDX, (R0), (R1), (R2), (R3)); \
 469 } while (0)
 470
 471 /* Macros for tracing inputs to comparative branch instructions. */
 472
 473 #define TRACE_BRANCH_INPUT1(V0) \
 474 do { \
 475   if (TRACE_BRANCH_P (CPU)) \
 476     trace_input_word1 (SD, CPU, TRACE_BRANCH_IDX, (V0)); \
 477 } while (0)
 478
 479 #define TRACE_BRANCH_INPUT2(V0,V1) \
 480 do { \
 481   if (TRACE_BRANCH_P (CPU)) \
 482     trace_input_word2 (SD, CPU, TRACE_BRANCH_IDX, (V0), (V1)); \
 483 } while (0)
 484
 485 /* Macros for tracing FPU instructions */
 486
 487 #define TRACE_FP_INPUT0() \
 488 do { \
 489   if (TRACE_FPU_P (CPU)) \
 490     trace_input0 (SD, CPU, TRACE_FPU_IDX); \
 491 } while (0)
 492
 493 #define TRACE_FP_INPUT1(V0) \
 494 do { \
 495   if (TRACE_FPU_P (CPU)) \
 496     trace_input_fp1 (SD, CPU, TRACE_FPU_IDX, (V0)); \
 497 } while (0)
 498
 499 #define TRACE_FP_INPUT2(V0,V1) \
 500 do { \
 501   if (TRACE_FPU_P (CPU)) \
 502     trace_input_fp2 (SD, CPU, TRACE_FPU_IDX, (V0), (V1)); \
 503 } while (0)
 504
 505 #define TRACE_FP_INPUT3(V0,V1,V2) \
 506 do { \
 507   if (TRACE_FPU_P (CPU)) \
 508     trace_input_fp3 (SD, CPU, TRACE_FPU_IDX, (V0), (V1), (V2)); \
 509 } while (0)
 510
 511 #define TRACE_FP_INPUT_WORD1(V0) \
 512 do { \
 513   if (TRACE_FPU_P (CPU)) \
 514     trace_input_word1 (SD, CPU, TRACE_FPU_IDX, (V0)); \
 515 } while (0)
 516
 517 #define TRACE_FP_RESULT(R0) \
 518 do { \
 519   if (TRACE_FPU_P (CPU)) \
 520     trace_result_fp1 (SD, CPU, TRACE_FPU_IDX, (R0)); \
 521 } while (0)
 522
 523 #define TRACE_FP_RESULT2(R0,R1) \
 524 do { \
 525   if (TRACE_FPU_P (CPU)) \
 526     trace_result_fp2 (SD, CPU, TRACE_FPU_IDX, (R0), (R1)); \
 527 } while (0)
 528
 529 #define TRACE_FP_RESULT_BOOL(R0) \
 530 do { \
 531   if (TRACE_FPU_P (CPU)) \
 532     trace_result_bool1 (SD, CPU, TRACE_FPU_IDX, (R0)); \
 533 } while (0)
 534
 535 #define TRACE_FP_RESULT_WORD(R0) \
 536 do { \
 537   if (TRACE_FPU_P (CPU)) \
 538     trace_result_word1 (SD, CPU, TRACE_FPU_IDX, (R0)); \
 539 } while (0)
 540
 541
 542 /* Macros for tracing branches */
 543
 544 #define TRACE_BRANCH_INPUT(COND) \
 545 do { \
 546   if (TRACE_BRANCH_P (CPU)) \
 547     trace_input_bool1 (SD, CPU, TRACE_BRANCH_IDX, (COND)); \
 548 } while (0)
 549
 550 #define TRACE_BRANCH_RESULT(DEST) \
 551 do { \
 552   if (TRACE_BRANCH_P (CPU)) \
 553     trace_result_addr1 (SD, CPU, TRACE_BRANCH_IDX, (DEST)); \
 554 } while (0)
 555
 556 \f
 557 /* The function trace_one_insn has been replaced by the function pair
 558    trace_prefix() + trace_generic() */
 559 extern void trace_one_insn PARAMS ((SIM_DESC sd,
 560                                     sim_cpu * cpu,
 561                                     address_word cia,
 562                                     int print_linenum_p,
 563                                     const char *file_name,
 564                                     int line_nr,
 565                                     const char *unit,
 566                                     const char *fmt,
 567                                     ...))
 568      __attribute__((format (printf, 8, 9)));
 569
 570 extern void trace_printf PARAMS ((SIM_DESC, sim_cpu *, const char *, ...))
 571      __attribute__((format (printf, 3, 4)));
 572
 573 extern void trace_vprintf PARAMS ((SIM_DESC, sim_cpu *, const char *, va_list));
 574
 575 /* Debug support.
 576    This is included here because there isn't enough of it to justify
 577    a sim-debug.h.  */
 578
 579 /* Return non-zero if debugging of IDX for CPU is enabled.  */
 580 #define DEBUG_P(cpu, idx) \
 581 ((WITH_DEBUG & (1 << (idx))) != 0 \
 582  && CPU_DEBUG_FLAGS (cpu)[idx] != 0)
 583
 584 /* Non-zero if "--debug-insn" specified.  */
 585 #define DEBUG_INSN_P(cpu) DEBUG_P (cpu, DEBUG_INSN_IDX)
 586
 587 extern void debug_printf PARAMS ((sim_cpu *, const char *, ...))
 588      __attribute__((format (printf, 2, 3)));
 589
 590 #endif /* SIM_TRACE_H */