[deliverable/binutils-gdb.git] / gdb / common / btrace-common.h

/* Branch trace support for GDB, the GNU debugger.

   Copyright (C) 2013-2015 Free Software Foundation, Inc.

   Contributed by Intel Corp. <markus.t.metzger@intel.com>.

   This file is part of GDB.

   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/>.  */

#ifndef BTRACE_COMMON_H
#define BTRACE_COMMON_H

/* Branch tracing (btrace) is a per-thread control-flow execution trace of the
   inferior.  For presentation purposes, the branch trace is represented as a
   list of sequential control-flow blocks, one such list per thread.  */

#include "vec.h"

/* A branch trace block.

   This represents a block of sequential control-flow.  Adjacent blocks will be
   connected via calls, returns, or jumps.  The latter can be direct or
   indirect, conditional or unconditional.  Branches can further be
   asynchronous, e.g. interrupts.  */
struct btrace_block
{
  /* The address of the first byte of the first instruction in the block.
     The address may be zero if we do not know the beginning of this block,
     such as for the first block in a delta trace.  */
  CORE_ADDR begin;

  /* The address of the first byte of the last instruction in the block.  */
  CORE_ADDR end;
};

/* Define functions operating on a vector of branch trace blocks.  */
typedef struct btrace_block btrace_block_s;
DEF_VEC_O (btrace_block_s);

/* Enumeration of btrace formats.  */

enum btrace_format
{
  /* No branch trace format.  */
  BTRACE_FORMAT_NONE,

  /* Branch trace is in Branch Trace Store (BTS) format.
     Actually, the format is a sequence of blocks derived from BTS.  */
  BTRACE_FORMAT_BTS
};

/* A BTS configuration.  */

struct btrace_config_bts
{
  /* The size of the branch trace buffer in bytes.  */
  unsigned int size;
};

/* A branch tracing configuration.

   This describes the requested configuration as well as the actually
   obtained configuration.
   We describe the configuration for all different formats so we can
   easily switch between formats.  */

struct btrace_config
{
  /* The branch tracing format.  */
  enum btrace_format format;

  /* The BTS format configuration.  */
  struct btrace_config_bts bts;
};

/* Branch trace in BTS format.  */
struct btrace_data_bts
{
  /* Branch trace is represented as a vector of branch trace blocks starting
     with the most recent block.  */
  VEC (btrace_block_s) *blocks;
};

/* The branch trace data.  */
struct btrace_data
{
  enum btrace_format format;

  union
  {
    /* Format == BTRACE_FORMAT_BTS.  */
    struct btrace_data_bts bts;
  } variant;
};

/* Target specific branch trace information.  */
struct btrace_target_info;

/* Enumeration of btrace read types.  */

enum btrace_read_type
{
  /* Send all available trace.  */
  BTRACE_READ_ALL,

  /* Send all available trace, if it changed.  */
  BTRACE_READ_NEW,

  /* Send the trace since the last request.  This will fail if the trace
     buffer overflowed.  */
  BTRACE_READ_DELTA
};

/* Enumeration of btrace errors.  */

enum btrace_error
{
  /* No error.  Everything is OK.  */
  BTRACE_ERR_NONE,

  /* An unknown error.  */
  BTRACE_ERR_UNKNOWN,

  /* Branch tracing is not supported on this system.  */
  BTRACE_ERR_NOT_SUPPORTED,

  /* The branch trace buffer overflowed; no delta read possible.  */
  BTRACE_ERR_OVERFLOW
};

/* Return a string representation of FORMAT.  */
extern const char *btrace_format_string (enum btrace_format format);

/* Initialize DATA.  */
extern void btrace_data_init (struct btrace_data *data);

/* Cleanup DATA.  */
extern void btrace_data_fini (struct btrace_data *data);

/* Return non-zero if DATA is empty; zero otherwise.  */
extern int btrace_data_empty (struct btrace_data *data);

#endif /* BTRACE_COMMON_H */
Commit	Line	Data
02d27625 MM	1	/* Branch trace support for GDB, the GNU debugger.
02d27625 MM	2
32d0add0	3	Copyright (C) 2013-2015 Free Software Foundation, Inc.
02d27625 MM	4
	5	Contributed by Intel Corp. <markus.t.metzger@intel.com>.
	6
	7	This file is part of GDB.
	8
	9	This program is free software; you can redistribute it and/or modify
	10	it under the terms of the GNU General Public License as published by
	11	the Free Software Foundation; either version 3 of the License, or
	12	(at your option) any later version.
	13
	14	This program is distributed in the hope that it will be useful,
	15	but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	GNU General Public License for more details.
	18
	19	You should have received a copy of the GNU General Public License
	20	along with this program. If not, see <http://www.gnu.org/licenses/>. */
	21
	22	#ifndef BTRACE_COMMON_H
	23	#define BTRACE_COMMON_H
	24
	25	/* Branch tracing (btrace) is a per-thread control-flow execution trace of the
	26	inferior. For presentation purposes, the branch trace is represented as a
	27	list of sequential control-flow blocks, one such list per thread. */
	28
02d27625 MM	29	#include "vec.h"
	30
	31	/* A branch trace block.
	32
	33	This represents a block of sequential control-flow. Adjacent blocks will be
	34	connected via calls, returns, or jumps. The latter can be direct or
	35	indirect, conditional or unconditional. Branches can further be
	36	asynchronous, e.g. interrupts. */
	37	struct btrace_block
	38	{
969c39fb MM	39	/* The address of the first byte of the first instruction in the block.
	40	The address may be zero if we do not know the beginning of this block,
	41	such as for the first block in a delta trace. */
02d27625 MM	42	CORE_ADDR begin;
	43
	44	/* The address of the first byte of the last instruction in the block. */
	45	CORE_ADDR end;
	46	};
	47
02d27625	48	/* Define functions operating on a vector of branch trace blocks. */
734b0e4b	49	typedef struct btrace_block btrace_block_s;
02d27625 MM	50	DEF_VEC_O (btrace_block_s);
02d27625 MM	51
734b0e4b MM	52	/* Enumeration of btrace formats. */
	53
	54	enum btrace_format
	55	{
	56	/* No branch trace format. */
	57	BTRACE_FORMAT_NONE,
	58
	59	/* Branch trace is in Branch Trace Store (BTS) format.
	60	Actually, the format is a sequence of blocks derived from BTS. */
	61	BTRACE_FORMAT_BTS
	62	};
	63
d33501a5 MM	64	/* A BTS configuration. */
	65
	66	struct btrace_config_bts
	67	{
	68	/* The size of the branch trace buffer in bytes. */
	69	unsigned int size;
	70	};
	71
f4abbc16 MM	72	/* A branch tracing configuration.
	73
	74	This describes the requested configuration as well as the actually
d33501a5 MM	75	obtained configuration.
	76	We describe the configuration for all different formats so we can
	77	easily switch between formats. */
f4abbc16 MM	78
	79	struct btrace_config
	80	{
	81	/* The branch tracing format. */
	82	enum btrace_format format;
d33501a5 MM	83
	84	/* The BTS format configuration. */
	85	struct btrace_config_bts bts;
f4abbc16 MM	86	};
f4abbc16 MM	87
734b0e4b MM	88	/* Branch trace in BTS format. */
	89	struct btrace_data_bts
	90	{
	91	/* Branch trace is represented as a vector of branch trace blocks starting
	92	with the most recent block. */
	93	VEC (btrace_block_s) *blocks;
	94	};
	95
	96	/* The branch trace data. */
	97	struct btrace_data
	98	{
	99	enum btrace_format format;
	100
	101	union
	102	{
	103	/* Format == BTRACE_FORMAT_BTS. */
	104	struct btrace_data_bts bts;
	105	} variant;
	106	};
	107
02d27625 MM	108	/* Target specific branch trace information. */
	109	struct btrace_target_info;
	110
	111	/* Enumeration of btrace read types. */
	112
	113	enum btrace_read_type
	114	{
	115	/* Send all available trace. */
864089d2	116	BTRACE_READ_ALL,
02d27625 MM	117
02d27625 MM	118	/* Send all available trace, if it changed. */
969c39fb MM	119	BTRACE_READ_NEW,
	120
	121	/* Send the trace since the last request. This will fail if the trace
	122	buffer overflowed. */
	123	BTRACE_READ_DELTA
	124	};
	125
	126	/* Enumeration of btrace errors. */
	127
	128	enum btrace_error
	129	{
	130	/* No error. Everything is OK. */
	131	BTRACE_ERR_NONE,
	132
	133	/* An unknown error. */
	134	BTRACE_ERR_UNKNOWN,
	135
	136	/* Branch tracing is not supported on this system. */
	137	BTRACE_ERR_NOT_SUPPORTED,
	138
	139	/* The branch trace buffer overflowed; no delta read possible. */
	140	BTRACE_ERR_OVERFLOW
02d27625 MM	141	};
02d27625 MM	142
734b0e4b MM	143	/* Return a string representation of FORMAT. */
	144	extern const char *btrace_format_string (enum btrace_format format);
	145
	146	/* Initialize DATA. */
	147	extern void btrace_data_init (struct btrace_data *data);
	148
	149	/* Cleanup DATA. */
	150	extern void btrace_data_fini (struct btrace_data *data);
	151
	152	/* Return non-zero if DATA is empty; zero otherwise. */
	153	extern int btrace_data_empty (struct btrace_data *data);
	154
02d27625	155	#endif /* BTRACE_COMMON_H */