gdb/ctf.c

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