gdb/tracefile-tfile.c

   1 /* Trace file TFILE format support in GDB.
   2
   3    Copyright (C) 1997-2014 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 "readline/tilde.h"
  23 #include "filestuff.h"
  24 #include "rsp-low.h" /* bin2hex */
  25 #include "regcache.h"
  26 #include "inferior.h"
  27 #include "gdbthread.h"
  28 #include "exec.h" /* exec_bfd */
  29 #include "completer.h"
  30 #include "filenames.h"
  31
  32 #ifndef O_LARGEFILE
  33 #define O_LARGEFILE 0
  34 #endif
  35
  36 /* TFILE trace writer.  */
  37
  38 struct tfile_trace_file_writer
  39 {
  40   struct trace_file_writer base;
  41
  42   /* File pointer to tfile trace file.  */
  43   FILE *fp;
  44   /* Path name of the tfile trace file.  */
  45   char *pathname;
  46 };
  47
  48 /* This is the implementation of trace_file_write_ops method
  49    target_save.  We just call the generic target
  50    target_save_trace_data to do target-side saving.  */
  51
  52 static int
  53 tfile_target_save (struct trace_file_writer *self,
  54                    const char *filename)
  55 {
  56   int err = target_save_trace_data (filename);
  57
  58   return (err >= 0);
  59 }
  60
  61 /* This is the implementation of trace_file_write_ops method
  62    dtor.  */
  63
  64 static void
  65 tfile_dtor (struct trace_file_writer *self)
  66 {
  67   struct tfile_trace_file_writer *writer
  68     = (struct tfile_trace_file_writer *) self;
  69
  70   xfree (writer->pathname);
  71
  72   if (writer->fp != NULL)
  73     fclose (writer->fp);
  74 }
  75
  76 /* This is the implementation of trace_file_write_ops method
  77    start.  It creates the trace file FILENAME and registers some
  78    cleanups.  */
  79
  80 static void
  81 tfile_start (struct trace_file_writer *self, const char *filename)
  82 {
  83   struct tfile_trace_file_writer *writer
  84     = (struct tfile_trace_file_writer *) self;
  85
  86   writer->pathname = tilde_expand (filename);
  87   writer->fp = gdb_fopen_cloexec (writer->pathname, "wb");
  88   if (writer->fp == NULL)
  89     error (_("Unable to open file '%s' for saving trace data (%s)"),
  90            writer->pathname, safe_strerror (errno));
  91 }
  92
  93 /* This is the implementation of trace_file_write_ops method
  94    write_header.  Write the TFILE header.  */
  95
  96 static void
  97 tfile_write_header (struct trace_file_writer *self)
  98 {
  99   struct tfile_trace_file_writer *writer
 100     = (struct tfile_trace_file_writer *) self;
 101   int written;
 102
 103   /* Write a file header, with a high-bit-set char to indicate a
 104      binary file, plus a hint as what this file is, and a version
 105      number in case of future needs.  */
 106   written = fwrite ("\x7fTRACE0\n", 8, 1, writer->fp);
 107   if (written < 1)
 108     perror_with_name (writer->pathname);
 109 }
 110
 111 /* This is the implementation of trace_file_write_ops method
 112    write_regblock_type.  Write the size of register block.  */
 113
 114 static void
 115 tfile_write_regblock_type (struct trace_file_writer *self, int size)
 116 {
 117   struct tfile_trace_file_writer *writer
 118     = (struct tfile_trace_file_writer *) self;
 119
 120   fprintf (writer->fp, "R %x\n", size);
 121 }
 122
 123 /* This is the implementation of trace_file_write_ops method
 124    write_status.  */
 125
 126 static void
 127 tfile_write_status (struct trace_file_writer *self,
 128                     struct trace_status *ts)
 129 {
 130   struct tfile_trace_file_writer *writer
 131     = (struct tfile_trace_file_writer *) self;
 132
 133   fprintf (writer->fp, "status %c;%s",
 134            (ts->running ? '1' : '0'), stop_reason_names[ts->stop_reason]);
 135   if (ts->stop_reason == tracepoint_error
 136       || ts->stop_reason == tstop_command)
 137     {
 138       char *buf = (char *) alloca (strlen (ts->stop_desc) * 2 + 1);
 139
 140       bin2hex ((gdb_byte *) ts->stop_desc, buf, strlen (ts->stop_desc));
 141       fprintf (writer->fp, ":%s", buf);
 142     }
 143   fprintf (writer->fp, ":%x", ts->stopping_tracepoint);
 144   if (ts->traceframe_count >= 0)
 145     fprintf (writer->fp, ";tframes:%x", ts->traceframe_count);
 146   if (ts->traceframes_created >= 0)
 147     fprintf (writer->fp, ";tcreated:%x", ts->traceframes_created);
 148   if (ts->buffer_free >= 0)
 149     fprintf (writer->fp, ";tfree:%x", ts->buffer_free);
 150   if (ts->buffer_size >= 0)
 151     fprintf (writer->fp, ";tsize:%x", ts->buffer_size);
 152   if (ts->disconnected_tracing)
 153     fprintf (writer->fp, ";disconn:%x", ts->disconnected_tracing);
 154   if (ts->circular_buffer)
 155     fprintf (writer->fp, ";circular:%x", ts->circular_buffer);
 156   if (ts->start_time)
 157     {
 158       fprintf (writer->fp, ";starttime:%s",
 159       phex_nz (ts->start_time, sizeof (ts->start_time)));
 160     }
 161   if (ts->stop_time)
 162     {
 163       fprintf (writer->fp, ";stoptime:%s",
 164       phex_nz (ts->stop_time, sizeof (ts->stop_time)));
 165     }
 166   if (ts->notes != NULL)
 167     {
 168       char *buf = (char *) alloca (strlen (ts->notes) * 2 + 1);
 169
 170       bin2hex ((gdb_byte *) ts->notes, buf, strlen (ts->notes));
 171       fprintf (writer->fp, ";notes:%s", buf);
 172     }
 173   if (ts->user_name != NULL)
 174     {
 175       char *buf = (char *) alloca (strlen (ts->user_name) * 2 + 1);
 176
 177       bin2hex ((gdb_byte *) ts->user_name, buf, strlen (ts->user_name));
 178       fprintf (writer->fp, ";username:%s", buf);
 179     }
 180   fprintf (writer->fp, "\n");
 181 }
 182
 183 /* This is the implementation of trace_file_write_ops method
 184    write_uploaded_tsv.  */
 185
 186 static void
 187 tfile_write_uploaded_tsv (struct trace_file_writer *self,
 188                           struct uploaded_tsv *utsv)
 189 {
 190   char *buf = "";
 191   struct tfile_trace_file_writer *writer
 192     = (struct tfile_trace_file_writer *) self;
 193
 194   if (utsv->name)
 195     {
 196       buf = (char *) xmalloc (strlen (utsv->name) * 2 + 1);
 197       bin2hex ((gdb_byte *) (utsv->name), buf, strlen (utsv->name));
 198     }
 199
 200   fprintf (writer->fp, "tsv %x:%s:%x:%s\n",
 201            utsv->number, phex_nz (utsv->initial_value, 8),
 202            utsv->builtin, buf);
 203
 204   if (utsv->name)
 205     xfree (buf);
 206 }
 207
 208 #define MAX_TRACE_UPLOAD 2000
 209
 210 /* This is the implementation of trace_file_write_ops method
 211    write_uploaded_tp.  */
 212
 213 static void
 214 tfile_write_uploaded_tp (struct trace_file_writer *self,
 215                          struct uploaded_tp *utp)
 216 {
 217   struct tfile_trace_file_writer *writer
 218     = (struct tfile_trace_file_writer *) self;
 219   int a;
 220   char *act;
 221   char buf[MAX_TRACE_UPLOAD];
 222
 223   fprintf (writer->fp, "tp T%x:%s:%c:%x:%x",
 224            utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
 225            (utp->enabled ? 'E' : 'D'), utp->step, utp->pass);
 226   if (utp->type == bp_fast_tracepoint)
 227     fprintf (writer->fp, ":F%x", utp->orig_size);
 228   if (utp->cond)
 229     fprintf (writer->fp,
 230              ":X%x,%s", (unsigned int) strlen (utp->cond) / 2,
 231              utp->cond);
 232   fprintf (writer->fp, "\n");
 233   for (a = 0; VEC_iterate (char_ptr, utp->actions, a, act); ++a)
 234     fprintf (writer->fp, "tp A%x:%s:%s\n",
 235              utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
 236   for (a = 0; VEC_iterate (char_ptr, utp->step_actions, a, act); ++a)
 237     fprintf (writer->fp, "tp S%x:%s:%s\n",
 238              utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
 239   if (utp->at_string)
 240     {
 241       encode_source_string (utp->number, utp->addr,
 242                             "at", utp->at_string, buf, MAX_TRACE_UPLOAD);
 243       fprintf (writer->fp, "tp Z%s\n", buf);
 244     }
 245   if (utp->cond_string)
 246     {
 247       encode_source_string (utp->number, utp->addr,
 248                             "cond", utp->cond_string,
 249                             buf, MAX_TRACE_UPLOAD);
 250       fprintf (writer->fp, "tp Z%s\n", buf);
 251     }
 252   for (a = 0; VEC_iterate (char_ptr, utp->cmd_strings, a, act); ++a)
 253     {
 254       encode_source_string (utp->number, utp->addr, "cmd", act,
 255                             buf, MAX_TRACE_UPLOAD);
 256       fprintf (writer->fp, "tp Z%s\n", buf);
 257     }
 258   fprintf (writer->fp, "tp V%x:%s:%x:%s\n",
 259            utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
 260            utp->hit_count,
 261            phex_nz (utp->traceframe_usage,
 262                     sizeof (utp->traceframe_usage)));
 263 }
 264
 265 /* This is the implementation of trace_file_write_ops method
 266    write_definition_end.  */
 267
 268 static void
 269 tfile_write_definition_end (struct trace_file_writer *self)
 270 {
 271   struct tfile_trace_file_writer *writer
 272     = (struct tfile_trace_file_writer *) self;
 273
 274   fprintf (writer->fp, "\n");
 275 }
 276
 277 /* This is the implementation of trace_file_write_ops method
 278    write_raw_data.  */
 279
 280 static void
 281 tfile_write_raw_data (struct trace_file_writer *self, gdb_byte *buf,
 282                       LONGEST len)
 283 {
 284   struct tfile_trace_file_writer *writer
 285     = (struct tfile_trace_file_writer *) self;
 286
 287   if (fwrite (buf, len, 1, writer->fp) < 1)
 288     perror_with_name (writer->pathname);
 289 }
 290
 291 /* This is the implementation of trace_file_write_ops method
 292    end.  */
 293
 294 static void
 295 tfile_end (struct trace_file_writer *self)
 296 {
 297   struct tfile_trace_file_writer *writer
 298     = (struct tfile_trace_file_writer *) self;
 299   uint32_t gotten = 0;
 300
 301   /* Mark the end of trace data.  */
 302   if (fwrite (&gotten, 4, 1, writer->fp) < 1)
 303     perror_with_name (writer->pathname);
 304 }
 305
 306 /* Operations to write trace buffers into TFILE format.  */
 307
 308 static const struct trace_file_write_ops tfile_write_ops =
 309 {
 310   tfile_dtor,
 311   tfile_target_save,
 312   tfile_start,
 313   tfile_write_header,
 314   tfile_write_regblock_type,
 315   tfile_write_status,
 316   tfile_write_uploaded_tsv,
 317   tfile_write_uploaded_tp,
 318   tfile_write_definition_end,
 319   tfile_write_raw_data,
 320   NULL,
 321   tfile_end,
 322 };
 323
 324 /* Return a trace writer for TFILE format.  */
 325
 326 struct trace_file_writer *
 327 tfile_trace_file_writer_new (void)
 328 {
 329   struct tfile_trace_file_writer *writer
 330     = xmalloc (sizeof (struct tfile_trace_file_writer));
 331
 332   writer->base.ops = &tfile_write_ops;
 333   writer->fp = NULL;
 334   writer->pathname = NULL;
 335
 336   return (struct trace_file_writer *) writer;
 337 }
 338
 339 /* target tfile command */
 340
 341 static struct target_ops tfile_ops;
 342
 343 /* Fill in tfile_ops with its defined operations and properties.  */
 344
 345 #define TRACE_HEADER_SIZE 8
 346
 347 #define TFILE_PID (1)
 348
 349 static char *trace_filename;
 350 static int trace_fd = -1;
 351 static off_t trace_frames_offset;
 352 static off_t cur_offset;
 353 static int cur_data_size;
 354 int trace_regblock_size;
 355
 356 static void tfile_interp_line (char *line,
 357                                struct uploaded_tp **utpp,
 358                                struct uploaded_tsv **utsvp);
 359
 360 /* Read SIZE bytes into READBUF from the trace frame, starting at
 361    TRACE_FD's current position.  Note that this call `read'
 362    underneath, hence it advances the file's seek position.  Throws an
 363    error if the `read' syscall fails, or less than SIZE bytes are
 364    read.  */
 365
 366 static void
 367 tfile_read (gdb_byte *readbuf, int size)
 368 {
 369   int gotten;
 370
 371   gotten = read (trace_fd, readbuf, size);
 372   if (gotten < 0)
 373     perror_with_name (trace_filename);
 374   else if (gotten < size)
 375     error (_("Premature end of file while reading trace file"));
 376 }
 377
 378 static void
 379 tfile_open (char *filename, int from_tty)
 380 {
 381   volatile struct gdb_exception ex;
 382   char *temp;
 383   struct cleanup *old_chain;
 384   int flags;
 385   int scratch_chan;
 386   char header[TRACE_HEADER_SIZE];
 387   char linebuf[1000]; /* Should be max remote packet size or so.  */
 388   gdb_byte byte;
 389   int bytes, i;
 390   struct trace_status *ts;
 391   struct uploaded_tp *uploaded_tps = NULL;
 392   struct uploaded_tsv *uploaded_tsvs = NULL;
 393
 394   target_preopen (from_tty);
 395   if (!filename)
 396     error (_("No trace file specified."));
 397
 398   filename = tilde_expand (filename);
 399   if (!IS_ABSOLUTE_PATH(filename))
 400     {
 401       temp = concat (current_directory, "/", filename, (char *) NULL);
 402       xfree (filename);
 403       filename = temp;
 404     }
 405
 406   old_chain = make_cleanup (xfree, filename);
 407
 408   flags = O_BINARY | O_LARGEFILE;
 409   flags |= O_RDONLY;
 410   scratch_chan = gdb_open_cloexec (filename, flags, 0);
 411   if (scratch_chan < 0)
 412     perror_with_name (filename);
 413
 414   /* Looks semi-reasonable.  Toss the old trace file and work on the new.  */
 415
 416   discard_cleanups (old_chain); /* Don't free filename any more.  */
 417   unpush_target (&tfile_ops);
 418
 419   trace_filename = xstrdup (filename);
 420   trace_fd = scratch_chan;
 421
 422   bytes = 0;
 423   /* Read the file header and test for validity.  */
 424   tfile_read ((gdb_byte *) &header, TRACE_HEADER_SIZE);
 425
 426   bytes += TRACE_HEADER_SIZE;
 427   if (!(header[0] == 0x7f
 428         && (strncmp (header + 1, "TRACE0\n", 7) == 0)))
 429     error (_("File is not a valid trace file."));
 430
 431   push_target (&tfile_ops);
 432
 433   trace_regblock_size = 0;
 434   ts = current_trace_status ();
 435   /* We know we're working with a file.  Record its name.  */
 436   ts->filename = trace_filename;
 437   /* Set defaults in case there is no status line.  */
 438   ts->running_known = 0;
 439   ts->stop_reason = trace_stop_reason_unknown;
 440   ts->traceframe_count = -1;
 441   ts->buffer_free = 0;
 442   ts->disconnected_tracing = 0;
 443   ts->circular_buffer = 0;
 444
 445   TRY_CATCH (ex, RETURN_MASK_ALL)
 446     {
 447       /* Read through a section of newline-terminated lines that
 448          define things like tracepoints.  */
 449       i = 0;
 450       while (1)
 451         {
 452           tfile_read (&byte, 1);
 453
 454           ++bytes;
 455           if (byte == '\n')
 456             {
 457               /* Empty line marks end of the definition section.  */
 458               if (i == 0)
 459                 break;
 460               linebuf[i] = '\0';
 461               i = 0;
 462               tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
 463             }
 464           else
 465             linebuf[i++] = byte;
 466           if (i >= 1000)
 467             error (_("Excessively long lines in trace file"));
 468         }
 469
 470       /* Record the starting offset of the binary trace data.  */
 471       trace_frames_offset = bytes;
 472
 473       /* If we don't have a blocksize, we can't interpret the
 474          traceframes.  */
 475       if (trace_regblock_size == 0)
 476         error (_("No register block size recorded in trace file"));
 477     }
 478   if (ex.reason < 0)
 479     {
 480       /* Remove the partially set up target.  */
 481       unpush_target (&tfile_ops);
 482       throw_exception (ex);
 483     }
 484
 485   inferior_appeared (current_inferior (), TFILE_PID);
 486   inferior_ptid = pid_to_ptid (TFILE_PID);
 487   add_thread_silent (inferior_ptid);
 488
 489   if (ts->traceframe_count <= 0)
 490     warning (_("No traceframes present in this file."));
 491
 492   /* Add the file's tracepoints and variables into the current mix.  */
 493
 494   /* Get trace state variables first, they may be checked when parsing
 495      uploaded commands.  */
 496   merge_uploaded_trace_state_variables (&uploaded_tsvs);
 497
 498   merge_uploaded_tracepoints (&uploaded_tps);
 499
 500   post_create_inferior (&tfile_ops, from_tty);
 501 }
 502
 503 /* Interpret the given line from the definitions part of the trace
 504    file.  */
 505
 506 static void
 507 tfile_interp_line (char *line, struct uploaded_tp **utpp,
 508                    struct uploaded_tsv **utsvp)
 509 {
 510   char *p = line;
 511
 512   if (strncmp (p, "R ", strlen ("R ")) == 0)
 513     {
 514       p += strlen ("R ");
 515       trace_regblock_size = strtol (p, &p, 16);
 516     }
 517   else if (strncmp (p, "status ", strlen ("status ")) == 0)
 518     {
 519       p += strlen ("status ");
 520       parse_trace_status (p, current_trace_status ());
 521     }
 522   else if (strncmp (p, "tp ", strlen ("tp ")) == 0)
 523     {
 524       p += strlen ("tp ");
 525       parse_tracepoint_definition (p, utpp);
 526     }
 527   else if (strncmp (p, "tsv ", strlen ("tsv ")) == 0)
 528     {
 529       p += strlen ("tsv ");
 530       parse_tsv_definition (p, utsvp);
 531     }
 532   else
 533     warning (_("Ignoring trace file definition \"%s\""), line);
 534 }
 535
 536 /* Close the trace file and generally clean up.  */
 537
 538 static void
 539 tfile_close (struct target_ops *self)
 540 {
 541   int pid;
 542
 543   if (trace_fd < 0)
 544     return;
 545
 546   pid = ptid_get_pid (inferior_ptid);
 547   inferior_ptid = null_ptid;    /* Avoid confusion from thread stuff.  */
 548   exit_inferior_silent (pid);
 549
 550   close (trace_fd);
 551   trace_fd = -1;
 552   xfree (trace_filename);
 553   trace_filename = NULL;
 554
 555   trace_reset_local_state ();
 556 }
 557
 558 static void
 559 tfile_files_info (struct target_ops *t)
 560 {
 561   printf_filtered ("\t`%s'\n", trace_filename);
 562 }
 563
 564 static void
 565 tfile_get_tracepoint_status (struct target_ops *self,
 566                              struct breakpoint *tp, struct uploaded_tp *utp)
 567 {
 568   /* Other bits of trace status were collected as part of opening the
 569      trace files, so nothing to do here.  */
 570 }
 571
 572 /* Given the position of a traceframe in the file, figure out what
 573    address the frame was collected at.  This would normally be the
 574    value of a collected PC register, but if not available, we
 575    improvise.  */
 576
 577 static CORE_ADDR
 578 tfile_get_traceframe_address (off_t tframe_offset)
 579 {
 580   CORE_ADDR addr = 0;
 581   short tpnum;
 582   struct tracepoint *tp;
 583   off_t saved_offset = cur_offset;
 584
 585   /* FIXME dig pc out of collected registers.  */
 586
 587   /* Fall back to using tracepoint address.  */
 588   lseek (trace_fd, tframe_offset, SEEK_SET);
 589   tfile_read ((gdb_byte *) &tpnum, 2);
 590   tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
 591                                           gdbarch_byte_order
 592                                               (target_gdbarch ()));
 593
 594   tp = get_tracepoint_by_number_on_target (tpnum);
 595   /* FIXME this is a poor heuristic if multiple locations.  */
 596   if (tp && tp->base.loc)
 597     addr = tp->base.loc->address;
 598
 599   /* Restore our seek position.  */
 600   cur_offset = saved_offset;
 601   lseek (trace_fd, cur_offset, SEEK_SET);
 602   return addr;
 603 }
 604
 605 /* Given a type of search and some parameters, scan the collection of
 606    traceframes in the file looking for a match.  When found, return
 607    both the traceframe and tracepoint number, otherwise -1 for
 608    each.  */
 609
 610 static int
 611 tfile_trace_find (struct target_ops *self, enum trace_find_type type, int num,
 612                   CORE_ADDR addr1, CORE_ADDR addr2, int *tpp)
 613 {
 614   short tpnum;
 615   int tfnum = 0, found = 0;
 616   unsigned int data_size;
 617   struct tracepoint *tp;
 618   off_t offset, tframe_offset;
 619   CORE_ADDR tfaddr;
 620
 621   if (num == -1)
 622     {
 623       if (tpp)
 624         *tpp = -1;
 625       return -1;
 626     }
 627
 628   lseek (trace_fd, trace_frames_offset, SEEK_SET);
 629   offset = trace_frames_offset;
 630   while (1)
 631     {
 632       tframe_offset = offset;
 633       tfile_read ((gdb_byte *) &tpnum, 2);
 634       tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
 635                                               gdbarch_byte_order
 636                                                   (target_gdbarch ()));
 637       offset += 2;
 638       if (tpnum == 0)
 639         break;
 640       tfile_read ((gdb_byte *) &data_size, 4);
 641       data_size = (unsigned int) extract_unsigned_integer
 642                                      ((gdb_byte *) &data_size, 4,
 643                                       gdbarch_byte_order (target_gdbarch ()));
 644       offset += 4;
 645
 646       if (type == tfind_number)
 647         {
 648           /* Looking for a specific trace frame.  */
 649           if (tfnum == num)
 650             found = 1;
 651         }
 652       else
 653         {
 654           /* Start from the _next_ trace frame.  */
 655           if (tfnum > get_traceframe_number ())
 656             {
 657               switch (type)
 658                 {
 659                 case tfind_pc:
 660                   tfaddr = tfile_get_traceframe_address (tframe_offset);
 661                   if (tfaddr == addr1)
 662                     found = 1;
 663                   break;
 664                 case tfind_tp:
 665                   tp = get_tracepoint (num);
 666                   if (tp && tpnum == tp->number_on_target)
 667                     found = 1;
 668                   break;
 669                 case tfind_range:
 670                   tfaddr = tfile_get_traceframe_address (tframe_offset);
 671                   if (addr1 <= tfaddr && tfaddr <= addr2)
 672                     found = 1;
 673                   break;
 674                 case tfind_outside:
 675                   tfaddr = tfile_get_traceframe_address (tframe_offset);
 676                   if (!(addr1 <= tfaddr && tfaddr <= addr2))
 677                     found = 1;
 678                   break;
 679                 default:
 680                   internal_error (__FILE__, __LINE__, _("unknown tfind type"));
 681                 }
 682             }
 683         }
 684
 685       if (found)
 686         {
 687           if (tpp)
 688             *tpp = tpnum;
 689           cur_offset = offset;
 690           cur_data_size = data_size;
 691
 692           return tfnum;
 693         }
 694       /* Skip past the traceframe's data.  */
 695       lseek (trace_fd, data_size, SEEK_CUR);
 696       offset += data_size;
 697       /* Update our own count of traceframes.  */
 698       ++tfnum;
 699     }
 700   /* Did not find what we were looking for.  */
 701   if (tpp)
 702     *tpp = -1;
 703   return -1;
 704 }
 705
 706 /* Prototype of the callback passed to tframe_walk_blocks.  */
 707 typedef int (*walk_blocks_callback_func) (char blocktype, void *data);
 708
 709 /* Callback for traceframe_walk_blocks, used to find a given block
 710    type in a traceframe.  */
 711
 712 static int
 713 match_blocktype (char blocktype, void *data)
 714 {
 715   char *wantedp = data;
 716
 717   if (*wantedp == blocktype)
 718     return 1;
 719
 720   return 0;
 721 }
 722
 723 /* Walk over all traceframe block starting at POS offset from
 724    CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
 725    unmodified.  If CALLBACK returns true, this returns the position in
 726    the traceframe where the block is found, relative to the start of
 727    the traceframe (cur_offset).  Returns -1 if no callback call
 728    returned true, indicating that all blocks have been walked.  */
 729
 730 static int
 731 traceframe_walk_blocks (walk_blocks_callback_func callback,
 732                         int pos, void *data)
 733 {
 734   /* Iterate through a traceframe's blocks, looking for a block of the
 735      requested type.  */
 736
 737   lseek (trace_fd, cur_offset + pos, SEEK_SET);
 738   while (pos < cur_data_size)
 739     {
 740       unsigned short mlen;
 741       char block_type;
 742
 743       tfile_read ((gdb_byte *) &block_type, 1);
 744
 745       ++pos;
 746
 747       if ((*callback) (block_type, data))
 748         return pos;
 749
 750       switch (block_type)
 751         {
 752         case 'R':
 753           lseek (trace_fd, cur_offset + pos + trace_regblock_size, SEEK_SET);
 754           pos += trace_regblock_size;
 755           break;
 756         case 'M':
 757           lseek (trace_fd, cur_offset + pos + 8, SEEK_SET);
 758           tfile_read ((gdb_byte *) &mlen, 2);
 759           mlen = (unsigned short)
 760                 extract_unsigned_integer ((gdb_byte *) &mlen, 2,
 761                                           gdbarch_byte_order
 762                                               (target_gdbarch ()));
 763           lseek (trace_fd, mlen, SEEK_CUR);
 764           pos += (8 + 2 + mlen);
 765           break;
 766         case 'V':
 767           lseek (trace_fd, cur_offset + pos + 4 + 8, SEEK_SET);
 768           pos += (4 + 8);
 769           break;
 770         default:
 771           error (_("Unknown block type '%c' (0x%x) in trace frame"),
 772                  block_type, block_type);
 773           break;
 774         }
 775     }
 776
 777   return -1;
 778 }
 779
 780 /* Convenience wrapper around traceframe_walk_blocks.  Looks for the
 781    position offset of a block of type TYPE_WANTED in the current trace
 782    frame, starting at POS.  Returns -1 if no such block was found.  */
 783
 784 static int
 785 traceframe_find_block_type (char type_wanted, int pos)
 786 {
 787   return traceframe_walk_blocks (match_blocktype, pos, &type_wanted);
 788 }
 789
 790 /* Look for a block of saved registers in the traceframe, and get the
 791    requested register from it.  */
 792
 793 static void
 794 tfile_fetch_registers (struct target_ops *ops,
 795                        struct regcache *regcache, int regno)
 796 {
 797   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 798   int offset, regn, regsize, pc_regno;
 799   gdb_byte *regs;
 800
 801   /* An uninitialized reg size says we're not going to be
 802      successful at getting register blocks.  */
 803   if (!trace_regblock_size)
 804     return;
 805
 806   regs = alloca (trace_regblock_size);
 807
 808   if (traceframe_find_block_type ('R', 0) >= 0)
 809     {
 810       tfile_read (regs, trace_regblock_size);
 811
 812       /* Assume the block is laid out in GDB register number order,
 813          each register with the size that it has in GDB.  */
 814       offset = 0;
 815       for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
 816         {
 817           regsize = register_size (gdbarch, regn);
 818           /* Make sure we stay within block bounds.  */
 819           if (offset + regsize >= trace_regblock_size)
 820             break;
 821           if (regcache_register_status (regcache, regn) == REG_UNKNOWN)
 822             {
 823               if (regno == regn)
 824                 {
 825                   regcache_raw_supply (regcache, regno, regs + offset);
 826                   break;
 827                 }
 828               else if (regno == -1)
 829                 {
 830                   regcache_raw_supply (regcache, regn, regs + offset);
 831                 }
 832             }
 833           offset += regsize;
 834         }
 835       return;
 836     }
 837
 838   /* We get here if no register data has been found.  Mark registers
 839      as unavailable.  */
 840   for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
 841     regcache_raw_supply (regcache, regn, NULL);
 842
 843   /* We can often usefully guess that the PC is going to be the same
 844      as the address of the tracepoint.  */
 845   pc_regno = gdbarch_pc_regnum (gdbarch);
 846
 847   /* XXX This guessing code below only works if the PC register isn't
 848      a pseudo-register.  The value of a pseudo-register isn't stored
 849      in the (non-readonly) regcache -- instead it's recomputed
 850      (probably from some other cached raw register) whenever the
 851      register is read.  This guesswork should probably move to some
 852      higher layer.  */
 853   if (pc_regno < 0 || pc_regno >= gdbarch_num_regs (gdbarch))
 854     return;
 855
 856   if (regno == -1 || regno == pc_regno)
 857     {
 858       struct tracepoint *tp = get_tracepoint (get_tracepoint_number ());
 859
 860       if (tp && tp->base.loc)
 861         {
 862           /* But don't try to guess if tracepoint is multi-location...  */
 863           if (tp->base.loc->next)
 864             {
 865               warning (_("Tracepoint %d has multiple "
 866                          "locations, cannot infer $pc"),
 867                        tp->base.number);
 868               return;
 869             }
 870           /* ... or does while-stepping.  */
 871           if (tp->step_count > 0)
 872             {
 873               warning (_("Tracepoint %d does while-stepping, "
 874                          "cannot infer $pc"),
 875                        tp->base.number);
 876               return;
 877             }
 878
 879           store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
 880                                   gdbarch_byte_order (gdbarch),
 881                                   tp->base.loc->address);
 882           regcache_raw_supply (regcache, pc_regno, regs);
 883         }
 884     }
 885 }
 886
 887 static enum target_xfer_status
 888 tfile_xfer_partial (struct target_ops *ops, enum target_object object,
 889                     const char *annex, gdb_byte *readbuf,
 890                     const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
 891                     ULONGEST *xfered_len)
 892 {
 893   /* We're only doing regular memory for now.  */
 894   if (object != TARGET_OBJECT_MEMORY)
 895     return TARGET_XFER_E_IO;
 896
 897   if (readbuf == NULL)
 898     error (_("tfile_xfer_partial: trace file is read-only"));
 899
 900   if (get_traceframe_number () != -1)
 901     {
 902       int pos = 0;
 903
 904       /* Iterate through the traceframe's blocks, looking for
 905          memory.  */
 906       while ((pos = traceframe_find_block_type ('M', pos)) >= 0)
 907         {
 908           ULONGEST maddr, amt;
 909           unsigned short mlen;
 910           enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 911
 912           tfile_read ((gdb_byte *) &maddr, 8);
 913           maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
 914                                             byte_order);
 915           tfile_read ((gdb_byte *) &mlen, 2);
 916           mlen = (unsigned short)
 917             extract_unsigned_integer ((gdb_byte *) &mlen, 2, byte_order);
 918
 919           /* If the block includes the first part of the desired
 920              range, return as much it has; GDB will re-request the
 921              remainder, which might be in a different block of this
 922              trace frame.  */
 923           if (maddr <= offset && offset < (maddr + mlen))
 924             {
 925               amt = (maddr + mlen) - offset;
 926               if (amt > len)
 927                 amt = len;
 928
 929               if (maddr != offset)
 930                 lseek (trace_fd, offset - maddr, SEEK_CUR);
 931               tfile_read (readbuf, amt);
 932               *xfered_len = amt;
 933               return TARGET_XFER_OK;
 934             }
 935
 936           /* Skip over this block.  */
 937           pos += (8 + 2 + mlen);
 938         }
 939     }
 940
 941   /* It's unduly pedantic to refuse to look at the executable for
 942      read-only pieces; so do the equivalent of readonly regions aka
 943      QTro packet.  */
 944   /* FIXME account for relocation at some point.  */
 945   if (exec_bfd)
 946     {
 947       asection *s;
 948       bfd_size_type size;
 949       bfd_vma vma;
 950
 951       for (s = exec_bfd->sections; s; s = s->next)
 952         {
 953           if ((s->flags & SEC_LOAD) == 0
 954               || (s->flags & SEC_READONLY) == 0)
 955             continue;
 956
 957           vma = s->vma;
 958           size = bfd_get_section_size (s);
 959           if (vma <= offset && offset < (vma + size))
 960             {
 961               ULONGEST amt;
 962
 963               amt = (vma + size) - offset;
 964               if (amt > len)
 965                 amt = len;
 966
 967               *xfered_len = bfd_get_section_contents (exec_bfd, s,
 968                                                       readbuf, offset - vma, amt);
 969               return TARGET_XFER_OK;
 970             }
 971         }
 972     }
 973
 974   /* Indicate failure to find the requested memory block.  */
 975   return TARGET_XFER_E_IO;
 976 }
 977
 978 /* Iterate through the blocks of a trace frame, looking for a 'V'
 979    block with a matching tsv number.  */
 980
 981 static int
 982 tfile_get_trace_state_variable_value (struct target_ops *self,
 983                                       int tsvnum, LONGEST *val)
 984 {
 985   int pos;
 986   int found = 0;
 987
 988   /* Iterate over blocks in current frame and find the last 'V'
 989      block in which tsv number is TSVNUM.  In one trace frame, there
 990      may be multiple 'V' blocks created for a given trace variable,
 991      and the last matched 'V' block contains the updated value.  */
 992   pos = 0;
 993   while ((pos = traceframe_find_block_type ('V', pos)) >= 0)
 994     {
 995       int vnum;
 996
 997       tfile_read ((gdb_byte *) &vnum, 4);
 998       vnum = (int) extract_signed_integer ((gdb_byte *) &vnum, 4,
 999                                            gdbarch_byte_order
1000                                            (target_gdbarch ()));
1001       if (tsvnum == vnum)
1002         {
1003           tfile_read ((gdb_byte *) val, 8);
1004           *val = extract_signed_integer ((gdb_byte *) val, 8,
1005                                          gdbarch_byte_order
1006                                          (target_gdbarch ()));
1007           found = 1;
1008         }
1009       pos += (4 + 8);
1010     }
1011
1012   return found;
1013 }
1014
1015 static int
1016 tfile_has_all_memory (struct target_ops *ops)
1017 {
1018   return 1;
1019 }
1020
1021 static int
1022 tfile_has_memory (struct target_ops *ops)
1023 {
1024   return 1;
1025 }
1026
1027 /* Callback for traceframe_walk_blocks.  Builds a traceframe_info
1028    object for the tfile target's current traceframe.  */
1029
1030 static int
1031 build_traceframe_info (char blocktype, void *data)
1032 {
1033   struct traceframe_info *info = data;
1034
1035   switch (blocktype)
1036     {
1037     case 'M':
1038       {
1039         struct mem_range *r;
1040         ULONGEST maddr;
1041         unsigned short mlen;
1042
1043         tfile_read ((gdb_byte *) &maddr, 8);
1044         maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
1045                                           gdbarch_byte_order
1046                                           (target_gdbarch ()));
1047         tfile_read ((gdb_byte *) &mlen, 2);
1048         mlen = (unsigned short)
1049                 extract_unsigned_integer ((gdb_byte *) &mlen,
1050                                           2, gdbarch_byte_order
1051                                           (target_gdbarch ()));
1052
1053         r = VEC_safe_push (mem_range_s, info->memory, NULL);
1054
1055         r->start = maddr;
1056         r->length = mlen;
1057         break;
1058       }
1059     case 'V':
1060       {
1061         int vnum;
1062
1063         tfile_read ((gdb_byte *) &vnum, 4);
1064         VEC_safe_push (int, info->tvars, vnum);
1065       }
1066     case 'R':
1067     case 'S':
1068       {
1069         break;
1070       }
1071     default:
1072       warning (_("Unhandled trace block type (%d) '%c ' "
1073                  "while building trace frame info."),
1074                blocktype, blocktype);
1075       break;
1076     }
1077
1078   return 0;
1079 }
1080
1081 static struct traceframe_info *
1082 tfile_traceframe_info (struct target_ops *self)
1083 {
1084   struct traceframe_info *info = XCNEW (struct traceframe_info);
1085
1086   traceframe_walk_blocks (build_traceframe_info, 0, info);
1087   return info;
1088 }
1089
1090 static void
1091 init_tfile_ops (void)
1092 {
1093   init_tracefile_ops (&tfile_ops);
1094
1095   tfile_ops.to_shortname = "tfile";
1096   tfile_ops.to_longname = "Local trace dump file";
1097   tfile_ops.to_doc
1098     = "Use a trace file as a target.  Specify the filename of the trace file.";
1099   tfile_ops.to_open = tfile_open;
1100   tfile_ops.to_close = tfile_close;
1101   tfile_ops.to_fetch_registers = tfile_fetch_registers;
1102   tfile_ops.to_xfer_partial = tfile_xfer_partial;
1103   tfile_ops.to_files_info = tfile_files_info;
1104   tfile_ops.to_get_tracepoint_status = tfile_get_tracepoint_status;
1105   tfile_ops.to_trace_find = tfile_trace_find;
1106   tfile_ops.to_get_trace_state_variable_value
1107     = tfile_get_trace_state_variable_value;
1108   tfile_ops.to_has_all_memory = tfile_has_all_memory;
1109   tfile_ops.to_has_memory = tfile_has_memory;
1110   tfile_ops.to_traceframe_info = tfile_traceframe_info;
1111 }
1112
1113 extern initialize_file_ftype _initialize_tracefile_tfile;
1114
1115 void
1116 _initialize_tracefile_tfile (void)
1117 {
1118   init_tfile_ops ();
1119
1120   add_target_with_completer (&tfile_ops, filename_completer);
1121 }