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