gdb/ctf.c

   1 /* CTF format support.
   2
   3    Copyright (C) 2012-2014 Free Software Foundation, Inc.
   4    Contributed by Hui Zhu <hui_zhu@mentor.com>
   5    Contributed by Yao Qi <yao@codesourcery.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 #include "defs.h"
  23 #include "ctf.h"
  24 #include "tracepoint.h"
  25 #include "regcache.h"
  26 #include <sys/stat.h>
  27 #include "exec.h"
  28 #include "completer.h"
  29 #include "inferior.h"
  30 #include "gdbthread.h"
  31 #include "tracefile.h"
  32
  33 #include <ctype.h>
  34
  35 /* GDB saves trace buffers and other information (such as trace
  36    status) got from the remote target into Common Trace Format (CTF).
  37    The following types of information are expected to save in CTF:
  38
  39    1. The length (in bytes) of register cache.  Event "register" will
  40    be defined in metadata, which includes the length.
  41
  42    2. Trace status.  Event "status" is defined in metadata, which
  43    includes all aspects of trace status.
  44
  45    3. Uploaded trace variables.  Event "tsv_def" is defined in
  46    metadata, which is about all aspects of a uploaded trace variable.
  47    Uploaded tracepoints.   Event "tp_def" is defined in meta, which
  48    is about all aspects of an uploaded tracepoint.  Note that the
  49    "sequence" (a CTF type, which is a dynamically-sized array.) is
  50    used for "actions" "step_actions" and "cmd_strings".
  51
  52    4. Trace frames.  Each trace frame is composed by several blocks
  53    of different types ('R', 'M', 'V').  One trace frame is saved in
  54    one CTF packet and the blocks of this frame are saved as events.
  55    4.1: The trace frame related information (such as the number of
  56    tracepoint associated with this frame) is saved in the packet
  57    context.
  58    4.2: The block 'M', 'R' and 'V' are saved in event "memory",
  59    "register" and "tsv" respectively.
  60    4.3: When iterating over events, babeltrace can't tell iterator
  61    goes to a new packet, so we need a marker or anchor to tell GDB
  62    that iterator goes into a new packet or frame.  We define event
  63    "frame".  */
  64
  65 #define CTF_MAGIC               0xC1FC1FC1
  66 #define CTF_SAVE_MAJOR          1
  67 #define CTF_SAVE_MINOR          8
  68
  69 #define CTF_METADATA_NAME       "metadata"
  70 #define CTF_DATASTREAM_NAME     "datastream"
  71
  72 /* Reserved event id.  */
  73
  74 #define CTF_EVENT_ID_REGISTER 0
  75 #define CTF_EVENT_ID_TSV 1
  76 #define CTF_EVENT_ID_MEMORY 2
  77 #define CTF_EVENT_ID_FRAME 3
  78 #define CTF_EVENT_ID_STATUS 4
  79 #define CTF_EVENT_ID_TSV_DEF 5
  80 #define CTF_EVENT_ID_TP_DEF 6
  81
  82 #define CTF_PID (2)
  83
  84 /* The state kept while writing the CTF datastream file.  */
  85
  86 struct trace_write_handler
  87 {
  88   /* File descriptor of metadata.  */
  89   FILE *metadata_fd;
  90   /* File descriptor of traceframes.  */
  91   FILE *datastream_fd;
  92
  93   /* This is the content size of the current packet.  */
  94   size_t content_size;
  95
  96   /* This is the start offset of current packet.  */
  97   long packet_start;
  98 };
  99
 100 /* Write metadata in FORMAT.  */
 101
 102 static void
 103 ctf_save_write_metadata (struct trace_write_handler *handler,
 104                          const char *format, ...)
 105 {
 106   va_list args;
 107
 108   va_start (args, format);
 109   if (vfprintf (handler->metadata_fd, format, args) < 0)
 110     error (_("Unable to write metadata file (%s)"),
 111              safe_strerror (errno));
 112   va_end (args);
 113 }
 114
 115 /* Write BUF of length SIZE to datastream file represented by
 116    HANDLER.  */
 117
 118 static int
 119 ctf_save_write (struct trace_write_handler *handler,
 120                 const gdb_byte *buf, size_t size)
 121 {
 122   if (fwrite (buf, size, 1, handler->datastream_fd) != 1)
 123     error (_("Unable to write file for saving trace data (%s)"),
 124            safe_strerror (errno));
 125
 126   handler->content_size += size;
 127
 128   return 0;
 129 }
 130
 131 /* Write a unsigned 32-bit integer to datastream file represented by
 132    HANDLER.  */
 133
 134 #define ctf_save_write_uint32(HANDLER, U32) \
 135   ctf_save_write (HANDLER, (gdb_byte *) &U32, 4)
 136
 137 /* Write a signed 32-bit integer to datastream file represented by
 138    HANDLER.  */
 139
 140 #define ctf_save_write_int32(HANDLER, INT32) \
 141   ctf_save_write ((HANDLER), (gdb_byte *) &(INT32), 4)
 142
 143 /* Set datastream file position.  Update HANDLER->content_size
 144    if WHENCE is SEEK_CUR.  */
 145
 146 static int
 147 ctf_save_fseek (struct trace_write_handler *handler, long offset,
 148                 int whence)
 149 {
 150   gdb_assert (whence != SEEK_END);
 151   gdb_assert (whence != SEEK_SET
 152               || offset <= handler->content_size + handler->packet_start);
 153
 154   if (fseek (handler->datastream_fd, offset, whence))
 155     error (_("Unable to seek file for saving trace data (%s)"),
 156            safe_strerror (errno));
 157
 158   if (whence == SEEK_CUR)
 159     handler->content_size += offset;
 160
 161   return 0;
 162 }
 163
 164 /* Change the datastream file position to align on ALIGN_SIZE,
 165    and write BUF to datastream file.  The size of BUF is SIZE.  */
 166
 167 static int
 168 ctf_save_align_write (struct trace_write_handler *handler,
 169                       const gdb_byte *buf,
 170                       size_t size, size_t align_size)
 171 {
 172   long offset
 173     = (align_up (handler->content_size, align_size)
 174        - handler->content_size);
 175
 176   if (ctf_save_fseek (handler, offset, SEEK_CUR))
 177     return -1;
 178
 179   if (ctf_save_write (handler, buf, size))
 180     return -1;
 181
 182   return 0;
 183 }
 184
 185 /* Write events to next new packet.  */
 186
 187 static void
 188 ctf_save_next_packet (struct trace_write_handler *handler)
 189 {
 190   handler->packet_start += (handler->content_size + 4);
 191   ctf_save_fseek (handler, handler->packet_start, SEEK_SET);
 192   handler->content_size = 0;
 193 }
 194
 195 /* Write the CTF metadata header.  */
 196
 197 static void
 198 ctf_save_metadata_header (struct trace_write_handler *handler)
 199 {
 200   const char metadata_fmt[] =
 201   "\ntrace {\n"
 202   "     major = %u;\n"
 203   "     minor = %u;\n"
 204   "     byte_order = %s;\n"             /* be or le */
 205   "     packet.header := struct {\n"
 206   "             uint32_t magic;\n"
 207   "     };\n"
 208   "};\n"
 209   "\n"
 210   "stream {\n"
 211   "     packet.context := struct {\n"
 212   "             uint32_t content_size;\n"
 213   "             uint32_t packet_size;\n"
 214   "             uint16_t tpnum;\n"
 215   "     };\n"
 216   "     event.header := struct {\n"
 217   "             uint32_t id;\n"
 218   "     };\n"
 219   "};\n";
 220
 221   ctf_save_write_metadata (handler, "/* CTF %d.%d */\n",
 222                            CTF_SAVE_MAJOR, CTF_SAVE_MINOR);
 223   ctf_save_write_metadata (handler,
 224                            "typealias integer { size = 8; align = 8; "
 225                            "signed = false; encoding = ascii;}"
 226                            " := ascii;\n");
 227   ctf_save_write_metadata (handler,
 228                            "typealias integer { size = 8; align = 8; "
 229                            "signed = false; }"
 230                            " := uint8_t;\n");
 231   ctf_save_write_metadata (handler,
 232                            "typealias integer { size = 16; align = 16;"
 233                            "signed = false; } := uint16_t;\n");
 234   ctf_save_write_metadata (handler,
 235                            "typealias integer { size = 32; align = 32;"
 236                            "signed = false; } := uint32_t;\n");
 237   ctf_save_write_metadata (handler,
 238                            "typealias integer { size = 64; align = 64;"
 239                            "signed = false; base = hex;}"
 240                            " := uint64_t;\n");
 241   ctf_save_write_metadata (handler,
 242                            "typealias integer { size = 32; align = 32;"
 243                            "signed = true; } := int32_t;\n");
 244   ctf_save_write_metadata (handler,
 245                            "typealias integer { size = 64; align = 64;"
 246                            "signed = true; } := int64_t;\n");
 247   ctf_save_write_metadata (handler,
 248                            "typealias string { encoding = ascii;"
 249                            " } := chars;\n");
 250   ctf_save_write_metadata (handler, "\n");
 251
 252   /* Get the byte order of the host and write CTF data in this byte
 253      order.  */
 254 #if WORDS_BIGENDIAN
 255 #define HOST_ENDIANNESS "be"
 256 #else
 257 #define HOST_ENDIANNESS "le"
 258 #endif
 259
 260   ctf_save_write_metadata (handler, metadata_fmt,
 261                            CTF_SAVE_MAJOR, CTF_SAVE_MINOR,
 262                            HOST_ENDIANNESS);
 263   ctf_save_write_metadata (handler, "\n");
 264 }
 265
 266 /* CTF trace writer.  */
 267
 268 struct ctf_trace_file_writer
 269 {
 270   struct trace_file_writer base;
 271
 272   /* States related to writing CTF trace file.  */
 273   struct trace_write_handler tcs;
 274 };
 275
 276 /* This is the implementation of trace_file_write_ops method
 277    dtor.  */
 278
 279 static void
 280 ctf_dtor (struct trace_file_writer *self)
 281 {
 282   struct ctf_trace_file_writer *writer
 283     = (struct ctf_trace_file_writer *) self;
 284
 285   if (writer->tcs.metadata_fd != NULL)
 286     fclose (writer->tcs.metadata_fd);
 287
 288   if (writer->tcs.datastream_fd != NULL)
 289     fclose (writer->tcs.datastream_fd);
 290
 291 }
 292
 293 /* This is the implementation of trace_file_write_ops method
 294    target_save.  */
 295
 296 static int
 297 ctf_target_save (struct trace_file_writer *self,
 298                  const char *dirname)
 299 {
 300   /* Don't support save trace file to CTF format in the target.  */
 301   return 0;
 302 }
 303
 304 #ifdef USE_WIN32API
 305 #undef mkdir
 306 #define mkdir(pathname, mode) mkdir (pathname)
 307 #endif
 308
 309 /* This is the implementation of trace_file_write_ops method
 310    start.  It creates the directory DIRNAME, metadata and datastream
 311    in the directory.  */
 312
 313 static void
 314 ctf_start (struct trace_file_writer *self, const char *dirname)
 315 {
 316   char *file_name;
 317   struct cleanup *old_chain;
 318   struct ctf_trace_file_writer *writer
 319     = (struct ctf_trace_file_writer *) self;
 320   int i;
 321   mode_t hmode = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH;
 322
 323   /* Create DIRNAME.  */
 324   if (mkdir (dirname, hmode) && errno != EEXIST)
 325     error (_("Unable to open directory '%s' for saving trace data (%s)"),
 326            dirname, safe_strerror (errno));
 327
 328   memset (&writer->tcs, '\0', sizeof (writer->tcs));
 329
 330   file_name = xstrprintf ("%s/%s", dirname, CTF_METADATA_NAME);
 331   old_chain = make_cleanup (xfree, file_name);
 332
 333   writer->tcs.metadata_fd = fopen (file_name, "w");
 334   if (writer->tcs.metadata_fd == NULL)
 335     error (_("Unable to open file '%s' for saving trace data (%s)"),
 336            file_name, safe_strerror (errno));
 337   do_cleanups (old_chain);
 338
 339   ctf_save_metadata_header (&writer->tcs);
 340
 341   file_name = xstrprintf ("%s/%s", dirname, CTF_DATASTREAM_NAME);
 342   old_chain = make_cleanup (xfree, file_name);
 343   writer->tcs.datastream_fd = fopen (file_name, "w");
 344   if (writer->tcs.datastream_fd == NULL)
 345     error (_("Unable to open file '%s' for saving trace data (%s)"),
 346            file_name, safe_strerror (errno));
 347   do_cleanups (old_chain);
 348 }
 349
 350 /* This is the implementation of trace_file_write_ops method
 351    write_header.  Write the types of events on trace variable and
 352    frame.  */
 353
 354 static void
 355 ctf_write_header (struct trace_file_writer *self)
 356 {
 357   struct ctf_trace_file_writer *writer
 358     = (struct ctf_trace_file_writer *) self;
 359
 360
 361   ctf_save_write_metadata (&writer->tcs, "\n");
 362   ctf_save_write_metadata (&writer->tcs,
 363                            "event {\n\tname = \"memory\";\n\tid = %u;\n"
 364                            "\tfields := struct { \n"
 365                            "\t\tuint64_t address;\n"
 366                            "\t\tuint16_t length;\n"
 367                            "\t\tuint8_t contents[length];\n"
 368                            "\t};\n"
 369                            "};\n", CTF_EVENT_ID_MEMORY);
 370
 371   ctf_save_write_metadata (&writer->tcs, "\n");
 372   ctf_save_write_metadata (&writer->tcs,
 373                            "event {\n\tname = \"tsv\";\n\tid = %u;\n"
 374                            "\tfields := struct { \n"
 375                            "\t\tuint64_t val;\n"
 376                            "\t\tuint32_t num;\n"
 377                            "\t};\n"
 378                            "};\n", CTF_EVENT_ID_TSV);
 379
 380   ctf_save_write_metadata (&writer->tcs, "\n");
 381   ctf_save_write_metadata (&writer->tcs,
 382                            "event {\n\tname = \"frame\";\n\tid = %u;\n"
 383                            "\tfields := struct { \n"
 384                            "\t};\n"
 385                            "};\n", CTF_EVENT_ID_FRAME);
 386
 387   ctf_save_write_metadata (&writer->tcs, "\n");
 388   ctf_save_write_metadata (&writer->tcs,
 389                           "event {\n\tname = \"tsv_def\";\n"
 390                           "\tid = %u;\n\tfields := struct { \n"
 391                           "\t\tint64_t initial_value;\n"
 392                           "\t\tint32_t number;\n"
 393                           "\t\tint32_t builtin;\n"
 394                           "\t\tchars name;\n"
 395                           "\t};\n"
 396                           "};\n", CTF_EVENT_ID_TSV_DEF);
 397
 398   ctf_save_write_metadata (&writer->tcs, "\n");
 399   ctf_save_write_metadata (&writer->tcs,
 400                            "event {\n\tname = \"tp_def\";\n"
 401                            "\tid = %u;\n\tfields := struct { \n"
 402                            "\t\tuint64_t addr;\n"
 403                            "\t\tuint64_t traceframe_usage;\n"
 404                            "\t\tint32_t number;\n"
 405                            "\t\tint32_t enabled;\n"
 406                            "\t\tint32_t step;\n"
 407                            "\t\tint32_t pass;\n"
 408                            "\t\tint32_t hit_count;\n"
 409                            "\t\tint32_t type;\n"
 410                            "\t\tchars cond;\n"
 411
 412                           "\t\tuint32_t action_num;\n"
 413                           "\t\tchars actions[action_num];\n"
 414
 415                           "\t\tuint32_t step_action_num;\n"
 416                           "\t\tchars step_actions[step_action_num];\n"
 417
 418                           "\t\tchars at_string;\n"
 419                           "\t\tchars cond_string;\n"
 420
 421                           "\t\tuint32_t cmd_num;\n"
 422                           "\t\tchars cmd_strings[cmd_num];\n"
 423                           "\t};\n"
 424                           "};\n", CTF_EVENT_ID_TP_DEF);
 425
 426   gdb_assert (writer->tcs.content_size == 0);
 427   gdb_assert (writer->tcs.packet_start == 0);
 428
 429   /* Create a new packet to contain this event.  */
 430   self->ops->frame_ops->start (self, 0);
 431 }
 432
 433 /* This is the implementation of trace_file_write_ops method
 434    write_regblock_type.  Write the type of register event in
 435    metadata.  */
 436
 437 static void
 438 ctf_write_regblock_type (struct trace_file_writer *self, int size)
 439 {
 440   struct ctf_trace_file_writer *writer
 441     = (struct ctf_trace_file_writer *) self;
 442
 443   ctf_save_write_metadata (&writer->tcs, "\n");
 444
 445   ctf_save_write_metadata (&writer->tcs,
 446                            "event {\n\tname = \"register\";\n\tid = %u;\n"
 447                            "\tfields := struct { \n"
 448                            "\t\tascii contents[%d];\n"
 449                            "\t};\n"
 450                            "};\n",
 451                            CTF_EVENT_ID_REGISTER, size);
 452 }
 453
 454 /* This is the implementation of trace_file_write_ops method
 455    write_status.  */
 456
 457 static void
 458 ctf_write_status (struct trace_file_writer *self,
 459                   struct trace_status *ts)
 460 {
 461   struct ctf_trace_file_writer *writer
 462     = (struct ctf_trace_file_writer *) self;
 463   uint32_t id;
 464   int32_t int32;
 465
 466   ctf_save_write_metadata (&writer->tcs, "\n");
 467   ctf_save_write_metadata (&writer->tcs,
 468                            "event {\n\tname = \"status\";\n\tid = %u;\n"
 469                            "\tfields := struct { \n"
 470                            "\t\tint32_t stop_reason;\n"
 471                            "\t\tint32_t stopping_tracepoint;\n"
 472                            "\t\tint32_t traceframe_count;\n"
 473                            "\t\tint32_t traceframes_created;\n"
 474                            "\t\tint32_t buffer_free;\n"
 475                            "\t\tint32_t buffer_size;\n"
 476                            "\t\tint32_t disconnected_tracing;\n"
 477                            "\t\tint32_t circular_buffer;\n"
 478                            "\t};\n"
 479                            "};\n",
 480                            CTF_EVENT_ID_STATUS);
 481
 482   id = CTF_EVENT_ID_STATUS;
 483   /* Event Id.  */
 484   ctf_save_align_write (&writer->tcs, (gdb_byte *) &id, 4, 4);
 485
 486   ctf_save_write_int32 (&writer->tcs, ts->stop_reason);
 487   ctf_save_write_int32 (&writer->tcs, ts->stopping_tracepoint);
 488   ctf_save_write_int32 (&writer->tcs, ts->traceframe_count);
 489   ctf_save_write_int32 (&writer->tcs, ts->traceframes_created);
 490   ctf_save_write_int32 (&writer->tcs, ts->buffer_free);
 491   ctf_save_write_int32 (&writer->tcs, ts->buffer_size);
 492   ctf_save_write_int32 (&writer->tcs, ts->disconnected_tracing);
 493   ctf_save_write_int32 (&writer->tcs, ts->circular_buffer);
 494 }
 495
 496 /* This is the implementation of trace_file_write_ops method
 497    write_uploaded_tsv.  */
 498
 499 static void
 500 ctf_write_uploaded_tsv (struct trace_file_writer *self,
 501                         struct uploaded_tsv *tsv)
 502 {
 503   struct ctf_trace_file_writer *writer
 504     = (struct ctf_trace_file_writer *) self;
 505   int32_t int32;
 506   int64_t int64;
 507   unsigned int len;
 508   const gdb_byte zero = 0;
 509
 510   /* Event Id.  */
 511   int32 = CTF_EVENT_ID_TSV_DEF;
 512   ctf_save_align_write (&writer->tcs, (gdb_byte *) &int32, 4, 4);
 513
 514   /* initial_value */
 515   int64 = tsv->initial_value;
 516   ctf_save_align_write (&writer->tcs, (gdb_byte *) &int64, 8, 8);
 517
 518   /* number */
 519   ctf_save_write_int32 (&writer->tcs, tsv->number);
 520
 521   /* builtin */
 522   ctf_save_write_int32 (&writer->tcs, tsv->builtin);
 523
 524   /* name */
 525   if (tsv->name != NULL)
 526     ctf_save_write (&writer->tcs, (gdb_byte *) tsv->name,
 527                     strlen (tsv->name));
 528   ctf_save_write (&writer->tcs, &zero, 1);
 529 }
 530
 531 /* This is the implementation of trace_file_write_ops method
 532    write_uploaded_tp.  */
 533
 534 static void
 535 ctf_write_uploaded_tp (struct trace_file_writer *self,
 536                        struct uploaded_tp *tp)
 537 {
 538   struct ctf_trace_file_writer *writer
 539     = (struct ctf_trace_file_writer *) self;
 540   int32_t int32;
 541   int64_t int64;
 542   uint32_t u32;
 543   const gdb_byte zero = 0;
 544   int a;
 545   char *act;
 546
 547   /* Event Id.  */
 548   int32 = CTF_EVENT_ID_TP_DEF;
 549   ctf_save_align_write (&writer->tcs, (gdb_byte *) &int32, 4, 4);
 550
 551   /* address */
 552   int64 = tp->addr;
 553   ctf_save_align_write (&writer->tcs, (gdb_byte *) &int64, 8, 8);
 554
 555   /* traceframe_usage */
 556   int64 = tp->traceframe_usage;
 557   ctf_save_align_write (&writer->tcs, (gdb_byte *) &int64, 8, 8);
 558
 559   /* number */
 560   ctf_save_write_int32 (&writer->tcs, tp->number);
 561
 562   /* enabled */
 563   ctf_save_write_int32 (&writer->tcs, tp->enabled);
 564
 565   /* step */
 566   ctf_save_write_int32 (&writer->tcs, tp->step);
 567
 568   /* pass */
 569   ctf_save_write_int32 (&writer->tcs, tp->pass);
 570
 571   /* hit_count */
 572   ctf_save_write_int32 (&writer->tcs, tp->hit_count);
 573
 574   /* type */
 575   ctf_save_write_int32 (&writer->tcs, tp->type);
 576
 577   /* condition  */
 578   if (tp->cond != NULL)
 579     ctf_save_write (&writer->tcs, (gdb_byte *) tp->cond, strlen (tp->cond));
 580   ctf_save_write (&writer->tcs, &zero, 1);
 581
 582   /* actions */
 583   u32 = VEC_length (char_ptr, tp->actions);
 584   ctf_save_align_write (&writer->tcs, (gdb_byte *) &u32, 4, 4);
 585   for (a = 0; VEC_iterate (char_ptr, tp->actions, a, act); ++a)
 586     ctf_save_write (&writer->tcs, (gdb_byte *) act, strlen (act) + 1);
 587
 588   /* step_actions */
 589   u32 = VEC_length (char_ptr, tp->step_actions);
 590   ctf_save_align_write (&writer->tcs, (gdb_byte *) &u32, 4, 4);
 591   for (a = 0; VEC_iterate (char_ptr, tp->step_actions, a, act); ++a)
 592     ctf_save_write (&writer->tcs, (gdb_byte *) act, strlen (act) + 1);
 593
 594   /* at_string */
 595   if (tp->at_string != NULL)
 596     ctf_save_write (&writer->tcs, (gdb_byte *) tp->at_string,
 597                     strlen (tp->at_string));
 598   ctf_save_write (&writer->tcs, &zero, 1);
 599
 600   /* cond_string */
 601   if (tp->cond_string != NULL)
 602     ctf_save_write (&writer->tcs, (gdb_byte *) tp->cond_string,
 603                     strlen (tp->cond_string));
 604   ctf_save_write (&writer->tcs, &zero, 1);
 605
 606   /* cmd_strings */
 607   u32 = VEC_length (char_ptr, tp->cmd_strings);
 608   ctf_save_align_write (&writer->tcs, (gdb_byte *) &u32, 4, 4);
 609   for (a = 0; VEC_iterate (char_ptr, tp->cmd_strings, a, act); ++a)
 610     ctf_save_write (&writer->tcs, (gdb_byte *) act, strlen (act) + 1);
 611
 612 }
 613
 614 /* This is the implementation of trace_file_write_ops method
 615    write_definition_end.  */
 616
 617 static void
 618 ctf_write_definition_end (struct trace_file_writer *self)
 619 {
 620   struct ctf_trace_file_writer *writer
 621     = (struct ctf_trace_file_writer *) self;
 622
 623   self->ops->frame_ops->end (self);
 624 }
 625
 626 /* The minimal file size of data stream.  It is required by
 627    babeltrace.  */
 628
 629 #define CTF_FILE_MIN_SIZE               4096
 630
 631 /* This is the implementation of trace_file_write_ops method
 632    end.  */
 633
 634 static void
 635 ctf_end (struct trace_file_writer *self)
 636 {
 637   struct ctf_trace_file_writer *writer = (struct ctf_trace_file_writer *) self;
 638
 639   gdb_assert (writer->tcs.content_size == 0);
 640   /* The babeltrace requires or assumes that the size of datastream
 641      file is greater than 4096 bytes.  If we don't generate enough
 642      packets and events, create a fake packet which has zero event,
 643       to use up the space.  */
 644   if (writer->tcs.packet_start < CTF_FILE_MIN_SIZE)
 645     {
 646       uint32_t u32;
 647
 648       /* magic.  */
 649       u32 = CTF_MAGIC;
 650       ctf_save_write_uint32 (&writer->tcs, u32);
 651
 652       /* content_size.  */
 653       u32 = 0;
 654       ctf_save_write_uint32 (&writer->tcs, u32);
 655
 656       /* packet_size.  */
 657       u32 = 12;
 658       if (writer->tcs.packet_start + u32 < CTF_FILE_MIN_SIZE)
 659         u32 = CTF_FILE_MIN_SIZE - writer->tcs.packet_start;
 660
 661       u32 *= TARGET_CHAR_BIT;
 662       ctf_save_write_uint32 (&writer->tcs, u32);
 663
 664       /* tpnum.  */
 665       u32 = 0;
 666       ctf_save_write (&writer->tcs, (gdb_byte *) &u32, 2);
 667
 668       /* Enlarge the file to CTF_FILE_MIN_SIZE is it is still less
 669          than that.  */
 670       if (CTF_FILE_MIN_SIZE
 671           > (writer->tcs.packet_start + writer->tcs.content_size))
 672         {
 673           gdb_byte b = 0;
 674
 675           /* Fake the content size to avoid assertion failure in
 676              ctf_save_fseek.  */
 677           writer->tcs.content_size = (CTF_FILE_MIN_SIZE
 678                                       - 1 - writer->tcs.packet_start);
 679           ctf_save_fseek (&writer->tcs, CTF_FILE_MIN_SIZE - 1,
 680                           SEEK_SET);
 681           ctf_save_write (&writer->tcs, &b, 1);
 682         }
 683     }
 684 }
 685
 686 /* This is the implementation of trace_frame_write_ops method
 687    start.  */
 688
 689 static void
 690 ctf_write_frame_start (struct trace_file_writer *self, uint16_t tpnum)
 691 {
 692   struct ctf_trace_file_writer *writer
 693     = (struct ctf_trace_file_writer *) self;
 694   uint32_t id = CTF_EVENT_ID_FRAME;
 695   uint32_t u32;
 696
 697   /* Step 1: Write packet context.  */
 698   /* magic.  */
 699   u32 = CTF_MAGIC;
 700   ctf_save_write_uint32 (&writer->tcs, u32);
 701   /* content_size and packet_size..  We still don't know the value,
 702      write it later.  */
 703   ctf_save_fseek (&writer->tcs, 4, SEEK_CUR);
 704   ctf_save_fseek (&writer->tcs, 4, SEEK_CUR);
 705   /* Tracepoint number.  */
 706   ctf_save_write (&writer->tcs, (gdb_byte *) &tpnum, 2);
 707
 708   /* Step 2: Write event "frame".  */
 709   /* Event Id.  */
 710   ctf_save_align_write (&writer->tcs, (gdb_byte *) &id, 4, 4);
 711 }
 712
 713 /* This is the implementation of trace_frame_write_ops method
 714    write_r_block.  */
 715
 716 static void
 717 ctf_write_frame_r_block (struct trace_file_writer *self,
 718                          gdb_byte *buf, int32_t size)
 719 {
 720   struct ctf_trace_file_writer *writer
 721     = (struct ctf_trace_file_writer *) self;
 722   uint32_t id = CTF_EVENT_ID_REGISTER;
 723
 724   /* Event Id.  */
 725   ctf_save_align_write (&writer->tcs, (gdb_byte *) &id, 4, 4);
 726
 727   /* array contents.  */
 728   ctf_save_align_write (&writer->tcs, buf, size, 1);
 729 }
 730
 731 /* This is the implementation of trace_frame_write_ops method
 732    write_m_block_header.  */
 733
 734 static void
 735 ctf_write_frame_m_block_header (struct trace_file_writer *self,
 736                                 uint64_t addr, uint16_t length)
 737 {
 738   struct ctf_trace_file_writer *writer
 739     = (struct ctf_trace_file_writer *) self;
 740   uint32_t event_id = CTF_EVENT_ID_MEMORY;
 741
 742   /* Event Id.  */
 743   ctf_save_align_write (&writer->tcs, (gdb_byte *) &event_id, 4, 4);
 744
 745   /* Address.  */
 746   ctf_save_align_write (&writer->tcs, (gdb_byte *) &addr, 8, 8);
 747
 748   /* Length.  */
 749   ctf_save_align_write (&writer->tcs, (gdb_byte *) &length, 2, 2);
 750 }
 751
 752 /* This is the implementation of trace_frame_write_ops method
 753    write_m_block_memory.  */
 754
 755 static void
 756 ctf_write_frame_m_block_memory (struct trace_file_writer *self,
 757                                 gdb_byte *buf, uint16_t length)
 758 {
 759   struct ctf_trace_file_writer *writer
 760     = (struct ctf_trace_file_writer *) self;
 761
 762   /* Contents.  */
 763   ctf_save_align_write (&writer->tcs, (gdb_byte *) buf, length, 1);
 764 }
 765
 766 /* This is the implementation of trace_frame_write_ops method
 767    write_v_block.  */
 768
 769 static void
 770 ctf_write_frame_v_block (struct trace_file_writer *self,
 771                          int32_t num, uint64_t val)
 772 {
 773   struct ctf_trace_file_writer *writer
 774     = (struct ctf_trace_file_writer *) self;
 775   uint32_t id = CTF_EVENT_ID_TSV;
 776
 777   /* Event Id.  */
 778   ctf_save_align_write (&writer->tcs, (gdb_byte *) &id, 4, 4);
 779
 780   /* val.  */
 781   ctf_save_align_write (&writer->tcs, (gdb_byte *) &val, 8, 8);
 782   /* num.  */
 783   ctf_save_align_write (&writer->tcs, (gdb_byte *) &num, 4, 4);
 784 }
 785
 786 /* This is the implementation of trace_frame_write_ops method
 787    end.  */
 788
 789 static void
 790 ctf_write_frame_end (struct trace_file_writer *self)
 791 {
 792   struct ctf_trace_file_writer *writer
 793     = (struct ctf_trace_file_writer *) self;
 794   uint32_t u32;
 795   uint32_t t;
 796
 797   /* Write the content size to packet header.  */
 798   ctf_save_fseek (&writer->tcs, writer->tcs.packet_start + 4,
 799                   SEEK_SET);
 800   u32 = writer->tcs.content_size * TARGET_CHAR_BIT;
 801
 802   t = writer->tcs.content_size;
 803   ctf_save_write_uint32 (&writer->tcs, u32);
 804
 805   /* Write the packet size.  */
 806   u32 += 4 * TARGET_CHAR_BIT;
 807   ctf_save_write_uint32 (&writer->tcs, u32);
 808
 809   writer->tcs.content_size = t;
 810
 811   /* Write zero at the end of the packet.  */
 812   ctf_save_fseek (&writer->tcs, writer->tcs.packet_start + t,
 813                   SEEK_SET);
 814   u32 = 0;
 815   ctf_save_write_uint32 (&writer->tcs, u32);
 816   writer->tcs.content_size = t;
 817
 818   ctf_save_next_packet (&writer->tcs);
 819 }
 820
 821 /* Operations to write various types of trace frames into CTF
 822    format.  */
 823
 824 static const struct trace_frame_write_ops ctf_write_frame_ops =
 825 {
 826   ctf_write_frame_start,
 827   ctf_write_frame_r_block,
 828   ctf_write_frame_m_block_header,
 829   ctf_write_frame_m_block_memory,
 830   ctf_write_frame_v_block,
 831   ctf_write_frame_end,
 832 };
 833
 834 /* Operations to write trace buffers into CTF format.  */
 835
 836 static const struct trace_file_write_ops ctf_write_ops =
 837 {
 838   ctf_dtor,
 839   ctf_target_save,
 840   ctf_start,
 841   ctf_write_header,
 842   ctf_write_regblock_type,
 843   ctf_write_status,
 844   ctf_write_uploaded_tsv,
 845   ctf_write_uploaded_tp,
 846   ctf_write_definition_end,
 847   NULL,
 848   &ctf_write_frame_ops,
 849   ctf_end,
 850 };
 851
 852 /* Return a trace writer for CTF format.  */
 853
 854 struct trace_file_writer *
 855 ctf_trace_file_writer_new (void)
 856 {
 857   struct ctf_trace_file_writer *writer
 858     = xmalloc (sizeof (struct ctf_trace_file_writer));
 859
 860   writer->base.ops = &ctf_write_ops;
 861
 862   return (struct trace_file_writer *) writer;
 863 }
 864
 865 #if HAVE_LIBBABELTRACE
 866 /* Use libbabeltrace to read CTF data.  The libbabeltrace provides
 867    iterator to iterate over each event in CTF data and APIs to get
 868    details of event and packet, so it is very convenient to use
 869    libbabeltrace to access events in CTF.  */
 870
 871 #include <babeltrace/babeltrace.h>
 872 #include <babeltrace/ctf/events.h>
 873 #include <babeltrace/ctf/iterator.h>
 874
 875 /* The struct pointer for current CTF directory.  */
 876 static struct bt_context *ctx = NULL;
 877 static struct bt_ctf_iter *ctf_iter = NULL;
 878 /* The position of the first packet containing trace frame.  */
 879 static struct bt_iter_pos *start_pos;
 880
 881 /* The name of CTF directory.  */
 882 static char *trace_dirname;
 883
 884 static struct target_ops ctf_ops;
 885
 886 /* Destroy ctf iterator and context.  */
 887
 888 static void
 889 ctf_destroy (void)
 890 {
 891   if (ctf_iter != NULL)
 892     {
 893       bt_ctf_iter_destroy (ctf_iter);
 894       ctf_iter = NULL;
 895     }
 896   if (ctx != NULL)
 897     {
 898       bt_context_put (ctx);
 899       ctx = NULL;
 900     }
 901 }
 902
 903 /* Open CTF trace data in DIRNAME.  */
 904
 905 static void
 906 ctf_open_dir (char *dirname)
 907 {
 908   int ret;
 909   struct bt_iter_pos begin_pos;
 910   struct bt_iter_pos *pos;
 911
 912   ctx = bt_context_create ();
 913   if (ctx == NULL)
 914     error (_("Unable to create bt_context"));
 915   ret = bt_context_add_trace (ctx, dirname, "ctf", NULL, NULL, NULL);
 916   if (ret < 0)
 917     {
 918       ctf_destroy ();
 919       error (_("Unable to use libbabeltrace on directory \"%s\""),
 920              dirname);
 921     }
 922
 923   begin_pos.type = BT_SEEK_BEGIN;
 924   ctf_iter = bt_ctf_iter_create (ctx, &begin_pos, NULL);
 925   if (ctf_iter == NULL)
 926     {
 927       ctf_destroy ();
 928       error (_("Unable to create bt_iterator"));
 929     }
 930
 931   /* Iterate over events, and look for an event for register block
 932      to set trace_regblock_size.  */
 933
 934   /* Save the current position.  */
 935   pos = bt_iter_get_pos (bt_ctf_get_iter (ctf_iter));
 936   gdb_assert (pos->type == BT_SEEK_RESTORE);
 937
 938   while (1)
 939     {
 940       const char *name;
 941       struct bt_ctf_event *event;
 942
 943       event = bt_ctf_iter_read_event (ctf_iter);
 944
 945       name = bt_ctf_event_name (event);
 946
 947       if (name == NULL)
 948         break;
 949       else if (strcmp (name, "register") == 0)
 950         {
 951           const struct bt_definition *scope
 952             = bt_ctf_get_top_level_scope (event,
 953                                           BT_EVENT_FIELDS);
 954           const struct bt_definition *array
 955             = bt_ctf_get_field (event, scope, "contents");
 956
 957           trace_regblock_size
 958             = bt_ctf_get_array_len (bt_ctf_get_decl_from_def (array));
 959         }
 960
 961       if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
 962         break;
 963     }
 964
 965   /* Restore the position.  */
 966   bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), pos);
 967 }
 968
 969 #define SET_INT32_FIELD(EVENT, SCOPE, VAR, FIELD)                       \
 970   (VAR)->FIELD = (int) bt_ctf_get_int64 (bt_ctf_get_field ((EVENT),     \
 971                                                            (SCOPE),     \
 972                                                            #FIELD))
 973
 974 /* EVENT is the "status" event and TS is filled in.  */
 975
 976 static void
 977 ctf_read_status (struct bt_ctf_event *event, struct trace_status *ts)
 978 {
 979   const struct bt_definition *scope
 980     = bt_ctf_get_top_level_scope (event, BT_EVENT_FIELDS);
 981
 982   SET_INT32_FIELD (event, scope, ts, stop_reason);
 983   SET_INT32_FIELD (event, scope, ts, stopping_tracepoint);
 984   SET_INT32_FIELD (event, scope, ts, traceframe_count);
 985   SET_INT32_FIELD (event, scope, ts, traceframes_created);
 986   SET_INT32_FIELD (event, scope, ts, buffer_free);
 987   SET_INT32_FIELD (event, scope, ts, buffer_size);
 988   SET_INT32_FIELD (event, scope, ts, disconnected_tracing);
 989   SET_INT32_FIELD (event, scope, ts, circular_buffer);
 990
 991   bt_iter_next (bt_ctf_get_iter (ctf_iter));
 992 }
 993
 994 /* Read the events "tsv_def" one by one, extract its contents and fill
 995    in the list UPLOADED_TSVS.  */
 996
 997 static void
 998 ctf_read_tsv (struct uploaded_tsv **uploaded_tsvs)
 999 {
1000   gdb_assert (ctf_iter != NULL);
1001
1002   while (1)
1003     {
1004       struct bt_ctf_event *event;
1005       const struct bt_definition *scope;
1006       const struct bt_definition *def;
1007       uint32_t event_id;
1008       struct uploaded_tsv *utsv = NULL;
1009
1010       event = bt_ctf_iter_read_event (ctf_iter);
1011       scope = bt_ctf_get_top_level_scope (event,
1012                                           BT_STREAM_EVENT_HEADER);
1013       event_id = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope,
1014                                                       "id"));
1015       if (event_id != CTF_EVENT_ID_TSV_DEF)
1016         break;
1017
1018       scope = bt_ctf_get_top_level_scope (event,
1019                                           BT_EVENT_FIELDS);
1020
1021       def = bt_ctf_get_field (event, scope, "number");
1022       utsv = get_uploaded_tsv ((int32_t) bt_ctf_get_int64 (def),
1023                                uploaded_tsvs);
1024
1025       def = bt_ctf_get_field (event, scope, "builtin");
1026       utsv->builtin = (int32_t) bt_ctf_get_int64 (def);
1027       def = bt_ctf_get_field (event, scope, "initial_value");
1028       utsv->initial_value = bt_ctf_get_int64 (def);
1029
1030       def = bt_ctf_get_field (event, scope, "name");
1031       utsv->name =  xstrdup (bt_ctf_get_string (def));
1032
1033       if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1034         break;
1035     }
1036
1037 }
1038
1039 /* Read the value of element whose index is NUM from CTF and write it
1040    to the corresponding VAR->ARRAY. */
1041
1042 #define SET_ARRAY_FIELD(EVENT, SCOPE, VAR, NUM, ARRAY)  \
1043   do                                                    \
1044     {                                                   \
1045       uint32_t u32, i;                                          \
1046       const struct bt_definition *def;                          \
1047                                                                 \
1048       u32 = (uint32_t) bt_ctf_get_uint64 (bt_ctf_get_field ((EVENT),    \
1049                                                             (SCOPE),    \
1050                                                             #NUM));     \
1051       def = bt_ctf_get_field ((EVENT), (SCOPE), #ARRAY);                \
1052       for (i = 0; i < u32; i++)                                 \
1053         {                                                               \
1054           const struct bt_definition *element                           \
1055             = bt_ctf_get_index ((EVENT), def, i);                       \
1056                                                                         \
1057           VEC_safe_push (char_ptr, (VAR)->ARRAY,                        \
1058                          xstrdup (bt_ctf_get_string (element)));        \
1059         }                                                               \
1060     }                                                                   \
1061   while (0)
1062
1063 /* Read a string from CTF and set VAR->FIELD. If the length of string
1064    is zero, set VAR->FIELD to NULL.  */
1065
1066 #define SET_STRING_FIELD(EVENT, SCOPE, VAR, FIELD)                      \
1067   do                                                                    \
1068     {                                                                   \
1069       const char *p = bt_ctf_get_string (bt_ctf_get_field ((EVENT),     \
1070                                                            (SCOPE),     \
1071                                                            #FIELD));    \
1072                                                                         \
1073       if (strlen (p) > 0)                                               \
1074         (VAR)->FIELD = xstrdup (p);                                     \
1075       else                                                              \
1076         (VAR)->FIELD = NULL;                                            \
1077     }                                                                   \
1078   while (0)
1079
1080 /* Read the events "tp_def" one by one, extract its contents and fill
1081    in the list UPLOADED_TPS.  */
1082
1083 static void
1084 ctf_read_tp (struct uploaded_tp **uploaded_tps)
1085 {
1086   gdb_assert (ctf_iter != NULL);
1087
1088   while (1)
1089     {
1090       struct bt_ctf_event *event;
1091       const struct bt_definition *scope;
1092       uint32_t u32;
1093       int32_t int32;
1094       uint64_t u64;
1095       struct uploaded_tp *utp = NULL;
1096
1097       event = bt_ctf_iter_read_event (ctf_iter);
1098       scope = bt_ctf_get_top_level_scope (event,
1099                                           BT_STREAM_EVENT_HEADER);
1100       u32 = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope,
1101                                                  "id"));
1102       if (u32 != CTF_EVENT_ID_TP_DEF)
1103         break;
1104
1105       scope = bt_ctf_get_top_level_scope (event,
1106                                           BT_EVENT_FIELDS);
1107       int32 = (int32_t) bt_ctf_get_int64 (bt_ctf_get_field (event,
1108                                                             scope,
1109                                                             "number"));
1110       u64 = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope,
1111                                                  "addr"));
1112       utp = get_uploaded_tp (int32, u64,  uploaded_tps);
1113
1114       SET_INT32_FIELD (event, scope, utp, enabled);
1115       SET_INT32_FIELD (event, scope, utp, step);
1116       SET_INT32_FIELD (event, scope, utp, pass);
1117       SET_INT32_FIELD (event, scope, utp, hit_count);
1118       SET_INT32_FIELD (event, scope, utp, type);
1119
1120       /* Read 'cmd_strings'.  */
1121       SET_ARRAY_FIELD (event, scope, utp, cmd_num, cmd_strings);
1122       /* Read 'actions'.  */
1123       SET_ARRAY_FIELD (event, scope, utp, action_num, actions);
1124       /* Read 'step_actions'.  */
1125       SET_ARRAY_FIELD (event, scope, utp, step_action_num,
1126                        step_actions);
1127
1128       SET_STRING_FIELD(event, scope, utp, at_string);
1129       SET_STRING_FIELD(event, scope, utp, cond_string);
1130
1131       if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1132         break;
1133     }
1134 }
1135
1136 /* This is the implementation of target_ops method to_open.  Open CTF
1137    trace data, read trace status, trace state variables and tracepoint
1138    definitions from the first packet.  Set the start position at the
1139    second packet which contains events on trace blocks.  */
1140
1141 static void
1142 ctf_open (char *dirname, int from_tty)
1143 {
1144   struct bt_ctf_event *event;
1145   uint32_t event_id;
1146   const struct bt_definition *scope;
1147   struct uploaded_tsv *uploaded_tsvs = NULL;
1148   struct uploaded_tp *uploaded_tps = NULL;
1149
1150   if (!dirname)
1151     error (_("No CTF directory specified."));
1152
1153   ctf_open_dir (dirname);
1154
1155   target_preopen (from_tty);
1156
1157   /* Skip the first packet which about the trace status.  The first
1158      event is "frame".  */
1159   event = bt_ctf_iter_read_event (ctf_iter);
1160   scope = bt_ctf_get_top_level_scope (event, BT_STREAM_EVENT_HEADER);
1161   event_id = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope, "id"));
1162   if (event_id != CTF_EVENT_ID_FRAME)
1163     error (_("Wrong event id of the first event"));
1164   /* The second event is "status".  */
1165   bt_iter_next (bt_ctf_get_iter (ctf_iter));
1166   event = bt_ctf_iter_read_event (ctf_iter);
1167   scope = bt_ctf_get_top_level_scope (event, BT_STREAM_EVENT_HEADER);
1168   event_id = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope, "id"));
1169   if (event_id != CTF_EVENT_ID_STATUS)
1170     error (_("Wrong event id of the second event"));
1171   ctf_read_status (event, current_trace_status ());
1172
1173   ctf_read_tsv (&uploaded_tsvs);
1174
1175   ctf_read_tp (&uploaded_tps);
1176
1177   event = bt_ctf_iter_read_event (ctf_iter);
1178   /* EVENT can be NULL if we've already gone to the end of stream of
1179      events.  */
1180   if (event != NULL)
1181     {
1182       scope = bt_ctf_get_top_level_scope (event,
1183                                           BT_STREAM_EVENT_HEADER);
1184       event_id = bt_ctf_get_uint64 (bt_ctf_get_field (event,
1185                                                       scope, "id"));
1186       if (event_id != CTF_EVENT_ID_FRAME)
1187         error (_("Wrong event id of the first event of the second packet"));
1188     }
1189
1190   start_pos = bt_iter_get_pos (bt_ctf_get_iter (ctf_iter));
1191   gdb_assert (start_pos->type == BT_SEEK_RESTORE);
1192
1193   trace_dirname = xstrdup (dirname);
1194   push_target (&ctf_ops);
1195
1196   inferior_appeared (current_inferior (), CTF_PID);
1197   inferior_ptid = pid_to_ptid (CTF_PID);
1198   add_thread_silent (inferior_ptid);
1199
1200   merge_uploaded_trace_state_variables (&uploaded_tsvs);
1201   merge_uploaded_tracepoints (&uploaded_tps);
1202 }
1203
1204 /* This is the implementation of target_ops method to_close.  Destroy
1205    CTF iterator and context.  */
1206
1207 static void
1208 ctf_close (struct target_ops *self)
1209 {
1210   int pid;
1211
1212   ctf_destroy ();
1213   xfree (trace_dirname);
1214   trace_dirname = NULL;
1215
1216   pid = ptid_get_pid (inferior_ptid);
1217   inferior_ptid = null_ptid;    /* Avoid confusion from thread stuff.  */
1218   exit_inferior_silent (pid);
1219
1220   trace_reset_local_state ();
1221 }
1222
1223 /* This is the implementation of target_ops method to_files_info.
1224    Print the directory name of CTF trace data.  */
1225
1226 static void
1227 ctf_files_info (struct target_ops *t)
1228 {
1229   printf_filtered ("\t`%s'\n", trace_dirname);
1230 }
1231
1232 /* This is the implementation of target_ops method to_fetch_registers.
1233    Iterate over events whose name is "register" in current frame,
1234    extract contents from events, and set REGCACHE with the contents.
1235    If no matched events are found, mark registers unavailable.  */
1236
1237 static void
1238 ctf_fetch_registers (struct target_ops *ops,
1239                      struct regcache *regcache, int regno)
1240 {
1241   struct gdbarch *gdbarch = get_regcache_arch (regcache);
1242   int offset, regn, regsize, pc_regno;
1243   gdb_byte *regs = NULL;
1244   struct bt_ctf_event *event = NULL;
1245   struct bt_iter_pos *pos;
1246
1247   /* An uninitialized reg size says we're not going to be
1248      successful at getting register blocks.  */
1249   if (trace_regblock_size == 0)
1250     return;
1251
1252   gdb_assert (ctf_iter != NULL);
1253   /* Save the current position.  */
1254   pos = bt_iter_get_pos (bt_ctf_get_iter (ctf_iter));
1255   gdb_assert (pos->type == BT_SEEK_RESTORE);
1256
1257   while (1)
1258     {
1259       const char *name;
1260       struct bt_ctf_event *event1;
1261
1262       event1 = bt_ctf_iter_read_event (ctf_iter);
1263
1264       name = bt_ctf_event_name (event1);
1265
1266       if (name == NULL || strcmp (name, "frame") == 0)
1267         break;
1268       else if (strcmp (name, "register") == 0)
1269         {
1270           event = event1;
1271           break;
1272         }
1273
1274       if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1275         break;
1276     }
1277
1278   /* Restore the position.  */
1279   bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), pos);
1280
1281   if (event != NULL)
1282     {
1283       const struct bt_definition *scope
1284         = bt_ctf_get_top_level_scope (event,
1285                                       BT_EVENT_FIELDS);
1286       const struct bt_definition *array
1287         = bt_ctf_get_field (event, scope, "contents");
1288
1289       regs = (gdb_byte *) bt_ctf_get_char_array (array);
1290       /* Assume the block is laid out in GDB register number order,
1291          each register with the size that it has in GDB.  */
1292       offset = 0;
1293       for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
1294         {
1295           regsize = register_size (gdbarch, regn);
1296           /* Make sure we stay within block bounds.  */
1297           if (offset + regsize >= trace_regblock_size)
1298             break;
1299           if (regcache_register_status (regcache, regn) == REG_UNKNOWN)
1300             {
1301               if (regno == regn)
1302                 {
1303                   regcache_raw_supply (regcache, regno, regs + offset);
1304                   break;
1305                 }
1306               else if (regno == -1)
1307                 {
1308                   regcache_raw_supply (regcache, regn, regs + offset);
1309                 }
1310             }
1311           offset += regsize;
1312         }
1313       return;
1314     }
1315
1316   regs = alloca (trace_regblock_size);
1317
1318   /* We get here if no register data has been found.  Mark registers
1319      as unavailable.  */
1320   for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
1321     regcache_raw_supply (regcache, regn, NULL);
1322
1323   /* We can often usefully guess that the PC is going to be the same
1324      as the address of the tracepoint.  */
1325   pc_regno = gdbarch_pc_regnum (gdbarch);
1326   if (pc_regno >= 0 && (regno == -1 || regno == pc_regno))
1327     {
1328       struct tracepoint *tp = get_tracepoint (get_tracepoint_number ());
1329
1330       if (tp != NULL && tp->base.loc)
1331         {
1332           /* But don't try to guess if tracepoint is multi-location...  */
1333           if (tp->base.loc->next != NULL)
1334             {
1335               warning (_("Tracepoint %d has multiple "
1336                          "locations, cannot infer $pc"),
1337                        tp->base.number);
1338               return;
1339             }
1340           /* ... or does while-stepping.  */
1341           if (tp->step_count > 0)
1342             {
1343               warning (_("Tracepoint %d does while-stepping, "
1344                          "cannot infer $pc"),
1345                        tp->base.number);
1346               return;
1347             }
1348
1349           store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
1350                                   gdbarch_byte_order (gdbarch),
1351                                   tp->base.loc->address);
1352           regcache_raw_supply (regcache, pc_regno, regs);
1353         }
1354     }
1355 }
1356
1357 /* This is the implementation of target_ops method to_xfer_partial.
1358    Iterate over events whose name is "memory" in
1359    current frame, extract the address and length from events.  If
1360    OFFSET is within the range, read the contents from events to
1361    READBUF.  */
1362
1363 static enum target_xfer_status
1364 ctf_xfer_partial (struct target_ops *ops, enum target_object object,
1365                   const char *annex, gdb_byte *readbuf,
1366                   const gdb_byte *writebuf, ULONGEST offset,
1367                   ULONGEST len, ULONGEST *xfered_len)
1368 {
1369   /* We're only doing regular memory for now.  */
1370   if (object != TARGET_OBJECT_MEMORY)
1371     return -1;
1372
1373   if (readbuf == NULL)
1374     error (_("ctf_xfer_partial: trace file is read-only"));
1375
1376   if (get_traceframe_number () != -1)
1377     {
1378       struct bt_iter_pos *pos;
1379       int i = 0;
1380
1381       gdb_assert (ctf_iter != NULL);
1382       /* Save the current position.  */
1383       pos = bt_iter_get_pos (bt_ctf_get_iter (ctf_iter));
1384       gdb_assert (pos->type == BT_SEEK_RESTORE);
1385
1386       /* Iterate through the traceframe's blocks, looking for
1387          memory.  */
1388       while (1)
1389         {
1390           ULONGEST amt;
1391           uint64_t maddr;
1392           uint16_t mlen;
1393           enum bfd_endian byte_order
1394             = gdbarch_byte_order (target_gdbarch ());
1395           const struct bt_definition *scope;
1396           const struct bt_definition *def;
1397           struct bt_ctf_event *event
1398             = bt_ctf_iter_read_event (ctf_iter);
1399           const char *name = bt_ctf_event_name (event);
1400
1401           if (strcmp (name, "frame") == 0)
1402             break;
1403           else if (strcmp (name, "memory") != 0)
1404             {
1405               if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1406                 break;
1407
1408               continue;
1409             }
1410
1411           scope = bt_ctf_get_top_level_scope (event,
1412                                               BT_EVENT_FIELDS);
1413
1414           def = bt_ctf_get_field (event, scope, "address");
1415           maddr = bt_ctf_get_uint64 (def);
1416           def = bt_ctf_get_field (event, scope, "length");
1417           mlen = (uint16_t) bt_ctf_get_uint64 (def);
1418
1419           /* If the block includes the first part of the desired
1420              range, return as much it has; GDB will re-request the
1421              remainder, which might be in a different block of this
1422              trace frame.  */
1423           if (maddr <= offset && offset < (maddr + mlen))
1424             {
1425               const struct bt_definition *array
1426                 = bt_ctf_get_field (event, scope, "contents");
1427               const struct bt_declaration *decl
1428                 = bt_ctf_get_decl_from_def (array);
1429               gdb_byte *contents;
1430               int k;
1431
1432               contents = xmalloc (mlen);
1433
1434               for (k = 0; k < mlen; k++)
1435                 {
1436                   const struct bt_definition *element
1437                     = bt_ctf_get_index (event, array, k);
1438
1439                   contents[k] = (gdb_byte) bt_ctf_get_uint64 (element);
1440                 }
1441
1442               amt = (maddr + mlen) - offset;
1443               if (amt > len)
1444                 amt = len;
1445
1446               memcpy (readbuf, &contents[offset - maddr], amt);
1447
1448               xfree (contents);
1449
1450               /* Restore the position.  */
1451               bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), pos);
1452
1453               if (amt == 0)
1454                 return TARGET_XFER_EOF;
1455               else
1456                 {
1457                   *xfered_len = amt;
1458                   return TARGET_XFER_OK;
1459                 }
1460             }
1461
1462           if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1463             break;
1464         }
1465
1466       /* Restore the position.  */
1467       bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), pos);
1468
1469       return exec_read_partial_read_only (readbuf, offset, len, xfered_len);
1470     }
1471   else
1472     {
1473       /* Fallback to reading from read-only sections.  */
1474       return section_table_read_available_memory (readbuf, offset, len, xfered_len);
1475     }
1476 }
1477
1478 /* This is the implementation of target_ops method
1479    to_get_trace_state_variable_value.
1480    Iterate over events whose name is "tsv" in current frame.  When the
1481    trace variable is found, set the value of it to *VAL and return
1482    true, otherwise return false.  */
1483
1484 static int
1485 ctf_get_trace_state_variable_value (struct target_ops *self,
1486                                     int tsvnum, LONGEST *val)
1487 {
1488   struct bt_iter_pos *pos;
1489   int found = 0;
1490
1491   gdb_assert (ctf_iter != NULL);
1492   /* Save the current position.  */
1493   pos = bt_iter_get_pos (bt_ctf_get_iter (ctf_iter));
1494   gdb_assert (pos->type == BT_SEEK_RESTORE);
1495
1496   /* Iterate through the traceframe's blocks, looking for 'V'
1497      block.  */
1498   while (1)
1499     {
1500       struct bt_ctf_event *event
1501         = bt_ctf_iter_read_event (ctf_iter);
1502       const char *name = bt_ctf_event_name (event);
1503
1504       if (name == NULL || strcmp (name, "frame") == 0)
1505         break;
1506       else if (strcmp (name, "tsv") == 0)
1507         {
1508           const struct bt_definition *scope;
1509           const struct bt_definition *def;
1510
1511           scope = bt_ctf_get_top_level_scope (event,
1512                                               BT_EVENT_FIELDS);
1513
1514           def = bt_ctf_get_field (event, scope, "num");
1515           if (tsvnum == (int32_t) bt_ctf_get_uint64 (def))
1516             {
1517               def = bt_ctf_get_field (event, scope, "val");
1518               *val = bt_ctf_get_uint64 (def);
1519
1520               found = 1;
1521             }
1522         }
1523
1524       if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1525         break;
1526     }
1527
1528   /* Restore the position.  */
1529   bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), pos);
1530
1531   return found;
1532 }
1533
1534 /* Return the tracepoint number in "frame" event.  */
1535
1536 static int
1537 ctf_get_tpnum_from_frame_event (struct bt_ctf_event *event)
1538 {
1539   /* The packet context of events has a field "tpnum".  */
1540   const struct bt_definition *scope
1541     = bt_ctf_get_top_level_scope (event, BT_STREAM_PACKET_CONTEXT);
1542   uint64_t tpnum
1543     = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope, "tpnum"));
1544
1545   return (int) tpnum;
1546 }
1547
1548 /* Return the address at which the current frame was collected.  */
1549
1550 static CORE_ADDR
1551 ctf_get_traceframe_address (void)
1552 {
1553   struct bt_ctf_event *event = NULL;
1554   struct bt_iter_pos *pos;
1555   CORE_ADDR addr = 0;
1556
1557   gdb_assert (ctf_iter != NULL);
1558   pos  = bt_iter_get_pos (bt_ctf_get_iter (ctf_iter));
1559   gdb_assert (pos->type == BT_SEEK_RESTORE);
1560
1561   while (1)
1562     {
1563       const char *name;
1564       struct bt_ctf_event *event1;
1565
1566       event1 = bt_ctf_iter_read_event (ctf_iter);
1567
1568       name = bt_ctf_event_name (event1);
1569
1570       if (name == NULL)
1571         break;
1572       else if (strcmp (name, "frame") == 0)
1573         {
1574           event = event1;
1575           break;
1576         }
1577
1578       if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1579         break;
1580     }
1581
1582   if (event != NULL)
1583     {
1584       int tpnum = ctf_get_tpnum_from_frame_event (event);
1585       struct tracepoint *tp
1586         = get_tracepoint_by_number_on_target (tpnum);
1587
1588       if (tp && tp->base.loc)
1589         addr = tp->base.loc->address;
1590     }
1591
1592   /* Restore the position.  */
1593   bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), pos);
1594
1595   return addr;
1596 }
1597
1598 /* This is the implementation of target_ops method to_trace_find.
1599    Iterate the events whose name is "frame", extract the tracepoint
1600    number in it.  Return traceframe number when matched.  */
1601
1602 static int
1603 ctf_trace_find (struct target_ops *self, enum trace_find_type type, int num,
1604                 CORE_ADDR addr1, CORE_ADDR addr2, int *tpp)
1605 {
1606   int ret = -1;
1607   int tfnum = 0;
1608   int found = 0;
1609   struct bt_iter_pos pos;
1610
1611   if (num == -1)
1612     {
1613       if (tpp != NULL)
1614         *tpp = -1;
1615       return -1;
1616     }
1617
1618   gdb_assert (ctf_iter != NULL);
1619   /* Set iterator back to the start.  */
1620   bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), start_pos);
1621
1622   while (1)
1623     {
1624       int id;
1625       struct bt_ctf_event *event;
1626       const char *name;
1627
1628       event = bt_ctf_iter_read_event (ctf_iter);
1629
1630       name = bt_ctf_event_name (event);
1631
1632       if (event == NULL || name == NULL)
1633         break;
1634
1635       if (strcmp (name, "frame") == 0)
1636         {
1637           CORE_ADDR tfaddr;
1638
1639           if (type == tfind_number)
1640             {
1641               /* Looking for a specific trace frame.  */
1642               if (tfnum == num)
1643                 found = 1;
1644             }
1645           else
1646             {
1647               /* Start from the _next_ trace frame.  */
1648               if (tfnum > get_traceframe_number ())
1649                 {
1650                   switch (type)
1651                     {
1652                     case tfind_tp:
1653                       {
1654                         struct tracepoint *tp = get_tracepoint (num);
1655
1656                         if (tp != NULL
1657                             && (tp->number_on_target
1658                                 == ctf_get_tpnum_from_frame_event (event)))
1659                           found = 1;
1660                         break;
1661                       }
1662                     case tfind_pc:
1663                       tfaddr = ctf_get_traceframe_address ();
1664                       if (tfaddr == addr1)
1665                         found = 1;
1666                       break;
1667                     case tfind_range:
1668                       tfaddr = ctf_get_traceframe_address ();
1669                       if (addr1 <= tfaddr && tfaddr <= addr2)
1670                         found = 1;
1671                       break;
1672                     case tfind_outside:
1673                       tfaddr = ctf_get_traceframe_address ();
1674                       if (!(addr1 <= tfaddr && tfaddr <= addr2))
1675                         found = 1;
1676                       break;
1677                     default:
1678                       internal_error (__FILE__, __LINE__, _("unknown tfind type"));
1679                     }
1680                 }
1681             }
1682           if (found)
1683             {
1684               if (tpp != NULL)
1685                 *tpp = ctf_get_tpnum_from_frame_event (event);
1686
1687               /* Skip the event "frame".  */
1688               bt_iter_next (bt_ctf_get_iter (ctf_iter));
1689
1690               return tfnum;
1691             }
1692           tfnum++;
1693         }
1694
1695       if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1696         break;
1697     }
1698
1699   return -1;
1700 }
1701
1702 /* This is the implementation of target_ops method to_traceframe_info.
1703    Iterate the events whose name is "memory", in current
1704    frame, extract memory range information, and return them in
1705    traceframe_info.  */
1706
1707 static struct traceframe_info *
1708 ctf_traceframe_info (struct target_ops *self)
1709 {
1710   struct traceframe_info *info = XCNEW (struct traceframe_info);
1711   const char *name;
1712   struct bt_iter_pos *pos;
1713
1714   gdb_assert (ctf_iter != NULL);
1715   /* Save the current position.  */
1716   pos = bt_iter_get_pos (bt_ctf_get_iter (ctf_iter));
1717   gdb_assert (pos->type == BT_SEEK_RESTORE);
1718
1719   do
1720     {
1721       struct bt_ctf_event *event
1722         = bt_ctf_iter_read_event (ctf_iter);
1723
1724       name = bt_ctf_event_name (event);
1725
1726       if (name == NULL || strcmp (name, "register") == 0
1727           || strcmp (name, "frame") == 0)
1728         ;
1729       else if (strcmp (name, "memory") == 0)
1730         {
1731           const struct bt_definition *scope
1732             = bt_ctf_get_top_level_scope (event,
1733                                           BT_EVENT_FIELDS);
1734           const struct bt_definition *def;
1735           struct mem_range *r;
1736
1737           r = VEC_safe_push (mem_range_s, info->memory, NULL);
1738           def = bt_ctf_get_field (event, scope, "address");
1739           r->start = bt_ctf_get_uint64 (def);
1740
1741           def = bt_ctf_get_field (event, scope, "length");
1742           r->length = (uint16_t) bt_ctf_get_uint64 (def);
1743         }
1744       else if (strcmp (name, "tsv") == 0)
1745         {
1746           int vnum;
1747           const struct bt_definition *scope
1748             = bt_ctf_get_top_level_scope (event,
1749                                           BT_EVENT_FIELDS);
1750           const struct bt_definition *def;
1751
1752           def = bt_ctf_get_field (event, scope, "num");
1753           vnum = (int) bt_ctf_get_int64 (def);
1754           VEC_safe_push (int, info->tvars, vnum);
1755         }
1756       else
1757         {
1758           warning (_("Unhandled trace block type (%s) "
1759                      "while building trace frame info."),
1760                    name);
1761         }
1762
1763       if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1764         break;
1765     }
1766   while (name != NULL && strcmp (name, "frame") != 0);
1767
1768   /* Restore the position.  */
1769   bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), pos);
1770
1771   return info;
1772 }
1773
1774 static void
1775 init_ctf_ops (void)
1776 {
1777   memset (&ctf_ops, 0, sizeof (ctf_ops));
1778
1779   init_tracefile_ops (&ctf_ops);
1780   ctf_ops.to_shortname = "ctf";
1781   ctf_ops.to_longname = "CTF file";
1782   ctf_ops.to_doc = "Use a CTF directory as a target.\n\
1783 Specify the filename of the CTF directory.";
1784   ctf_ops.to_open = ctf_open;
1785   ctf_ops.to_close = ctf_close;
1786   ctf_ops.to_fetch_registers = ctf_fetch_registers;
1787   ctf_ops.to_xfer_partial = ctf_xfer_partial;
1788   ctf_ops.to_files_info = ctf_files_info;
1789   ctf_ops.to_trace_find = ctf_trace_find;
1790   ctf_ops.to_get_trace_state_variable_value
1791     = ctf_get_trace_state_variable_value;
1792   ctf_ops.to_traceframe_info = ctf_traceframe_info;
1793 }
1794
1795 #endif
1796
1797 /* -Wmissing-prototypes */
1798
1799 extern initialize_file_ftype _initialize_ctf;
1800
1801 /* module initialization */
1802
1803 void
1804 _initialize_ctf (void)
1805 {
1806 #if HAVE_LIBBABELTRACE
1807   init_ctf_ops ();
1808
1809   add_target_with_completer (&ctf_ops, filename_completer);
1810 #endif
1811 }