[binutils.git] / gdb / tracefile.c

/* Trace file support in GDB.

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

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

#include "defs.h"
#include "tracefile.h"
#include "ctf.h"
#include "exec.h"
#include "regcache.h"

/* Helper macros.  */

#define TRACE_WRITE_R_BLOCK(writer, buf, size)	\
  writer->ops->frame_ops->write_r_block ((writer), (buf), (size))
#define TRACE_WRITE_M_BLOCK_HEADER(writer, addr, size)		  \
  writer->ops->frame_ops->write_m_block_header ((writer), (addr), \
						(size))
#define TRACE_WRITE_M_BLOCK_MEMORY(writer, buf, size)	  \
  writer->ops->frame_ops->write_m_block_memory ((writer), (buf), \
						(size))
#define TRACE_WRITE_V_BLOCK(writer, num, val)	\
  writer->ops->frame_ops->write_v_block ((writer), (num), (val))

/* Free trace file writer.  */

static void
trace_file_writer_xfree (void *arg)
{
  struct trace_file_writer *writer = arg;

  writer->ops->dtor (writer);
  xfree (writer);
}

/* Save tracepoint data to file named FILENAME through WRITER.  WRITER
   determines the trace file format.  If TARGET_DOES_SAVE is non-zero,
   the save is performed on the target, otherwise GDB obtains all trace
   data and saves it locally.  */

static void
trace_save (const char *filename, struct trace_file_writer *writer,
	    int target_does_save)
{
  struct trace_status *ts = current_trace_status ();
  int status;
  struct uploaded_tp *uploaded_tps = NULL, *utp;
  struct uploaded_tsv *uploaded_tsvs = NULL, *utsv;

  ULONGEST offset = 0;
#define MAX_TRACE_UPLOAD 2000
  gdb_byte buf[MAX_TRACE_UPLOAD];
  int written;
  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());

  /* If the target is to save the data to a file on its own, then just
     send the command and be done with it.  */
  if (target_does_save)
    {
      if (!writer->ops->target_save (writer, filename))
	error (_("Target failed to save trace data to '%s'."),
	       filename);
      return;
    }

  /* Get the trace status first before opening the file, so if the
     target is losing, we can get out without touching files.  */
  status = target_get_trace_status (ts);

  writer->ops->start (writer, filename);

  writer->ops->write_header (writer);

  /* Write descriptive info.  */

  /* Write out the size of a register block.  */
  writer->ops->write_regblock_type (writer, trace_regblock_size);

  /* Write out status of the tracing run (aka "tstatus" info).  */
  writer->ops->write_status (writer, ts);

  /* Note that we want to upload tracepoints and save those, rather
     than simply writing out the local ones, because the user may have
     changed tracepoints in GDB in preparation for a future tracing
     run, or maybe just mass-deleted all types of breakpoints as part
     of cleaning up.  So as not to contaminate the session, leave the
     data in its uploaded form, don't make into real tracepoints.  */

  /* Get trace state variables first, they may be checked when parsing
     uploaded commands.  */

  target_upload_trace_state_variables (&uploaded_tsvs);

  for (utsv = uploaded_tsvs; utsv; utsv = utsv->next)
    writer->ops->write_uploaded_tsv (writer, utsv);

  free_uploaded_tsvs (&uploaded_tsvs);

  target_upload_tracepoints (&uploaded_tps);

  for (utp = uploaded_tps; utp; utp = utp->next)
    target_get_tracepoint_status (NULL, utp);

  for (utp = uploaded_tps; utp; utp = utp->next)
    writer->ops->write_uploaded_tp (writer, utp);

  free_uploaded_tps (&uploaded_tps);

  /* Mark the end of the definition section.  */
  writer->ops->write_definition_end (writer);

  /* Get and write the trace data proper.  */
  while (1)
    {
      LONGEST gotten = 0;

      /* The writer supports writing the contents of trace buffer
	  directly to trace file.  Don't parse the contents of trace
	  buffer.  */
      if (writer->ops->write_trace_buffer != NULL)
	{
	  /* We ask for big blocks, in the hopes of efficiency, but
	     will take less if the target has packet size limitations
	     or some such.  */
	  gotten = target_get_raw_trace_data (buf, offset,
					      MAX_TRACE_UPLOAD);
	  if (gotten < 0)
	    error (_("Failure to get requested trace buffer data"));
	  /* No more data is forthcoming, we're done.  */
	  if (gotten == 0)
	    break;

	  writer->ops->write_trace_buffer (writer, buf, gotten);

	  offset += gotten;
	}
      else
	{
	  uint16_t tp_num;
	  uint32_t tf_size;
	  /* Parse the trace buffers according to how data are stored
	     in trace buffer in GDBserver.  */

	  gotten = target_get_raw_trace_data (buf, offset, 6);

	  if (gotten == 0)
	    break;

	  /* Read the first six bytes in, which is the tracepoint
	     number and trace frame size.  */
	  tp_num = (uint16_t)
	    extract_unsigned_integer (&buf[0], 2, byte_order);

	  tf_size = (uint32_t)
	    extract_unsigned_integer (&buf[2], 4, byte_order);

	  writer->ops->frame_ops->start (writer, tp_num);
	  gotten = 6;

	  if (tf_size > 0)
	    {
	      unsigned int block;

	      offset += 6;

	      for (block = 0; block < tf_size; )
		{
		  gdb_byte block_type;

		  /* We'll fetch one block each time, in order to
		     handle the extremely large 'M' block.  We first
		     fetch one byte to get the type of the block.  */
		  gotten = target_get_raw_trace_data (buf, offset, 1);
		  if (gotten < 1)
		    error (_("Failure to get requested trace buffer data"));

		  gotten = 1;
		  block += 1;
		  offset += 1;

		  block_type = buf[0];
		  switch (block_type)
		    {
		    case 'R':
		      gotten
			= target_get_raw_trace_data (buf, offset,
						     trace_regblock_size);
		      if (gotten < trace_regblock_size)
			error (_("Failure to get requested trace"
				 " buffer data"));

		      TRACE_WRITE_R_BLOCK (writer, buf,
					   trace_regblock_size);
		      break;
		    case 'M':
		      {
			unsigned short mlen;
			ULONGEST addr;
			LONGEST t;
			int j;

			t = target_get_raw_trace_data (buf,offset, 10);
			if (t < 10)
			  error (_("Failure to get requested trace"
				   " buffer data"));

			offset += 10;
			block += 10;

			gotten = 0;
			addr = (ULONGEST)
			  extract_unsigned_integer (buf, 8,
						    byte_order);
			mlen = (unsigned short)
			  extract_unsigned_integer (&buf[8], 2,
						    byte_order);

			TRACE_WRITE_M_BLOCK_HEADER (writer, addr,
						    mlen);

			/* The memory contents in 'M' block may be
			   very large.  Fetch the data from the target
			   and write them into file one by one.  */
			for (j = 0; j < mlen; )
			  {
			    unsigned int read_length;

			    if (mlen - j > MAX_TRACE_UPLOAD)
			      read_length = MAX_TRACE_UPLOAD;
			    else
			      read_length = mlen - j;

			    t = target_get_raw_trace_data (buf,
							   offset + j,
							   read_length);
			    if (t < read_length)
			      error (_("Failure to get requested"
				       " trace buffer data"));

			    TRACE_WRITE_M_BLOCK_MEMORY (writer, buf,
							read_length);

			    j += read_length;
			    gotten += read_length;
			  }

			break;
		      }
		    case 'V':
		      {
			int vnum;
			LONGEST val;

			gotten
			  = target_get_raw_trace_data (buf, offset,
						       12);
			if (gotten < 12)
			  error (_("Failure to get requested"
				   " trace buffer data"));

			vnum  = (int) extract_signed_integer (buf,
							      4,
							      byte_order);
			val
			  = extract_signed_integer (&buf[4], 8,
						    byte_order);

			TRACE_WRITE_V_BLOCK (writer, vnum, val);
		      }
		      break;
		    default:
		      error (_("Unknown block type '%c' (0x%x) in"
			       " trace frame"),
			     block_type, block_type);
		    }

		  block += gotten;
		  offset += gotten;
		}
	    }
	  else
	    offset += gotten;

	  writer->ops->frame_ops->end (writer);
	}
    }

  writer->ops->end (writer);
}

static void
trace_save_command (char *args, int from_tty)
{
  int target_does_save = 0;
  char **argv;
  char *filename = NULL;
  struct cleanup *back_to;
  int generate_ctf = 0;
  struct trace_file_writer *writer = NULL;

  if (args == NULL)
    error_no_arg (_("file in which to save trace data"));

  argv = gdb_buildargv (args);
  back_to = make_cleanup_freeargv (argv);

  for (; *argv; ++argv)
    {
      if (strcmp (*argv, "-r") == 0)
	target_does_save = 1;
      if (strcmp (*argv, "-ctf") == 0)
	generate_ctf = 1;
      else if (**argv == '-')
	error (_("unknown option `%s'"), *argv);
      else
	filename = *argv;
    }

  if (!filename)
    error_no_arg (_("file in which to save trace data"));

  if (generate_ctf)
    writer = ctf_trace_file_writer_new ();
  else
    writer = tfile_trace_file_writer_new ();

  make_cleanup (trace_file_writer_xfree, writer);

  trace_save (filename, writer, target_does_save);

  if (from_tty)
    printf_filtered (_("Trace data saved to %s '%s'.\n"),
		     generate_ctf ? "directory" : "file", filename);

  do_cleanups (back_to);
}

/* Save the trace data to file FILENAME of tfile format.  */

void
trace_save_tfile (const char *filename, int target_does_save)
{
  struct trace_file_writer *writer;
  struct cleanup *back_to;

  writer = tfile_trace_file_writer_new ();
  back_to = make_cleanup (trace_file_writer_xfree, writer);
  trace_save (filename, writer, target_does_save);
  do_cleanups (back_to);
}

/* Save the trace data to dir DIRNAME of ctf format.  */

void
trace_save_ctf (const char *dirname, int target_does_save)
{
  struct trace_file_writer *writer;
  struct cleanup *back_to;

  writer = ctf_trace_file_writer_new ();
  back_to = make_cleanup (trace_file_writer_xfree, writer);

  trace_save (dirname, writer, target_does_save);
  do_cleanups (back_to);
}

/* Fetch register data from tracefile, shared for both tfile and
   ctf.  */

void
tracefile_fetch_registers (struct regcache *regcache, int regno)
{
  struct gdbarch *gdbarch = get_regcache_arch (regcache);
  int regn, pc_regno;

  /* We get here if no register data has been found.  Mark registers
     as unavailable.  */
  for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
    regcache_raw_supply (regcache, regn, NULL);

  /* We can often usefully guess that the PC is going to be the same
     as the address of the tracepoint.  */
  pc_regno = gdbarch_pc_regnum (gdbarch);

  /* XXX This guessing code below only works if the PC register isn't
     a pseudo-register.  The value of a pseudo-register isn't stored
     in the (non-readonly) regcache -- instead it's recomputed
     (probably from some other cached raw register) whenever the
     register is read.  This guesswork should probably move to some
     higher layer.  */
  if (pc_regno < 0 || pc_regno >= gdbarch_num_regs (gdbarch))
    return;

  if (regno == -1 || regno == pc_regno)
    {
      struct tracepoint *tp = get_tracepoint (get_tracepoint_number ());
      gdb_byte *regs;

      if (tp && tp->base.loc)
	{
	  /* But don't try to guess if tracepoint is multi-location...  */
	  if (tp->base.loc->next)
	    {
	      warning (_("Tracepoint %d has multiple "
			 "locations, cannot infer $pc"),
		       tp->base.number);
	      return;
	    }
	  /* ... or does while-stepping.  */
	  if (tp->step_count > 0)
	    {
	      warning (_("Tracepoint %d does while-stepping, "
			 "cannot infer $pc"),
		       tp->base.number);
	      return;
	    }

	  regs = alloca (register_size (gdbarch, pc_regno));
	  store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
				  gdbarch_byte_order (gdbarch),
				  tp->base.loc->address);
	  regcache_raw_supply (regcache, pc_regno, regs);
	}
    }
}

/* This is the implementation of target_ops method to_has_all_memory.  */

static int
tracefile_has_all_memory (struct target_ops *ops)
{
  return 1;
}

/* This is the implementation of target_ops method to_has_memory.  */

static int
tracefile_has_memory (struct target_ops *ops)
{
  return 1;
}

/* This is the implementation of target_ops method to_has_stack.
   The target has a stack when GDB has already selected one trace
   frame.  */

static int
tracefile_has_stack (struct target_ops *ops)
{
  return get_traceframe_number () != -1;
}

/* This is the implementation of target_ops method to_has_registers.
   The target has registers when GDB has already selected one trace
   frame.  */

static int
tracefile_has_registers (struct target_ops *ops)
{
  return get_traceframe_number () != -1;
}

/* This is the implementation of target_ops method to_thread_alive.
   tracefile has one thread faked by GDB.  */

static int
tracefile_thread_alive (struct target_ops *ops, ptid_t ptid)
{
  return 1;
}

/* This is the implementation of target_ops method to_get_trace_status.
   The trace status for a file is that tracing can never be run.  */

static int
tracefile_get_trace_status (struct target_ops *self, struct trace_status *ts)
{
  /* Other bits of trace status were collected as part of opening the
     trace files, so nothing to do here.  */

  return -1;
}

/* Initialize OPS for tracefile related targets.  */

void
init_tracefile_ops (struct target_ops *ops)
{
  ops->to_stratum = process_stratum;
  ops->to_get_trace_status = tracefile_get_trace_status;
  ops->to_has_all_memory = tracefile_has_all_memory;
  ops->to_has_memory = tracefile_has_memory;
  ops->to_has_stack = tracefile_has_stack;
  ops->to_has_registers = tracefile_has_registers;
  ops->to_thread_alive = tracefile_thread_alive;
  ops->to_magic = OPS_MAGIC;
}

extern initialize_file_ftype _initialize_tracefile;

void
_initialize_tracefile (void)
{
  add_com ("tsave", class_trace, trace_save_command, _("\
Save the trace data to a file.\n\
Use the '-ctf' option to save the data to CTF format.\n\
Use the '-r' option to direct the target to save directly to the file,\n\
using its own filesystem."));
}
Commit	Line	Data
7951c4eb YQ	1	/* Trace file support in GDB.
7951c4eb YQ	2
32d0add0	3	Copyright (C) 1997-2015 Free Software Foundation, Inc.
7951c4eb YQ	4
	5	This file is part of GDB.
	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
	9	the Free Software Foundation; either version 3 of the License, or
	10	(at your option) any later version.
	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
	17	You should have received a copy of the GNU General Public License
	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
	19
	20	#include "defs.h"
	21	#include "tracefile.h"
	22	#include "ctf.h"
1ca49d37	23	#include "exec.h"
48b6e87e	24	#include "regcache.h"
7951c4eb YQ	25
	26	/* Helper macros. */
	27
	28	#define TRACE_WRITE_R_BLOCK(writer, buf, size) \
	29	writer->ops->frame_ops->write_r_block ((writer), (buf), (size))
	30	#define TRACE_WRITE_M_BLOCK_HEADER(writer, addr, size) \
	31	writer->ops->frame_ops->write_m_block_header ((writer), (addr), \
	32	(size))
	33	#define TRACE_WRITE_M_BLOCK_MEMORY(writer, buf, size) \
	34	writer->ops->frame_ops->write_m_block_memory ((writer), (buf), \
	35	(size))
	36	#define TRACE_WRITE_V_BLOCK(writer, num, val) \
	37	writer->ops->frame_ops->write_v_block ((writer), (num), (val))
	38
	39	/* Free trace file writer. */
	40
	41	static void
	42	trace_file_writer_xfree (void *arg)
	43	{
	44	struct trace_file_writer *writer = arg;
	45
	46	writer->ops->dtor (writer);
	47	xfree (writer);
	48	}
	49
	50	/* Save tracepoint data to file named FILENAME through WRITER. WRITER
	51	determines the trace file format. If TARGET_DOES_SAVE is non-zero,
	52	the save is performed on the target, otherwise GDB obtains all trace
	53	data and saves it locally. */
	54
	55	static void
	56	trace_save (const char filename, struct trace_file_writer writer,
	57	int target_does_save)
	58	{
	59	struct trace_status *ts = current_trace_status ();
	60	int status;
	61	struct uploaded_tp uploaded_tps = NULL, utp;
	62	struct uploaded_tsv uploaded_tsvs = NULL, utsv;
	63
	64	ULONGEST offset = 0;
	65	#define MAX_TRACE_UPLOAD 2000
	66	gdb_byte buf[MAX_TRACE_UPLOAD];
	67	int written;
	68	enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
	69
	70	/* If the target is to save the data to a file on its own, then just
	71	send the command and be done with it. */
	72	if (target_does_save)
	73	{
	74	if (!writer->ops->target_save (writer, filename))
	75	error (_("Target failed to save trace data to '%s'."),
	76	filename);
	77	return;
	78	}
	79
	80	/* Get the trace status first before opening the file, so if the
	81	target is losing, we can get out without touching files. */
	82	status = target_get_trace_status (ts);
	83
	84	writer->ops->start (writer, filename);
	85
	86	writer->ops->write_header (writer);
	87
	88	/* Write descriptive info. */
89
90	/* Write out the size of a register block. */
91	writer->ops->write_regblock_type (writer, trace_regblock_size);
92
93	/* Write out status of the tracing run (aka "tstatus" info). */
94	writer->ops->write_status (writer, ts);
95
96	/* Note that we want to upload tracepoints and save those, rather
97	than simply writing out the local ones, because the user may have
98	changed tracepoints in GDB in preparation for a future tracing
99	run, or maybe just mass-deleted all types of breakpoints as part
100	of cleaning up. So as not to contaminate the session, leave the
101	data in its uploaded form, don't make into real tracepoints. */
102
103	/* Get trace state variables first, they may be checked when parsing
104	uploaded commands. */
105
106	target_upload_trace_state_variables (&uploaded_tsvs);
107
108	for (utsv = uploaded_tsvs; utsv; utsv = utsv->next)
109	writer->ops->write_uploaded_tsv (writer, utsv);
110
111	free_uploaded_tsvs (&uploaded_tsvs);
112
113	target_upload_tracepoints (&uploaded_tps);
114
115	for (utp = uploaded_tps; utp; utp = utp->next)
116	target_get_tracepoint_status (NULL, utp);
117
118	for (utp = uploaded_tps; utp; utp = utp->next)
119	writer->ops->write_uploaded_tp (writer, utp);
120
121	free_uploaded_tps (&uploaded_tps);
122
123	/* Mark the end of the definition section. */
124	writer->ops->write_definition_end (writer);
125
126	/* Get and write the trace data proper. */
127	while (1)
128	{
129	LONGEST gotten = 0;
130
131	/* The writer supports writing the contents of trace buffer
132	directly to trace file. Don't parse the contents of trace
133	buffer. */
134	if (writer->ops->write_trace_buffer != NULL)
135	{
136	/* We ask for big blocks, in the hopes of efficiency, but
137	will take less if the target has packet size limitations
138	or some such. */
139	gotten = target_get_raw_trace_data (buf, offset,
140	MAX_TRACE_UPLOAD);
141	if (gotten < 0)
142	error (_("Failure to get requested trace buffer data"));
143	/* No more data is forthcoming, we're done. */
144	if (gotten == 0)
145	break;
146
147	writer->ops->write_trace_buffer (writer, buf, gotten);
148
149	offset += gotten;
150	}
151	else
152	{
153	uint16_t tp_num;
154	uint32_t tf_size;
155	/* Parse the trace buffers according to how data are stored
156	in trace buffer in GDBserver. */
157
158	gotten = target_get_raw_trace_data (buf, offset, 6);
159
160	if (gotten == 0)
161	break;
162
163	/* Read the first six bytes in, which is the tracepoint
164	number and trace frame size. */
165	tp_num = (uint16_t)
166	extract_unsigned_integer (&buf[0], 2, byte_order);
167
168	tf_size = (uint32_t)
169	extract_unsigned_integer (&buf[2], 4, byte_order);
170
171	writer->ops->frame_ops->start (writer, tp_num);
172	gotten = 6;
173
174	if (tf_size > 0)
175	{
176	unsigned int block;
177
178	offset += 6;
179
180	for (block = 0; block < tf_size; )
181	{
182	gdb_byte block_type;
183
184	/* We'll fetch one block each time, in order to
185	handle the extremely large 'M' block. We first
186	fetch one byte to get the type of the block. */
187	gotten = target_get_raw_trace_data (buf, offset, 1);
188	if (gotten < 1)
189	error (_("Failure to get requested trace buffer data"));
190
191	gotten = 1;
192	block += 1;
193	offset += 1;
194
195	block_type = buf[0];
196	switch (block_type)
197	{
198	case 'R':
199	gotten
200	= target_get_raw_trace_data (buf, offset,
201	trace_regblock_size);
202	if (gotten < trace_regblock_size)
203	error (_("Failure to get requested trace"
204	" buffer data"));
205
206	TRACE_WRITE_R_BLOCK (writer, buf,
207	trace_regblock_size);
208	break;
209	case 'M':
210	{
211	unsigned short mlen;
212	ULONGEST addr;
213	LONGEST t;
214	int j;
215
216	t = target_get_raw_trace_data (buf,offset, 10);
217	if (t < 10)
218	error (_("Failure to get requested trace"
219	" buffer data"));
220
221	offset += 10;
222	block += 10;
223
224	gotten = 0;
225	addr = (ULONGEST)
226	extract_unsigned_integer (buf, 8,
227	byte_order);
228	mlen = (unsigned short)
229	extract_unsigned_integer (&buf[8], 2,
230	byte_order);
231
232	TRACE_WRITE_M_BLOCK_HEADER (writer, addr,
233	mlen);
234
235	/* The memory contents in 'M' block may be
236	very large. Fetch the data from the target
237	and write them into file one by one. */
238	for (j = 0; j < mlen; )
239	{
240	unsigned int read_length;
241
242	if (mlen - j > MAX_TRACE_UPLOAD)
243	read_length = MAX_TRACE_UPLOAD;
244	else
245	read_length = mlen - j;
246
247	t = target_get_raw_trace_data (buf,
248	offset + j,
249	read_length);
250	if (t < read_length)
251	error (_("Failure to get requested"
252	" trace buffer data"));
253
254	TRACE_WRITE_M_BLOCK_MEMORY (writer, buf,
255	read_length);
256
257	j += read_length;
258	gotten += read_length;
259	}
260
261	break;
262	}
263	case 'V':
264	{
265	int vnum;
266	LONGEST val;
267
268	gotten
269	= target_get_raw_trace_data (buf, offset,
270	12);
271	if (gotten < 12)
272	error (_("Failure to get requested"
273	" trace buffer data"));
274
275	vnum = (int) extract_signed_integer (buf,
276	4,
277	byte_order);
278	val
279	= extract_signed_integer (&buf[4], 8,
280	byte_order);
281
282	TRACE_WRITE_V_BLOCK (writer, vnum, val);
283	}
284	break;
285	default:
286	error (_("Unknown block type '%c' (0x%x) in"
287	" trace frame"),
288	block_type, block_type);
289	}
290
291	block += gotten;
292	offset += gotten;
293	}
294	}
295	else
296	offset += gotten;
297
298	writer->ops->frame_ops->end (writer);
299	}
300	}
301
302	writer->ops->end (writer);
303	}
304
305	static void
306	trace_save_command (char *args, int from_tty)
307	{
308	int target_does_save = 0;
309	char **argv;
310	char *filename = NULL;
311	struct cleanup *back_to;
312	int generate_ctf = 0;
313	struct trace_file_writer *writer = NULL;
314
315	if (args == NULL)
316	error_no_arg (_("file in which to save trace data"));
317
318	argv = gdb_buildargv (args);
319	back_to = make_cleanup_freeargv (argv);
320
321	for (; *argv; ++argv)
322	{
323	if (strcmp (*argv, "-r") == 0)
324	target_does_save = 1;
325	if (strcmp (*argv, "-ctf") == 0)
326	generate_ctf = 1;
327	else if (**argv == '-')
328	error (_("unknown option `%s'"), *argv);
329	else
330	filename = *argv;
331	}
332
333	if (!filename)
334	error_no_arg (_("file in which to save trace data"));
335
336	if (generate_ctf)
337	writer = ctf_trace_file_writer_new ();
338	else
339	writer = tfile_trace_file_writer_new ();
340
341	make_cleanup (trace_file_writer_xfree, writer);
342
343	trace_save (filename, writer, target_does_save);
344
345	if (from_tty)
346	printf_filtered (_("Trace data saved to %s '%s'.\n"),
347	generate_ctf ? "directory" : "file", filename);
348
349	do_cleanups (back_to);
350	}
351
352	/* Save the trace data to file FILENAME of tfile format. */
353
354	void
355	trace_save_tfile (const char *filename, int target_does_save)
356	{
357	struct trace_file_writer *writer;
358	struct cleanup *back_to;
359
360	writer = tfile_trace_file_writer_new ();
361	back_to = make_cleanup (trace_file_writer_xfree, writer);
362	trace_save (filename, writer, target_does_save);
363	do_cleanups (back_to);
364	}
365
366	/* Save the trace data to dir DIRNAME of ctf format. */
367
368	void
369	trace_save_ctf (const char *dirname, int target_does_save)
370	{
371	struct trace_file_writer *writer;
372	struct cleanup *back_to;
373
374	writer = ctf_trace_file_writer_new ();
375	back_to = make_cleanup (trace_file_writer_xfree, writer);
376
377	trace_save (dirname, writer, target_does_save);
378	do_cleanups (back_to);
379	}
380
48b6e87e YQ	381	/* Fetch register data from tracefile, shared for both tfile and
	382	ctf. */
	383
	384	void
	385	tracefile_fetch_registers (struct regcache *regcache, int regno)
	386	{
	387	struct gdbarch *gdbarch = get_regcache_arch (regcache);
	388	int regn, pc_regno;
	389
	390	/* We get here if no register data has been found. Mark registers
	391	as unavailable. */
	392	for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
	393	regcache_raw_supply (regcache, regn, NULL);
	394
	395	/* We can often usefully guess that the PC is going to be the same
	396	as the address of the tracepoint. */
	397	pc_regno = gdbarch_pc_regnum (gdbarch);
	398
	399	/* XXX This guessing code below only works if the PC register isn't
	400	a pseudo-register. The value of a pseudo-register isn't stored
	401	in the (non-readonly) regcache -- instead it's recomputed
	402	(probably from some other cached raw register) whenever the
	403	register is read. This guesswork should probably move to some
	404	higher layer. */
	405	if (pc_regno < 0 \|\| pc_regno >= gdbarch_num_regs (gdbarch))
	406	return;
	407
	408	if (regno == -1 \|\| regno == pc_regno)
	409	{
	410	struct tracepoint *tp = get_tracepoint (get_tracepoint_number ());
	411	gdb_byte *regs;
	412
	413	if (tp && tp->base.loc)
	414	{
	415	/* But don't try to guess if tracepoint is multi-location... */
	416	if (tp->base.loc->next)
	417	{
	418	warning (_("Tracepoint %d has multiple "
	419	"locations, cannot infer $pc"),
	420	tp->base.number);
	421	return;
	422	}
	423	/* ... or does while-stepping. */
	424	if (tp->step_count > 0)
	425	{
	426	warning (_("Tracepoint %d does while-stepping, "
	427	"cannot infer $pc"),
	428	tp->base.number);
	429	return;
	430	}
	431
	432	regs = alloca (register_size (gdbarch, pc_regno));
	433	store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
	434	gdbarch_byte_order (gdbarch),
	435	tp->base.loc->address);
	436	regcache_raw_supply (regcache, pc_regno, regs);
	437	}
	438	}
	439	}
	440
a283690e YQ	441	/* This is the implementation of target_ops method to_has_all_memory. */
	442
	443	static int
	444	tracefile_has_all_memory (struct target_ops *ops)
	445	{
	446	return 1;
	447	}
	448
	449	/* This is the implementation of target_ops method to_has_memory. */
	450
	451	static int
	452	tracefile_has_memory (struct target_ops *ops)
	453	{
	454	return 1;
	455	}
	456
12e03cd0 YQ	457	/* This is the implementation of target_ops method to_has_stack.
	458	The target has a stack when GDB has already selected one trace
	459	frame. */
	460
	461	static int
	462	tracefile_has_stack (struct target_ops *ops)
	463	{
	464	return get_traceframe_number () != -1;
	465	}
	466
	467	/* This is the implementation of target_ops method to_has_registers.
	468	The target has registers when GDB has already selected one trace
	469	frame. */
	470
	471	static int
	472	tracefile_has_registers (struct target_ops *ops)
	473	{
	474	return get_traceframe_number () != -1;
	475	}
	476
	477	/* This is the implementation of target_ops method to_thread_alive.
	478	tracefile has one thread faked by GDB. */
	479
	480	static int
	481	tracefile_thread_alive (struct target_ops *ops, ptid_t ptid)
	482	{
	483	return 1;
	484	}
	485
	486	/* This is the implementation of target_ops method to_get_trace_status.
	487	The trace status for a file is that tracing can never be run. */
	488
	489	static int
	490	tracefile_get_trace_status (struct target_ops self, struct trace_status ts)
	491	{
	492	/* Other bits of trace status were collected as part of opening the
	493	trace files, so nothing to do here. */
	494
	495	return -1;
	496	}
	497
	498	/* Initialize OPS for tracefile related targets. */
	499
	500	void
	501	init_tracefile_ops (struct target_ops *ops)
	502	{
	503	ops->to_stratum = process_stratum;
	504	ops->to_get_trace_status = tracefile_get_trace_status;
a283690e YQ	505	ops->to_has_all_memory = tracefile_has_all_memory;
a283690e YQ	506	ops->to_has_memory = tracefile_has_memory;
12e03cd0 YQ	507	ops->to_has_stack = tracefile_has_stack;
	508	ops->to_has_registers = tracefile_has_registers;
	509	ops->to_thread_alive = tracefile_thread_alive;
	510	ops->to_magic = OPS_MAGIC;
	511	}
	512
7951c4eb YQ	513	extern initialize_file_ftype _initialize_tracefile;
	514
	515	void
	516	_initialize_tracefile (void)
	517	{
	518	add_com ("tsave", class_trace, trace_save_command, _("\
	519	Save the trace data to a file.\n\
	520	Use the '-ctf' option to save the data to CTF format.\n\
	521	Use the '-r' option to direct the target to save directly to the file,\n\
	522	using its own filesystem."));
	523	}