[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 operations.  */
  TRACE_ALU_IDX,

  /* Trace memory core operations.  */
  TRACE_CORE_IDX,

  /* Trace events.  */
  TRACE_EVENTS_IDX,

  /* Trace fpu operations.  */
  TRACE_FPU_IDX,

  /* Trace vpu 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)

/* Preprocessor macros to simplify tests of WITH_TRACE.  */
#define WITH_TRACE_P(idx)	(WITH_TRACE & (1 << idx))
#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_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) && (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)
\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
	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
01816cd8 BE	65	/* Trace vpu operations. */
	66	TRACE_VPU_IDX,
	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)
	109
	110	/* Preprocessor macros to simplify tests of WITH_TRACE. */
9b9c712c MF	111	#define WITH_TRACE_P(idx) (WITH_TRACE & (1 << idx))
	112	#define WITH_TRACE_INSN_P WITH_TRACE_P (TRACE_INSN_IDX)
	113	#define WITH_TRACE_DECODE_P WITH_TRACE_P (TRACE_DECODE_IDX)
	114	#define WITH_TRACE_EXTRACT_P WITH_TRACE_P (TRACE_EXTRACT_IDX)
	115	#define WITH_TRACE_LINENUM_P WITH_TRACE_P (TRACE_LINENUM_IDX)
	116	#define WITH_TRACE_MEMORY_P WITH_TRACE_P (TRACE_MEMORY_IDX)
	117	#define WITH_TRACE_MODEL_P WITH_TRACE_P (TRACE_MODEL_IDX)
	118	#define WITH_TRACE_ALU_P WITH_TRACE_P (TRACE_ALU_IDX)
	119	#define WITH_TRACE_CORE_P WITH_TRACE_P (TRACE_CORE_IDX)
	120	#define WITH_TRACE_EVENTS_P WITH_TRACE_P (TRACE_EVENTS_IDX)
	121	#define WITH_TRACE_FPU_P WITH_TRACE_P (TRACE_FPU_IDX)
	122	#define WITH_TRACE_VPU_P WITH_TRACE_P (TRACE_VPU_IDX)
	123	#define WITH_TRACE_BRANCH_P WITH_TRACE_P (TRACE_BRANCH_IDX)
	124	#define WITH_TRACE_SYSCALL_P WITH_TRACE_P (TRACE_SYSCALL_IDX)
	125	#define WITH_TRACE_DEBUG_P WITH_TRACE_P (TRACE_DEBUG_IDX)
c906108c SS	126
	127	/* Tracing install handler. */
	128	MODULE_INSTALL_FN trace_install;
	129	\f
	130	/* Struct containing all system and cpu trace data.
	131
	132	System trace data is stored with the associated module.
	133	System and cpu tracing must share the same space of bitmasks as they
	134	are arguments to --with-trace. One could have --with-trace and
	135	--with-cpu-trace or some such but that's an over-complication at this point
	136	in time. Also, there may be occasions where system and cpu tracing may
	137	wish to share a name. */
	138
	139	typedef struct _trace_data {
	140
	141	/* Global summary of all the current trace options */
	142	char trace_any_p;
	143
	144	/* Boolean array of specified tracing flags. */
	145	/* ??? It's not clear that using an array vs a bit mask is faster.
	146	Consider the case where one wants to test whether any of several bits
	147	are set. */
	148	char trace_flags[MAX_TRACE_VALUES];
	149	#define TRACE_FLAGS(t) ((t)->trace_flags)
	150
	151	/* Tracing output goes to this or stderr if NULL.
	152	We can't store `stderr' here as stderr goes through a callback. */
	153	FILE *trace_file;
	154	#define TRACE_FILE(t) ((t)->trace_file)
	155
	156	/* Buffer to store the prefix to be printed before any trace line. */
	157	char trace_prefix[256];
	158	#define TRACE_PREFIX(t) ((t)->trace_prefix)
	159
	160	/* Buffer to save the inputs for the current instruction. Use a
	161	union to force the buffer into correct alignment */
	162	union {
	163	unsigned8 i8;
	164	unsigned16 i16;
	165	unsigned32 i32;
	166	unsigned64 i64;
	167	} trace_input_data[16];
	168	unsigned8 trace_input_fmt[16];
	169	unsigned8 trace_input_size[16];
	170	int trace_input_idx;
	171	#define TRACE_INPUT_DATA(t) ((t)->trace_input_data)
	172	#define TRACE_INPUT_FMT(t) ((t)->trace_input_fmt)
	173	#define TRACE_INPUT_SIZE(t) ((t)->trace_input_size)
	174	#define TRACE_INPUT_IDX(t) ((t)->trace_input_idx)
	175
	176	/* Category of trace being performed */
	177	int trace_idx;
	178	#define TRACE_IDX(t) ((t)->trace_idx)
	179
	180	/* Trace range.
	181	??? Not all cpu's support this. */
	182	ADDR_RANGE range;
	183	#define TRACE_RANGE(t) (& (t)->range)
	184	} TRACE_DATA;
	185	\f
	186	/* System tracing support. */
	187
	188	#define STATE_TRACE_FLAGS(sd) TRACE_FLAGS (STATE_TRACE_DATA (sd))
	189
190	/* Return non-zero if tracing of IDX is enabled for non-cpu specific
191	components. The "S" in "STRACE" refers to "System". */
192	#define STRACE_P(sd,idx) \
9b9c712c	193	(WITH_TRACE_P (idx) && STATE_TRACE_FLAGS (sd)[idx] != 0)
c906108c SS	194
	195	/* Non-zero if --trace-<xxxx> was specified for SD. */
	196	#define STRACE_DEBUG_P(sd) STRACE_P (sd, TRACE_DEBUG_IDX)
	197	\f
	198	/* CPU tracing support. */
	199
	200	#define CPU_TRACE_FLAGS(cpu) TRACE_FLAGS (CPU_TRACE_DATA (cpu))
	201
	202	/* Return non-zero if tracing of IDX is enabled for CPU. */
	203	#define TRACE_P(cpu,idx) \
9b9c712c	204	(WITH_TRACE_P (idx) && CPU_TRACE_FLAGS (cpu)[idx] != 0)
c906108c SS	205
	206	/* Non-zero if --trace-<xxxx> was specified for CPU. */
	207	#define TRACE_ANY_P(cpu) ((WITH_TRACE) && (CPU_TRACE_DATA (cpu)->trace_any_p))
	208	#define TRACE_INSN_P(cpu) TRACE_P (cpu, TRACE_INSN_IDX)
	209	#define TRACE_DECODE_P(cpu) TRACE_P (cpu, TRACE_DECODE_IDX)
	210	#define TRACE_EXTRACT_P(cpu) TRACE_P (cpu, TRACE_EXTRACT_IDX)
	211	#define TRACE_LINENUM_P(cpu) TRACE_P (cpu, TRACE_LINENUM_IDX)
	212	#define TRACE_MEMORY_P(cpu) TRACE_P (cpu, TRACE_MEMORY_IDX)
	213	#define TRACE_MODEL_P(cpu) TRACE_P (cpu, TRACE_MODEL_IDX)
	214	#define TRACE_ALU_P(cpu) TRACE_P (cpu, TRACE_ALU_IDX)
	215	#define TRACE_CORE_P(cpu) TRACE_P (cpu, TRACE_CORE_IDX)
	216	#define TRACE_EVENTS_P(cpu) TRACE_P (cpu, TRACE_EVENTS_IDX)
	217	#define TRACE_FPU_P(cpu) TRACE_P (cpu, TRACE_FPU_IDX)
01816cd8	218	#define TRACE_VPU_P(cpu) TRACE_P (cpu, TRACE_VPU_IDX)
c906108c	219	#define TRACE_BRANCH_P(cpu) TRACE_P (cpu, TRACE_BRANCH_IDX)
3a49ea9f	220	#define TRACE_SYSCALL_P(cpu) TRACE_P (cpu, TRACE_SYSCALL_IDX)
c906108c SS	221	#define TRACE_DEBUG_P(cpu) TRACE_P (cpu, TRACE_DEBUG_IDX)
c906108c SS	222	\f
01816cd8	223	/* Tracing functions. */
c906108c SS	224
	225	/* Prime the trace buffers ready for any trace output.
	226	Must be called prior to any other trace operation */
bdca5ee4 TT	227	extern void trace_prefix (SIM_DESC sd,
	228	sim_cpu *cpu,
	229	sim_cia cia,
	230	address_word pc,
	231	int print_linenum_p,
	232	const char *file_name,
	233	int line_nr,
	234	const char *fmt,
	235	...)
c906108c SS	236	__attribute__((format (printf, 8, 9)));
	237
	238	/* Generic trace print, assumes trace_prefix() has been called */
	239
bdca5ee4 TT	240	extern void trace_generic (SIM_DESC sd,
	241	sim_cpu *cpu,
	242	int trace_idx,
	243	const char *fmt,
	244	...)
c906108c SS	245	__attribute__((format (printf, 4, 5)));
c906108c SS	246
2aaed979 KB	247	typedef enum {
	248	trace_fmt_invalid,
	249	trace_fmt_word,
	250	trace_fmt_fp,
	251	trace_fmt_fpu,
	252	trace_fmt_string,
	253	trace_fmt_bool,
	254	trace_fmt_addr,
	255	trace_fmt_instruction_incomplete,
	256	} data_fmt;
	257
c906108c SS	258	/* Trace a varying number of word sized inputs/outputs. trace_result*
	259	must be called to close the trace operation. */
	260
bdca5ee4 TT	261	extern void save_data (SIM_DESC sd,
	262	TRACE_DATA *data,
	263	data_fmt fmt,
	264	long size,
	265	const void *buf);
c906108c	266
bdca5ee4 TT	267	extern void trace_input0 (SIM_DESC sd,
	268	sim_cpu *cpu,
	269	int trace_idx);
c906108c	270
bdca5ee4 TT	271	extern void trace_input_word1 (SIM_DESC sd,
	272	sim_cpu *cpu,
	273	int trace_idx,
	274	unsigned_word d0);
c906108c	275
bdca5ee4 TT	276	extern void trace_input_word2 (SIM_DESC sd,
	277	sim_cpu *cpu,
	278	int trace_idx,
	279	unsigned_word d0,
	280	unsigned_word d1);
c906108c	281
bdca5ee4	282	extern void trace_input_word3 (SIM_DESC sd,
c906108c SS	283	sim_cpu *cpu,
	284	int trace_idx,
	285	unsigned_word d0,
	286	unsigned_word d1,
bdca5ee4 TT	287	unsigned_word d2);
	288
	289	extern void trace_input_word4 (SIM_DESC sd,
	290	sim_cpu *cpu,
	291	int trace_idx,
	292	unsigned_word d0,
	293	unsigned_word d1,
	294	unsigned_word d2,
	295	unsigned_word d3);
	296
	297	extern void trace_input_addr1 (SIM_DESC sd,
	298	sim_cpu *cpu,
	299	int trace_idx,
	300	address_word d0);
	301
	302	extern void trace_input_bool1 (SIM_DESC sd,
	303	sim_cpu *cpu,
	304	int trace_idx,
	305	int d0);
	306
	307	extern void trace_input_fp1 (SIM_DESC sd,
	308	sim_cpu *cpu,
	309	int trace_idx,
	310	fp_word f0);
	311
	312	extern void trace_input_fp2 (SIM_DESC sd,
	313	sim_cpu *cpu,
	314	int trace_idx,
	315	fp_word f0,
	316	fp_word f1);
	317
	318	extern void trace_input_fp3 (SIM_DESC sd,
	319	sim_cpu *cpu,
	320	int trace_idx,
	321	fp_word f0,
	322	fp_word f1,
	323	fp_word f2);
	324
	325	extern void trace_input_fpu1 (SIM_DESC sd,
	326	sim_cpu *cpu,
	327	int trace_idx,
	328	struct _sim_fpu *f0);
	329
	330	extern void trace_input_fpu2 (SIM_DESC sd,
	331	sim_cpu *cpu,
	332	int trace_idx,
	333	struct _sim_fpu *f0,
	334	struct _sim_fpu *f1);
	335
	336	extern void trace_input_fpu3 (SIM_DESC sd,
	337	sim_cpu *cpu,
	338	int trace_idx,
	339	struct _sim_fpu *f0,
	340	struct _sim_fpu *f1,
	341	struct _sim_fpu *f2);
c906108c SS	342
	343	/* Other trace_input{_<fmt><nr-inputs>} functions can go here */
	344
bdca5ee4 TT	345	extern void trace_result0 (SIM_DESC sd,
	346	sim_cpu *cpu,
	347	int trace_idx);
	348
	349	extern void trace_result_word1 (SIM_DESC sd,
	350	sim_cpu *cpu,
	351	int trace_idx,
	352	unsigned_word r0);
	353
	354	extern void trace_result_word2 (SIM_DESC sd,
	355	sim_cpu *cpu,
	356	int trace_idx,
	357	unsigned_word r0,
	358	unsigned_word r1);
	359
	360	extern void trace_result_word4 (SIM_DESC sd,
	361	sim_cpu *cpu,
	362	int trace_idx,
	363	unsigned_word r0,
	364	unsigned_word r1,
	365	unsigned_word r2,
	366	unsigned_word r3);
	367
	368	extern void trace_result_bool1 (SIM_DESC sd,
	369	sim_cpu *cpu,
	370	int trace_idx,
	371	int r0);
	372
	373	extern void trace_result_addr1 (SIM_DESC sd,
	374	sim_cpu *cpu,
	375	int trace_idx,
	376	address_word r0);
	377
	378	extern void trace_result_fp1 (SIM_DESC sd,
	379	sim_cpu *cpu,
	380	int trace_idx,
	381	fp_word f0);
	382
	383	extern void trace_result_fp2 (SIM_DESC sd,
	384	sim_cpu *cpu,
	385	int trace_idx,
	386	fp_word f0,
	387	fp_word f1);
	388
	389	extern void trace_result_fpu1 (SIM_DESC sd,
	390	sim_cpu *cpu,
	391	int trace_idx,
	392	struct _sim_fpu *f0);
	393
	394	extern void trace_result_string1 (SIM_DESC sd,
	395	sim_cpu *cpu,
	396	int trace_idx,
	397	char *str0);
c906108c	398
bdca5ee4	399	extern void trace_result_word1_string1 (SIM_DESC sd,
c906108c SS	400	sim_cpu *cpu,
	401	int trace_idx,
	402	unsigned_word r0,
bdca5ee4	403	char *s0);
c906108c SS	404
	405	/* Other trace_result{_<type><nr-results>} */
	406
	407
44a9331c	408	/* Macros for tracing ALU instructions */
c906108c SS	409
	410	#define TRACE_ALU_INPUT0() \
	411	do { \
	412	if (TRACE_ALU_P (CPU)) \
	413	trace_input0 (SD, CPU, TRACE_ALU_IDX); \
	414	} while (0)
028f6515	415
c906108c SS	416	#define TRACE_ALU_INPUT1(V0) \
	417	do { \
	418	if (TRACE_ALU_P (CPU)) \
	419	trace_input_word1 (SD, CPU, TRACE_ALU_IDX, (V0)); \
	420	} while (0)
	421
	422	#define TRACE_ALU_INPUT2(V0,V1) \
	423	do { \
	424	if (TRACE_ALU_P (CPU)) \
	425	trace_input_word2 (SD, CPU, TRACE_ALU_IDX, (V0), (V1)); \
	426	} while (0)
	427
	428	#define TRACE_ALU_INPUT3(V0,V1,V2) \
	429	do { \
	430	if (TRACE_ALU_P (CPU)) \
	431	trace_input_word3 (SD, CPU, TRACE_ALU_IDX, (V0), (V1), (V2)); \
	432	} while (0)
	433
	434	#define TRACE_ALU_INPUT4(V0,V1,V2,V3) \
	435	do { \
	436	if (TRACE_ALU_P (CPU)) \
	437	trace_input_word4 (SD, CPU, TRACE_ALU_IDX, (V0), (V1), (V2), (V3)); \
	438	} while (0)
	439
	440	#define TRACE_ALU_RESULT(R0) TRACE_ALU_RESULT1(R0)
	441
	442	#define TRACE_ALU_RESULT0() \
	443	do { \
	444	if (TRACE_ALU_P (CPU)) \
	445	trace_result0 (SD, CPU, TRACE_ALU_IDX); \
	446	} while (0)
	447
	448	#define TRACE_ALU_RESULT1(R0) \
	449	do { \
	450	if (TRACE_ALU_P (CPU)) \
	451	trace_result_word1 (SD, CPU, TRACE_ALU_IDX, (R0)); \
	452	} while (0)
	453
	454	#define TRACE_ALU_RESULT2(R0,R1) \
	455	do { \
	456	if (TRACE_ALU_P (CPU)) \
	457	trace_result_word2 (SD, CPU, TRACE_ALU_IDX, (R0), (R1)); \
	458	} while (0)
	459
	460	#define TRACE_ALU_RESULT4(R0,R1,R2,R3) \
	461	do { \
	462	if (TRACE_ALU_P (CPU)) \
	463	trace_result_word4 (SD, CPU, TRACE_ALU_IDX, (R0), (R1), (R2), (R3)); \
	464	} while (0)
	465
44a9331c	466	/* Macros for tracing inputs to comparative branch instructions. */
c906108c	467
44a9331c BE	468	#define TRACE_BRANCH_INPUT1(V0) \
	469	do { \
	470	if (TRACE_BRANCH_P (CPU)) \
	471	trace_input_word1 (SD, CPU, TRACE_BRANCH_IDX, (V0)); \
	472	} while (0)
	473
	474	#define TRACE_BRANCH_INPUT2(V0,V1) \
	475	do { \
	476	if (TRACE_BRANCH_P (CPU)) \
	477	trace_input_word2 (SD, CPU, TRACE_BRANCH_IDX, (V0), (V1)); \
	478	} while (0)
	479
	480	/* Macros for tracing FPU instructions */
c906108c SS	481
	482	#define TRACE_FP_INPUT0() \
	483	do { \
	484	if (TRACE_FPU_P (CPU)) \
	485	trace_input0 (SD, CPU, TRACE_FPU_IDX); \
	486	} while (0)
028f6515	487
c906108c SS	488	#define TRACE_FP_INPUT1(V0) \
	489	do { \
	490	if (TRACE_FPU_P (CPU)) \
	491	trace_input_fp1 (SD, CPU, TRACE_FPU_IDX, (V0)); \
	492	} while (0)
	493
	494	#define TRACE_FP_INPUT2(V0,V1) \
	495	do { \
	496	if (TRACE_FPU_P (CPU)) \
	497	trace_input_fp2 (SD, CPU, TRACE_FPU_IDX, (V0), (V1)); \
	498	} while (0)
	499
	500	#define TRACE_FP_INPUT3(V0,V1,V2) \
	501	do { \
	502	if (TRACE_FPU_P (CPU)) \
	503	trace_input_fp3 (SD, CPU, TRACE_FPU_IDX, (V0), (V1), (V2)); \
	504	} while (0)
	505
	506	#define TRACE_FP_INPUT_WORD1(V0) \
	507	do { \
	508	if (TRACE_FPU_P (CPU)) \
	509	trace_input_word1 (SD, CPU, TRACE_FPU_IDX, (V0)); \
	510	} while (0)
028f6515	511
c906108c SS	512	#define TRACE_FP_RESULT(R0) \
	513	do { \
	514	if (TRACE_FPU_P (CPU)) \
	515	trace_result_fp1 (SD, CPU, TRACE_FPU_IDX, (R0)); \
	516	} while (0)
	517
	518	#define TRACE_FP_RESULT2(R0,R1) \
	519	do { \
	520	if (TRACE_FPU_P (CPU)) \
	521	trace_result_fp2 (SD, CPU, TRACE_FPU_IDX, (R0), (R1)); \
	522	} while (0)
	523
	524	#define TRACE_FP_RESULT_BOOL(R0) \
	525	do { \
	526	if (TRACE_FPU_P (CPU)) \
	527	trace_result_bool1 (SD, CPU, TRACE_FPU_IDX, (R0)); \
	528	} while (0)
	529
	530	#define TRACE_FP_RESULT_WORD(R0) \
	531	do { \
	532	if (TRACE_FPU_P (CPU)) \
	533	trace_result_word1 (SD, CPU, TRACE_FPU_IDX, (R0)); \
	534	} while (0)
	535
	536
	537	/* Macros for tracing branches */
	538
	539	#define TRACE_BRANCH_INPUT(COND) \
	540	do { \
	541	if (TRACE_BRANCH_P (CPU)) \
	542	trace_input_bool1 (SD, CPU, TRACE_BRANCH_IDX, (COND)); \
	543	} while (0)
	544
	545	#define TRACE_BRANCH_RESULT(DEST) \
	546	do { \
	547	if (TRACE_BRANCH_P (CPU)) \
	548	trace_result_addr1 (SD, CPU, TRACE_BRANCH_IDX, (DEST)); \
	549	} while (0)
	550
	551	\f
	552	/* The function trace_one_insn has been replaced by the function pair
	553	trace_prefix() + trace_generic() */
bdca5ee4 TT	554	extern void trace_one_insn (SIM_DESC sd,
	555	sim_cpu * cpu,
	556	address_word cia,
	557	int print_linenum_p,
	558	const char *file_name,
	559	int line_nr,
	560	const char *unit,
	561	const char *fmt,
	562	...)
c906108c SS	563	__attribute__((format (printf, 8, 9)));
c906108c SS	564
bdca5ee4	565	extern void trace_printf (SIM_DESC, sim_cpu , const char , ...)
c906108c SS	566	__attribute__((format (printf, 3, 4)));
c906108c SS	567
bdca5ee4	568	extern void trace_vprintf (SIM_DESC, sim_cpu , const char , va_list);
c906108c SS	569
	570	/* Debug support.
	571	This is included here because there isn't enough of it to justify
	572	a sim-debug.h. */
	573
	574	/* Return non-zero if debugging of IDX for CPU is enabled. */
	575	#define DEBUG_P(cpu, idx) \
	576	((WITH_DEBUG & (1 << (idx))) != 0 \
	577	&& CPU_DEBUG_FLAGS (cpu)[idx] != 0)
	578
	579	/* Non-zero if "--debug-insn" specified. */
	580	#define DEBUG_INSN_P(cpu) DEBUG_P (cpu, DEBUG_INSN_IDX)
	581
6aefca7e GB	582	/* GDB also has a debug_printf, so we shadow ours. */
	583	#define debug_printf sim_debug_printf
	584
bdca5ee4	585	extern void debug_printf (sim_cpu , const char , ...)
c906108c SS	586	__attribute__((format (printf, 2, 3)));
	587
	588	#endif /* SIM_TRACE_H */