[deliverable/binutils-gdb.git] / sim / common / sim-trace.h

/* Simulator tracing/debugging support.
   Copyright (C) 1997-2015 Free Software Foundation, Inc.
   Contributed by Cygnus Support.

This file is part of GDB, the GNU debugger.

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

/* This file is meant to be included by sim-basics.h.  */

#ifndef SIM_TRACE_H
#define SIM_TRACE_H

/* Standard traceable entities.  */

enum {
  /* Trace insn execution.  */
  TRACE_INSN_IDX = 1,

  /* Trace insn decoding.
     ??? This is more of a simulator debugging operation and might best be
     moved to --debug-decode.  */
  TRACE_DECODE_IDX,

  /* Trace insn extraction.
     ??? This is more of a simulator debugging operation and might best be
     moved to --debug-extract.  */
  TRACE_EXTRACT_IDX,

  /* Trace insn execution but include line numbers.  */
  TRACE_LINENUM_IDX,

  /* Trace memory operations.
     The difference between this and TRACE_CORE_IDX is (I think) that this
     is intended to apply to a higher level.  TRACE_CORE_IDX applies to the
     low level core operations.  */
  TRACE_MEMORY_IDX,

  /* Include model performance data in tracing output.  */
  TRACE_MODEL_IDX,

  /* Trace ALU (Arithmetic Logic Unit) operations.  */
  TRACE_ALU_IDX,

  /* Trace memory core operations.  */
  TRACE_CORE_IDX,

  /* Trace events.  */
  TRACE_EVENTS_IDX,

  /* Trace FPU (Floating Point Unit) operations.  */
  TRACE_FPU_IDX,

  /* Trace VPU (Vector Processing Unit) operations.  */
  TRACE_VPU_IDX,

  /* Trace branching.  */
  TRACE_BRANCH_IDX,

  /* Trace syscalls.  */
  TRACE_SYSCALL_IDX,

  /* Add information useful for debugging the simulator to trace output.  */
  TRACE_DEBUG_IDX,

  /* Simulator specific trace bits begin here.  */
  TRACE_NEXT_IDX,

};
/* Maximum number of traceable entities.  */
#ifndef MAX_TRACE_VALUES
#define MAX_TRACE_VALUES 32
#endif

/* The -t option only prints useful values.  It's easy to type and shouldn't
   splat on the screen everything under the sun making nothing easy to
   find.  */
#define TRACE_USEFUL_MASK \
  (TRACE_insn | TRACE_linenum | TRACE_memory | TRACE_model)
\f
/* Masks so WITH_TRACE can have symbolic values.
   The case choice here is on purpose.  The lowercase parts are args to
   --with-trace.  */
#define TRACE_insn     (1 << TRACE_INSN_IDX)
#define TRACE_decode   (1 << TRACE_DECODE_IDX)
#define TRACE_extract  (1 << TRACE_EXTRACT_IDX)
#define TRACE_linenum  (1 << TRACE_LINENUM_IDX)
#define TRACE_memory   (1 << TRACE_MEMORY_IDX)
#define TRACE_model    (1 << TRACE_MODEL_IDX)
#define TRACE_alu      (1 << TRACE_ALU_IDX)
#define TRACE_core     (1 << TRACE_CORE_IDX)
#define TRACE_events   (1 << TRACE_EVENTS_IDX)
#define TRACE_fpu      (1 << TRACE_FPU_IDX)
#define TRACE_vpu      (1 << TRACE_VPU_IDX)
#define TRACE_branch   (1 << TRACE_BRANCH_IDX)
#define TRACE_syscall  (1 << TRACE_SYSCALL_IDX)
#define TRACE_debug    (1 << TRACE_DEBUG_IDX)

/* Return non-zero if tracing of idx is enabled (compiled in).  */
#define WITH_TRACE_P(idx)	(WITH_TRACE & (1 << idx))

/* Preprocessor macros to simplify tests of WITH_TRACE.  */
#define WITH_TRACE_ANY_P	(WITH_TRACE)
#define WITH_TRACE_INSN_P	WITH_TRACE_P (TRACE_INSN_IDX)
#define WITH_TRACE_DECODE_P	WITH_TRACE_P (TRACE_DECODE_IDX)
#define WITH_TRACE_EXTRACT_P	WITH_TRACE_P (TRACE_EXTRACT_IDX)
#define WITH_TRACE_LINENUM_P	WITH_TRACE_P (TRACE_LINENUM_IDX)
#define WITH_TRACE_MEMORY_P	WITH_TRACE_P (TRACE_MEMORY_IDX)
#define WITH_TRACE_MODEL_P	WITH_TRACE_P (TRACE_MODEL_IDX)
#define WITH_TRACE_ALU_P	WITH_TRACE_P (TRACE_ALU_IDX)
#define WITH_TRACE_CORE_P	WITH_TRACE_P (TRACE_CORE_IDX)
#define WITH_TRACE_EVENTS_P	WITH_TRACE_P (TRACE_EVENTS_IDX)
#define WITH_TRACE_FPU_P	WITH_TRACE_P (TRACE_FPU_IDX)
#define WITH_TRACE_VPU_P	WITH_TRACE_P (TRACE_VPU_IDX)
#define WITH_TRACE_BRANCH_P	WITH_TRACE_P (TRACE_BRANCH_IDX)
#define WITH_TRACE_SYSCALL_P	WITH_TRACE_P (TRACE_SYSCALL_IDX)
#define WITH_TRACE_DEBUG_P	WITH_TRACE_P (TRACE_DEBUG_IDX)

/* Tracing install handler.  */
MODULE_INSTALL_FN trace_install;
\f
/* Struct containing all system and cpu trace data.

   System trace data is stored with the associated module.
   System and cpu tracing must share the same space of bitmasks as they
   are arguments to --with-trace.  One could have --with-trace and
   --with-cpu-trace or some such but that's an over-complication at this point
   in time.  Also, there may be occasions where system and cpu tracing may
   wish to share a name.  */

typedef struct _trace_data {

  /* Global summary of all the current trace options */
  char trace_any_p;

  /* Boolean array of specified tracing flags.  */
  /* ??? It's not clear that using an array vs a bit mask is faster.
     Consider the case where one wants to test whether any of several bits
     are set.  */
  char trace_flags[MAX_TRACE_VALUES];
#define TRACE_FLAGS(t) ((t)->trace_flags)

  /* Tracing output goes to this or stderr if NULL.
     We can't store `stderr' here as stderr goes through a callback.  */
  FILE *trace_file;
#define TRACE_FILE(t) ((t)->trace_file)

  /* Buffer to store the prefix to be printed before any trace line.  */
  char trace_prefix[256];
#define TRACE_PREFIX(t) ((t)->trace_prefix)

  /* Buffer to save the inputs for the current instruction.  Use a
     union to force the buffer into correct alignment */
  union {
    unsigned8 i8;
    unsigned16 i16;
    unsigned32 i32;
    unsigned64 i64;
  } trace_input_data[16];
  unsigned8 trace_input_fmt[16];
  unsigned8 trace_input_size[16];
  int trace_input_idx;
#define TRACE_INPUT_DATA(t) ((t)->trace_input_data)
#define TRACE_INPUT_FMT(t) ((t)->trace_input_fmt)
#define TRACE_INPUT_SIZE(t) ((t)->trace_input_size)
#define TRACE_INPUT_IDX(t) ((t)->trace_input_idx)

  /* Category of trace being performed */
  int trace_idx;
#define TRACE_IDX(t) ((t)->trace_idx)

  /* Trace range.
     ??? Not all cpu's support this.  */
  ADDR_RANGE range;
#define TRACE_RANGE(t) (& (t)->range)
} TRACE_DATA;
\f
/* System tracing support.  */

#define STATE_TRACE_FLAGS(sd) TRACE_FLAGS (STATE_TRACE_DATA (sd))

/* Return non-zero if tracing of IDX is enabled for non-cpu specific
   components.  The "S" in "STRACE" refers to "System".  */
#define STRACE_P(sd,idx) \
  (WITH_TRACE_P (idx) && STATE_TRACE_FLAGS (sd)[idx] != 0)

/* Non-zero if --trace-<xxxx> was specified for SD.  */
#define STRACE_ANY_P(sd)	(WITH_TRACE_ANY_P && (STATE_TRACE_DATA (sd)->trace_any_p))
#define STRACE_INSN_P(sd)	STRACE_P (sd, TRACE_INSN_IDX)
#define STRACE_DECODE_P(sd)	STRACE_P (sd, TRACE_DECODE_IDX)
#define STRACE_EXTRACT_P(sd)	STRACE_P (sd, TRACE_EXTRACT_IDX)
#define STRACE_LINENUM_P(sd)	STRACE_P (sd, TRACE_LINENUM_IDX)
#define STRACE_MEMORY_P(sd)	STRACE_P (sd, TRACE_MEMORY_IDX)
#define STRACE_MODEL_P(sd)	STRACE_P (sd, TRACE_MODEL_IDX)
#define STRACE_ALU_P(sd)	STRACE_P (sd, TRACE_ALU_IDX)
#define STRACE_CORE_P(sd)	STRACE_P (sd, TRACE_CORE_IDX)
#define STRACE_EVENTS_P(sd)	STRACE_P (sd, TRACE_EVENTS_IDX)
#define STRACE_FPU_P(sd)	STRACE_P (sd, TRACE_FPU_IDX)
#define STRACE_VPU_P(sd)	STRACE_P (sd, TRACE_VPU_IDX)
#define STRACE_BRANCH_P(sd)	STRACE_P (sd, TRACE_BRANCH_IDX)
#define STRACE_SYSCALL_P(sd)	STRACE_P (sd, TRACE_SYSCALL_IDX)
#define STRACE_DEBUG_P(sd)	STRACE_P (sd, TRACE_DEBUG_IDX)
\f
/* CPU tracing support.  */

#define CPU_TRACE_FLAGS(cpu) TRACE_FLAGS (CPU_TRACE_DATA (cpu))

/* Return non-zero if tracing of IDX is enabled for CPU.  */
#define TRACE_P(cpu,idx) \
  (WITH_TRACE_P (idx) && CPU_TRACE_FLAGS (cpu)[idx] != 0)

/* Non-zero if --trace-<xxxx> was specified for CPU.  */
#define TRACE_ANY_P(cpu)	(WITH_TRACE_ANY_P && (CPU_TRACE_DATA (cpu)->trace_any_p))
#define TRACE_INSN_P(cpu)	TRACE_P (cpu, TRACE_INSN_IDX)
#define TRACE_DECODE_P(cpu)	TRACE_P (cpu, TRACE_DECODE_IDX)
#define TRACE_EXTRACT_P(cpu)	TRACE_P (cpu, TRACE_EXTRACT_IDX)
#define TRACE_LINENUM_P(cpu)	TRACE_P (cpu, TRACE_LINENUM_IDX)
#define TRACE_MEMORY_P(cpu)	TRACE_P (cpu, TRACE_MEMORY_IDX)
#define TRACE_MODEL_P(cpu)	TRACE_P (cpu, TRACE_MODEL_IDX)
#define TRACE_ALU_P(cpu)	TRACE_P (cpu, TRACE_ALU_IDX)
#define TRACE_CORE_P(cpu)	TRACE_P (cpu, TRACE_CORE_IDX)
#define TRACE_EVENTS_P(cpu)	TRACE_P (cpu, TRACE_EVENTS_IDX)
#define TRACE_FPU_P(cpu)	TRACE_P (cpu, TRACE_FPU_IDX)
#define TRACE_VPU_P(cpu)	TRACE_P (cpu, TRACE_VPU_IDX)
#define TRACE_BRANCH_P(cpu)	TRACE_P (cpu, TRACE_BRANCH_IDX)
#define TRACE_SYSCALL_P(cpu)	TRACE_P (cpu, TRACE_SYSCALL_IDX)
#define TRACE_DEBUG_P(cpu)	TRACE_P (cpu, TRACE_DEBUG_IDX)

/* Helper functions for printing messages.  */
#define TRACE(cpu, idx, fmt, args...) \
  do { \
    if (TRACE_P (cpu, idx)) \
      trace_generic (CPU_STATE (cpu), cpu, idx, fmt, ## args); \
  } while (0)
#define TRACE_INSN(cpu, fmt, args...)		TRACE (cpu, TRACE_INSN_IDX, fmt, ## args)
#define TRACE_DECODE(cpu, fmt, args...)		TRACE (cpu, TRACE_DECODE_IDX, fmt, ## args)
#define TRACE_EXTRACT(cpu, fmt, args...)	TRACE (cpu, TRACE_EXTRACT_IDX, fmt, ## args)
#define TRACE_LINENUM(cpu, fmt, args...)	TRACE (cpu, TRACE_LINENUM_IDX, fmt, ## args)
#define TRACE_MEMORY(cpu, fmt, args...)		TRACE (cpu, TRACE_MEMORY_IDX, fmt, ## args)
#define TRACE_MODEL(cpu, fmt, args...)		TRACE (cpu, TRACE_MODEL_IDX, fmt, ## args)
#define TRACE_ALU(cpu, fmt, args...)		TRACE (cpu, TRACE_ALU_IDX, fmt, ## args)
#define TRACE_CORE(cpu, fmt, args...)		TRACE (cpu, TRACE_CORE_IDX, fmt, ## args)
#define TRACE_EVENTS(cpu, fmt, args...)		TRACE (cpu, TRACE_EVENTS_IDX, fmt, ## args)
#define TRACE_FPU(cpu, fmt, args...)		TRACE (cpu, TRACE_FPU_IDX, fmt, ## args)
#define TRACE_VPU(cpu, fmt, args...)		TRACE (cpu, TRACE_VPU_IDX, fmt, ## args)
#define TRACE_BRANCH(cpu, fmt, args...)		TRACE (cpu, TRACE_BRANCH_IDX, fmt, ## args)
#define TRACE_SYSCALL(cpu, fmt, args...)	TRACE (cpu, TRACE_SYSCALL_IDX, fmt, ## args)
#define TRACE_DEBUG(cpu, fmt, args...)		TRACE (cpu, TRACE_DEBUG_IDX, fmt, ## args)
\f
/* Tracing functions.  */

/* Prime the trace buffers ready for any trace output.
   Must be called prior to any other trace operation */
extern void trace_prefix (SIM_DESC sd,
			  sim_cpu *cpu,
			  sim_cia cia,
			  address_word pc,
			  int print_linenum_p,
			  const char *file_name,
			  int line_nr,
			  const char *fmt,
			  ...)
       __attribute__((format (printf, 8, 9)));

/* Generic trace print, assumes trace_prefix() has been called */

extern void trace_generic (SIM_DESC sd,
			   sim_cpu *cpu,
			   int trace_idx,
			   const char *fmt,
			   ...)
     __attribute__((format (printf, 4, 5)));

typedef enum {
  trace_fmt_invalid,
  trace_fmt_word,
  trace_fmt_fp,
  trace_fmt_fpu,
  trace_fmt_string,
  trace_fmt_bool,
  trace_fmt_addr,
  trace_fmt_instruction_incomplete,
} data_fmt;

/* Trace a varying number of word sized inputs/outputs.  trace_result*
   must be called to close the trace operation. */

extern void save_data (SIM_DESC sd,
		       TRACE_DATA *data,
		       data_fmt fmt,
		       long size,
		       const void *buf);

extern void trace_input0 (SIM_DESC sd,
			  sim_cpu *cpu,
			  int trace_idx);

extern void trace_input_word1 (SIM_DESC sd,
			       sim_cpu *cpu,
			       int trace_idx,
			       unsigned_word d0);

extern void trace_input_word2 (SIM_DESC sd,
			       sim_cpu *cpu,
			       int trace_idx,
			       unsigned_word d0,
			       unsigned_word d1);

extern void trace_input_word3 (SIM_DESC sd,
				       sim_cpu *cpu,
				       int trace_idx,
				       unsigned_word d0,
				       unsigned_word d1,
				       unsigned_word d2);

extern void trace_input_word4 (SIM_DESC sd,
			       sim_cpu *cpu,
			       int trace_idx,
			       unsigned_word d0,
			       unsigned_word d1,
			       unsigned_word d2,
			       unsigned_word d3);

extern void trace_input_addr1 (SIM_DESC sd,
			       sim_cpu *cpu,
			       int trace_idx,
			       address_word d0);

extern void trace_input_bool1 (SIM_DESC sd,
			       sim_cpu *cpu,
			       int trace_idx,
			       int d0);

extern void trace_input_fp1 (SIM_DESC sd,
			     sim_cpu *cpu,
			     int trace_idx,
			     fp_word f0);

extern void trace_input_fp2 (SIM_DESC sd,
			     sim_cpu *cpu,
			     int trace_idx,
			     fp_word f0,
			     fp_word f1);

extern void trace_input_fp3 (SIM_DESC sd,
			     sim_cpu *cpu,
			     int trace_idx,
			     fp_word f0,
			     fp_word f1,
			     fp_word f2);

extern void trace_input_fpu1 (SIM_DESC sd,
			      sim_cpu *cpu,
			      int trace_idx,
			      struct _sim_fpu *f0);

extern void trace_input_fpu2 (SIM_DESC sd,
			      sim_cpu *cpu,
			      int trace_idx,
			      struct _sim_fpu *f0,
			      struct _sim_fpu *f1);

extern void trace_input_fpu3 (SIM_DESC sd,
			      sim_cpu *cpu,
			      int trace_idx,
			      struct _sim_fpu *f0,
			      struct _sim_fpu *f1,
			      struct _sim_fpu *f2);

/* Other trace_input{_<fmt><nr-inputs>} functions can go here */

extern void trace_result0 (SIM_DESC sd,
			   sim_cpu *cpu,
			   int trace_idx);

extern void trace_result_word1 (SIM_DESC sd,
				sim_cpu *cpu,
				int trace_idx,
				unsigned_word r0);

extern void trace_result_word2 (SIM_DESC sd,
				sim_cpu *cpu,
				int trace_idx,
				unsigned_word r0,
				unsigned_word r1);

extern void trace_result_word4 (SIM_DESC sd,
				sim_cpu *cpu,
				int trace_idx,
				unsigned_word r0,
				unsigned_word r1,
				unsigned_word r2,
				unsigned_word r3);

extern void trace_result_bool1 (SIM_DESC sd,
				sim_cpu *cpu,
				int trace_idx,
				int r0);

extern void trace_result_addr1 (SIM_DESC sd,
				sim_cpu *cpu,
				int trace_idx,
				address_word r0);

extern void trace_result_fp1 (SIM_DESC sd,
			      sim_cpu *cpu,
			      int trace_idx,
			      fp_word f0);

extern void trace_result_fp2 (SIM_DESC sd,
			      sim_cpu *cpu,
			      int trace_idx,
			      fp_word f0,
			      fp_word f1);

extern void trace_result_fpu1 (SIM_DESC sd,
			       sim_cpu *cpu,
			       int trace_idx,
			       struct _sim_fpu *f0);

extern void trace_result_string1 (SIM_DESC sd,
				  sim_cpu *cpu,
				  int trace_idx,
				  char *str0);

extern void trace_result_word1_string1 (SIM_DESC sd,
					sim_cpu *cpu,
					int trace_idx,
					unsigned_word r0,
					char *s0);

/* Other trace_result{_<type><nr-results>} */


/* Macros for tracing ALU instructions */

#define TRACE_ALU_INPUT0() \
do { \
  if (TRACE_ALU_P (CPU)) \
    trace_input0 (SD, CPU, TRACE_ALU_IDX); \
} while (0)

#define TRACE_ALU_INPUT1(V0) \
do { \
  if (TRACE_ALU_P (CPU)) \
    trace_input_word1 (SD, CPU, TRACE_ALU_IDX, (V0)); \
} while (0)

#define TRACE_ALU_INPUT2(V0,V1) \
do { \
  if (TRACE_ALU_P (CPU)) \
    trace_input_word2 (SD, CPU, TRACE_ALU_IDX, (V0), (V1)); \
} while (0)

#define TRACE_ALU_INPUT3(V0,V1,V2) \
do { \
  if (TRACE_ALU_P (CPU)) \
    trace_input_word3 (SD, CPU, TRACE_ALU_IDX, (V0), (V1), (V2)); \
} while (0)

#define TRACE_ALU_INPUT4(V0,V1,V2,V3) \
do { \
  if (TRACE_ALU_P (CPU)) \
    trace_input_word4 (SD, CPU, TRACE_ALU_IDX, (V0), (V1), (V2), (V3)); \
} while (0)

#define TRACE_ALU_RESULT(R0) TRACE_ALU_RESULT1(R0)

#define TRACE_ALU_RESULT0() \
do { \
  if (TRACE_ALU_P (CPU)) \
    trace_result0 (SD, CPU, TRACE_ALU_IDX); \
} while (0)

#define TRACE_ALU_RESULT1(R0) \
do { \
  if (TRACE_ALU_P (CPU)) \
    trace_result_word1 (SD, CPU, TRACE_ALU_IDX, (R0)); \
} while (0)

#define TRACE_ALU_RESULT2(R0,R1) \
do { \
  if (TRACE_ALU_P (CPU)) \
    trace_result_word2 (SD, CPU, TRACE_ALU_IDX, (R0), (R1)); \
} while (0)

#define TRACE_ALU_RESULT4(R0,R1,R2,R3) \
do { \
  if (TRACE_ALU_P (CPU)) \
    trace_result_word4 (SD, CPU, TRACE_ALU_IDX, (R0), (R1), (R2), (R3)); \
} while (0)

/* Macros for tracing inputs to comparative branch instructions. */

#define TRACE_BRANCH_INPUT1(V0) \
do { \
  if (TRACE_BRANCH_P (CPU)) \
    trace_input_word1 (SD, CPU, TRACE_BRANCH_IDX, (V0)); \
} while (0)

#define TRACE_BRANCH_INPUT2(V0,V1) \
do { \
  if (TRACE_BRANCH_P (CPU)) \
    trace_input_word2 (SD, CPU, TRACE_BRANCH_IDX, (V0), (V1)); \
} while (0)

/* Macros for tracing FPU instructions */

#define TRACE_FP_INPUT0() \
do { \
  if (TRACE_FPU_P (CPU)) \
    trace_input0 (SD, CPU, TRACE_FPU_IDX); \
} while (0)

#define TRACE_FP_INPUT1(V0) \
do { \
  if (TRACE_FPU_P (CPU)) \
    trace_input_fp1 (SD, CPU, TRACE_FPU_IDX, (V0)); \
} while (0)

#define TRACE_FP_INPUT2(V0,V1) \
do { \
  if (TRACE_FPU_P (CPU)) \
    trace_input_fp2 (SD, CPU, TRACE_FPU_IDX, (V0), (V1)); \
} while (0)

#define TRACE_FP_INPUT3(V0,V1,V2) \
do { \
  if (TRACE_FPU_P (CPU)) \
    trace_input_fp3 (SD, CPU, TRACE_FPU_IDX, (V0), (V1), (V2)); \
} while (0)

#define TRACE_FP_INPUT_WORD1(V0) \
do { \
  if (TRACE_FPU_P (CPU)) \
    trace_input_word1 (SD, CPU, TRACE_FPU_IDX, (V0)); \
} while (0)

#define TRACE_FP_RESULT(R0) \
do { \
  if (TRACE_FPU_P (CPU)) \
    trace_result_fp1 (SD, CPU, TRACE_FPU_IDX, (R0)); \
} while (0)

#define TRACE_FP_RESULT2(R0,R1) \
do { \
  if (TRACE_FPU_P (CPU)) \
    trace_result_fp2 (SD, CPU, TRACE_FPU_IDX, (R0), (R1)); \
} while (0)

#define TRACE_FP_RESULT_BOOL(R0) \
do { \
  if (TRACE_FPU_P (CPU)) \
    trace_result_bool1 (SD, CPU, TRACE_FPU_IDX, (R0)); \
} while (0)

#define TRACE_FP_RESULT_WORD(R0) \
do { \
  if (TRACE_FPU_P (CPU)) \
    trace_result_word1 (SD, CPU, TRACE_FPU_IDX, (R0)); \
} while (0)


/* Macros for tracing branches */

#define TRACE_BRANCH_INPUT(COND) \
do { \
  if (TRACE_BRANCH_P (CPU)) \
    trace_input_bool1 (SD, CPU, TRACE_BRANCH_IDX, (COND)); \
} while (0)

#define TRACE_BRANCH_RESULT(DEST) \
do { \
  if (TRACE_BRANCH_P (CPU)) \
    trace_result_addr1 (SD, CPU, TRACE_BRANCH_IDX, (DEST)); \
} while (0)

\f
/* The function trace_one_insn has been replaced by the function pair
   trace_prefix() + trace_generic() */
extern void trace_one_insn (SIM_DESC sd,
			    sim_cpu * cpu,
			    address_word cia,
			    int print_linenum_p,
			    const char *file_name,
			    int line_nr,
			    const char *unit,
			    const char *fmt,
			    ...)
     __attribute__((format (printf, 8, 9)));

extern void trace_printf (SIM_DESC, sim_cpu *, const char *, ...)
     __attribute__((format (printf, 3, 4)));

extern void trace_vprintf (SIM_DESC, sim_cpu *, const char *, va_list);

/* Debug support.
   This is included here because there isn't enough of it to justify
   a sim-debug.h.  */

/* Return non-zero if debugging of IDX for CPU is enabled.  */
#define DEBUG_P(cpu, idx) \
((WITH_DEBUG & (1 << (idx))) != 0 \
 && CPU_DEBUG_FLAGS (cpu)[idx] != 0)

/* Non-zero if "--debug-insn" specified.  */
#define DEBUG_INSN_P(cpu) DEBUG_P (cpu, DEBUG_INSN_IDX)

/* GDB also has a debug_printf, so we shadow ours.  */
#define debug_printf sim_debug_printf

extern void debug_printf (sim_cpu *, const char *, ...)
     __attribute__((format (printf, 2, 3)));

#endif /* SIM_TRACE_H */
Commit	Line	Data
c906108c	1	/* Simulator tracing/debugging support.
32d0add0	2	Copyright (C) 1997-2015 Free Software Foundation, Inc.
c906108c SS	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
4744ac1b JB	9	the Free Software Foundation; either version 3 of the License, or
4744ac1b JB	10	(at your option) any later version.
c906108c SS	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
4744ac1b JB	17	You should have received a copy of the GNU General Public License
4744ac1b JB	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c SS	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
8371bf0c	53	/* Trace ALU (Arithmetic Logic Unit) operations. */
c906108c SS	54	TRACE_ALU_IDX,
	55
	56	/* Trace memory core operations. */
	57	TRACE_CORE_IDX,
	58
	59	/* Trace events. */
	60	TRACE_EVENTS_IDX,
	61
8371bf0c	62	/* Trace FPU (Floating Point Unit) operations. */
c906108c SS	63	TRACE_FPU_IDX,
c906108c SS	64
8371bf0c	65	/* Trace VPU (Vector Processing Unit) operations. */
01816cd8 BE	66	TRACE_VPU_IDX,
01816cd8 BE	67
c906108c SS	68	/* Trace branching. */
	69	TRACE_BRANCH_IDX,
	70
3a49ea9f MF	71	/* Trace syscalls. */
	72	TRACE_SYSCALL_IDX,
	73
c906108c SS	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 \
a6c2a374	90	(TRACE_insn \| TRACE_linenum \| TRACE_memory \| TRACE_model)
c906108c SS	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)
01816cd8	105	#define TRACE_vpu (1 << TRACE_VPU_IDX)
c906108c	106	#define TRACE_branch (1 << TRACE_BRANCH_IDX)
3a49ea9f	107	#define TRACE_syscall (1 << TRACE_SYSCALL_IDX)
c906108c SS	108	#define TRACE_debug (1 << TRACE_DEBUG_IDX)
c906108c SS	109
bffcfec8	110	/* Return non-zero if tracing of idx is enabled (compiled in). */
9b9c712c	111	#define WITH_TRACE_P(idx) (WITH_TRACE & (1 << idx))
bffcfec8 MF	112
	113	/* Preprocessor macros to simplify tests of WITH_TRACE. */
	114	#define WITH_TRACE_ANY_P (WITH_TRACE)
9b9c712c MF	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)
c906108c SS	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) \
9b9c712c	196	(WITH_TRACE_P (idx) && STATE_TRACE_FLAGS (sd)[idx] != 0)
c906108c SS	197
c906108c SS	198	/* Non-zero if --trace-<xxxx> was specified for SD. */
bffcfec8	199	#define STRACE_ANY_P(sd) (WITH_TRACE_ANY_P && (STATE_TRACE_DATA (sd)->trace_any_p))
ce4eda4a MF	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)
c906108c SS	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) \
9b9c712c	221	(WITH_TRACE_P (idx) && CPU_TRACE_FLAGS (cpu)[idx] != 0)
c906108c SS	222
c906108c SS	223	/* Non-zero if --trace-<xxxx> was specified for CPU. */
bffcfec8	224	#define TRACE_ANY_P(cpu) (WITH_TRACE_ANY_P && (CPU_TRACE_DATA (cpu)->trace_any_p))
c906108c SS	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)
01816cd8	235	#define TRACE_VPU_P(cpu) TRACE_P (cpu, TRACE_VPU_IDX)
c906108c	236	#define TRACE_BRANCH_P(cpu) TRACE_P (cpu, TRACE_BRANCH_IDX)
3a49ea9f	237	#define TRACE_SYSCALL_P(cpu) TRACE_P (cpu, TRACE_SYSCALL_IDX)
c906108c	238	#define TRACE_DEBUG_P(cpu) TRACE_P (cpu, TRACE_DEBUG_IDX)
bb11f3ed MF	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)
c906108c	260	\f
01816cd8	261	/* Tracing functions. */
c906108c SS	262
	263	/* Prime the trace buffers ready for any trace output.
	264	Must be called prior to any other trace operation */
bdca5ee4 TT	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	...)
c906108c SS	274	__attribute__((format (printf, 8, 9)));
	275
	276	/* Generic trace print, assumes trace_prefix() has been called */
	277
bdca5ee4 TT	278	extern void trace_generic (SIM_DESC sd,
	279	sim_cpu *cpu,
	280	int trace_idx,
	281	const char *fmt,
	282	...)
c906108c SS	283	__attribute__((format (printf, 4, 5)));
c906108c SS	284
2aaed979 KB	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
c906108c SS	296	/* Trace a varying number of word sized inputs/outputs. trace_result*
	297	must be called to close the trace operation. */
	298
bdca5ee4 TT	299	extern void save_data (SIM_DESC sd,
	300	TRACE_DATA *data,
	301	data_fmt fmt,
	302	long size,
	303	const void *buf);
c906108c	304
bdca5ee4 TT	305	extern void trace_input0 (SIM_DESC sd,
	306	sim_cpu *cpu,
	307	int trace_idx);
c906108c	308
bdca5ee4 TT	309	extern void trace_input_word1 (SIM_DESC sd,
	310	sim_cpu *cpu,
	311	int trace_idx,
	312	unsigned_word d0);
c906108c	313
bdca5ee4 TT	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);
c906108c	319
bdca5ee4	320	extern void trace_input_word3 (SIM_DESC sd,
c906108c SS	321	sim_cpu *cpu,
	322	int trace_idx,
	323	unsigned_word d0,
	324	unsigned_word d1,
bdca5ee4 TT	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);
c906108c SS	380
	381	/* Other trace_input{_<fmt><nr-inputs>} functions can go here */
	382
bdca5ee4 TT	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);
c906108c	436
bdca5ee4	437	extern void trace_result_word1_string1 (SIM_DESC sd,
c906108c SS	438	sim_cpu *cpu,
	439	int trace_idx,
	440	unsigned_word r0,
bdca5ee4	441	char *s0);
c906108c SS	442
	443	/* Other trace_result{_<type><nr-results>} */
	444
	445
44a9331c	446	/* Macros for tracing ALU instructions */
c906108c SS	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)
028f6515	453
c906108c SS	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
44a9331c	504	/* Macros for tracing inputs to comparative branch instructions. */
c906108c	505
44a9331c BE	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 */
c906108c SS	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)
028f6515	525
c906108c SS	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)
028f6515	549
c906108c SS	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() */
bdca5ee4 TT	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	...)
c906108c SS	601	__attribute__((format (printf, 8, 9)));
c906108c SS	602
bdca5ee4	603	extern void trace_printf (SIM_DESC, sim_cpu , const char , ...)
c906108c SS	604	__attribute__((format (printf, 3, 4)));
c906108c SS	605
bdca5ee4	606	extern void trace_vprintf (SIM_DESC, sim_cpu , const char , va_list);
c906108c SS	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
6aefca7e GB	620	/* GDB also has a debug_printf, so we shadow ours. */
	621	#define debug_printf sim_debug_printf
	622
bdca5ee4	623	extern void debug_printf (sim_cpu , const char , ...)
c906108c SS	624	__attribute__((format (printf, 2, 3)));
	625
	626	#endif /* SIM_TRACE_H */