gdb/common/btrace-common.h

   1 /* Branch trace support for GDB, the GNU debugger.
   2
   3    Copyright (C) 2013-2019 Free Software Foundation, Inc.
   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 COMMON_BTRACE_COMMON_H
  23 #define COMMON_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
  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 {
  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.  */
  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
  48 /* Define functions operating on a vector of branch trace blocks.  */
  49 typedef struct btrace_block btrace_block_s;
  50 DEF_VEC_O (btrace_block_s);
  51
  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   /* Branch trace is in Intel Processor Trace format.  */
  64   BTRACE_FORMAT_PT
  65 };
  66
  67 /* An enumeration of cpu vendors.  */
  68
  69 enum btrace_cpu_vendor
  70 {
  71   /* We do not know this vendor.  */
  72   CV_UNKNOWN,
  73
  74   /* Intel.  */
  75   CV_INTEL
  76 };
  77
  78 /* A cpu identifier.  */
  79
  80 struct btrace_cpu
  81 {
  82   /* The processor vendor.  */
  83   enum btrace_cpu_vendor vendor;
  84
  85   /* The cpu family.  */
  86   unsigned short family;
  87
  88   /* The cpu model.  */
  89   unsigned char model;
  90
  91   /* The cpu stepping.  */
  92   unsigned char stepping;
  93 };
  94
  95 /* A BTS configuration.  */
  96
  97 struct btrace_config_bts
  98 {
  99   /* The size of the branch trace buffer in bytes.
 100
 101      This is unsigned int and not size_t since it is registered as
 102      control variable for "set record btrace bts buffer-size".  */
 103   unsigned int size;
 104 };
 105
 106 /* An Intel Processor Trace configuration.  */
 107
 108 struct btrace_config_pt
 109 {
 110   /* The size of the branch trace buffer in bytes.
 111
 112      This is unsigned int and not size_t since it is registered as
 113      control variable for "set record btrace pt buffer-size".  */
 114   unsigned int size;
 115 };
 116
 117 /* A branch tracing configuration.
 118
 119    This describes the requested configuration as well as the actually
 120    obtained configuration.
 121    We describe the configuration for all different formats so we can
 122    easily switch between formats.  */
 123
 124 struct btrace_config
 125 {
 126   /* The branch tracing format.  */
 127   enum btrace_format format;
 128
 129   /* The BTS format configuration.  */
 130   struct btrace_config_bts bts;
 131
 132   /* The Intel Processor Trace format configuration.  */
 133   struct btrace_config_pt pt;
 134 };
 135
 136 /* Branch trace in BTS format.  */
 137 struct btrace_data_bts
 138 {
 139   /* Branch trace is represented as a vector of branch trace blocks starting
 140      with the most recent block.  */
 141   VEC (btrace_block_s) *blocks;
 142 };
 143
 144 /* Configuration information to go with the trace data.  */
 145 struct btrace_data_pt_config
 146 {
 147   /* The processor on which the trace has been collected.  */
 148   struct btrace_cpu cpu;
 149 };
 150
 151 /* Branch trace in Intel Processor Trace format.  */
 152 struct btrace_data_pt
 153 {
 154   /* Some configuration information to go with the data.  */
 155   struct btrace_data_pt_config config;
 156
 157   /* The trace data.  */
 158   gdb_byte *data;
 159
 160   /* The size of DATA in bytes.  */
 161   size_t size;
 162 };
 163
 164 /* The branch trace data.  */
 165 struct btrace_data
 166 {
 167   btrace_data () = default;
 168
 169   ~btrace_data ()
 170   {
 171     fini ();
 172   }
 173
 174   btrace_data &operator= (btrace_data &&other)
 175   {
 176     if (this != &other)
 177       {
 178         fini ();
 179         format = other.format;
 180         variant = other.variant;
 181         other.format = BTRACE_FORMAT_NONE;
 182       }
 183     return *this;
 184   }
 185
 186   /* Return true if this is empty; false otherwise.  */
 187   bool empty () const;
 188
 189   /* Clear this object.  */
 190   void clear ();
 191
 192   enum btrace_format format = BTRACE_FORMAT_NONE;
 193
 194   union
 195   {
 196     /* Format == BTRACE_FORMAT_BTS.  */
 197     struct btrace_data_bts bts;
 198
 199     /* Format == BTRACE_FORMAT_PT.  */
 200     struct btrace_data_pt pt;
 201   } variant;
 202
 203 private:
 204
 205   DISABLE_COPY_AND_ASSIGN (btrace_data);
 206
 207   void fini ();
 208 };
 209
 210 /* Target specific branch trace information.  */
 211 struct btrace_target_info;
 212
 213 /* Enumeration of btrace read types.  */
 214
 215 enum btrace_read_type
 216 {
 217   /* Send all available trace.  */
 218   BTRACE_READ_ALL,
 219
 220   /* Send all available trace, if it changed.  */
 221   BTRACE_READ_NEW,
 222
 223   /* Send the trace since the last request.  This will fail if the trace
 224      buffer overflowed.  */
 225   BTRACE_READ_DELTA
 226 };
 227
 228 /* Enumeration of btrace errors.  */
 229
 230 enum btrace_error
 231 {
 232   /* No error.  Everything is OK.  */
 233   BTRACE_ERR_NONE,
 234
 235   /* An unknown error.  */
 236   BTRACE_ERR_UNKNOWN,
 237
 238   /* Branch tracing is not supported on this system.  */
 239   BTRACE_ERR_NOT_SUPPORTED,
 240
 241   /* The branch trace buffer overflowed; no delta read possible.  */
 242   BTRACE_ERR_OVERFLOW
 243 };
 244
 245 /* Return a string representation of FORMAT.  */
 246 extern const char *btrace_format_string (enum btrace_format format);
 247
 248 /* Return an abbreviation string representation of FORMAT.  */
 249 extern const char *btrace_format_short_string (enum btrace_format format);
 250
 251 /* Append the branch trace data from SRC to the end of DST.
 252    Both SRC and DST must use the same format.
 253    Returns zero on success; a negative number otherwise.  */
 254 extern int btrace_data_append (struct btrace_data *dst,
 255                                const struct btrace_data *src);
 256
 257 #endif /* COMMON_BTRACE_COMMON_H */