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

/* Simulator tracing/debugging support.
   Copyright (C) 1997-2013 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 \
((1 << TRACE_INSN_IDX) \
 | (1 << TRACE_LINENUM_IDX) \
 | (1 << TRACE_MEMORY_IDX) \
 | (1 << TRACE_MODEL_IDX))
\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_INSN_P	(WITH_TRACE & TRACE_insn)
#define WITH_TRACE_DECODE_P	(WITH_TRACE & TRACE_decode)
#define WITH_TRACE_EXTRACT_P	(WITH_TRACE & TRACE_extract)
#define WITH_TRACE_LINENUM_P	(WITH_TRACE & TRACE_linenum)
#define WITH_TRACE_MEMORY_P	(WITH_TRACE & TRACE_memory)
#define WITH_TRACE_MODEL_P	(WITH_TRACE & TRACE_model)
#define WITH_TRACE_ALU_P	(WITH_TRACE & TRACE_alu)
#define WITH_TRACE_CORE_P	(WITH_TRACE & TRACE_core)
#define WITH_TRACE_EVENTS_P	(WITH_TRACE & TRACE_events)
#define WITH_TRACE_FPU_P	(WITH_TRACE & TRACE_fpu)
#define WITH_TRACE_VPU_P	(WITH_TRACE & TRACE_vpu)
#define WITH_TRACE_BRANCH_P	(WITH_TRACE & TRACE_branch)
#define WITH_TRACE_SYSCALL_P	(WITH_TRACE & TRACE_syscall)
#define WITH_TRACE_DEBUG_P	(WITH_TRACE & TRACE_debug)

/* 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 & (1 << (idx))) != 0 \
 && 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 & (1 << (idx))) != 0 \
 && 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 PARAMS ((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 PARAMS ((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 PARAMS ((SIM_DESC sd,
                               TRACE_DATA *data,
                               data_fmt fmt,
                               long size,
                               const void *buf));

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

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

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

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

extern void trace_input_word4 PARAMS ((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 PARAMS ((SIM_DESC sd,
				       sim_cpu *cpu,
				       int trace_idx,
				       address_word d0));

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

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

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

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

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

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

extern void trace_input_fpu3 PARAMS ((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 PARAMS ((SIM_DESC sd,
				   sim_cpu *cpu,
				   int trace_idx));

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

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

extern void trace_result_word4 PARAMS ((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 PARAMS ((SIM_DESC sd,
					sim_cpu *cpu,
					int trace_idx,
					int r0));

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

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

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

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

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

extern void trace_result_word1_string1 PARAMS ((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 PARAMS ((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 PARAMS ((SIM_DESC, sim_cpu *, const char *, ...))
     __attribute__((format (printf, 3, 4)));

extern void trace_vprintf PARAMS ((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)

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

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