/* CTF format support.
- Copyright (C) 2012-2015 Free Software Foundation, Inc.
+ Copyright (C) 2012-2017 Free Software Foundation, Inc.
Contributed by Hui Zhu <hui_zhu@mentor.com>
Contributed by Yao Qi <yao@codesourcery.com>
#include "inferior.h"
#include "gdbthread.h"
#include "tracefile.h"
-
#include <ctype.h>
+#include <algorithm>
/* GDB saves trace buffers and other information (such as trace
status) got from the remote target into Common Trace Format (CTF).
static void
ctf_save_metadata_header (struct trace_write_handler *handler)
{
- const char metadata_fmt[] =
- "\ntrace {\n"
- " major = %u;\n"
- " minor = %u;\n"
- " byte_order = %s;\n" /* be or le */
- " packet.header := struct {\n"
- " uint32_t magic;\n"
- " };\n"
- "};\n"
- "\n"
- "stream {\n"
- " packet.context := struct {\n"
- " uint32_t content_size;\n"
- " uint32_t packet_size;\n"
- " uint16_t tpnum;\n"
- " };\n"
- " event.header := struct {\n"
- " uint32_t id;\n"
- " };\n"
- "};\n";
-
ctf_save_write_metadata (handler, "/* CTF %d.%d */\n",
CTF_SAVE_MAJOR, CTF_SAVE_MINOR);
ctf_save_write_metadata (handler,
#define HOST_ENDIANNESS "le"
#endif
- ctf_save_write_metadata (handler, metadata_fmt,
+ ctf_save_write_metadata (handler,
+ "\ntrace {\n"
+ " major = %u;\n"
+ " minor = %u;\n"
+ " byte_order = %s;\n"
+ " packet.header := struct {\n"
+ " uint32_t magic;\n"
+ " };\n"
+ "};\n"
+ "\n"
+ "stream {\n"
+ " packet.context := struct {\n"
+ " uint32_t content_size;\n"
+ " uint32_t packet_size;\n"
+ " uint16_t tpnum;\n"
+ " };\n"
+ " event.header := struct {\n"
+ " uint32_t id;\n"
+ " };\n"
+ "};\n",
CTF_SAVE_MAJOR, CTF_SAVE_MINOR,
HOST_ENDIANNESS);
ctf_save_write_metadata (handler, "\n");
return 0;
}
-#ifdef USE_WIN32API
-#undef mkdir
-#define mkdir(pathname, mode) mkdir (pathname)
-#endif
-
/* This is the implementation of trace_file_write_ops method
start. It creates the directory DIRNAME, metadata and datastream
in the directory. */
static void
ctf_start (struct trace_file_writer *self, const char *dirname)
{
- char *file_name;
- struct cleanup *old_chain;
struct ctf_trace_file_writer *writer
= (struct ctf_trace_file_writer *) self;
int i;
memset (&writer->tcs, '\0', sizeof (writer->tcs));
- file_name = xstrprintf ("%s/%s", dirname, CTF_METADATA_NAME);
- old_chain = make_cleanup (xfree, file_name);
+ std::string file_name = string_printf ("%s/%s", dirname, CTF_METADATA_NAME);
- writer->tcs.metadata_fd = fopen (file_name, "w");
+ writer->tcs.metadata_fd = fopen (file_name.c_str (), "w");
if (writer->tcs.metadata_fd == NULL)
error (_("Unable to open file '%s' for saving trace data (%s)"),
- file_name, safe_strerror (errno));
- do_cleanups (old_chain);
+ file_name.c_str (), safe_strerror (errno));
ctf_save_metadata_header (&writer->tcs);
- file_name = xstrprintf ("%s/%s", dirname, CTF_DATASTREAM_NAME);
- old_chain = make_cleanup (xfree, file_name);
- writer->tcs.datastream_fd = fopen (file_name, "w");
+ file_name = string_printf ("%s/%s", dirname, CTF_DATASTREAM_NAME);
+ writer->tcs.datastream_fd = fopen (file_name.c_str (), "w");
if (writer->tcs.datastream_fd == NULL)
error (_("Unable to open file '%s' for saving trace data (%s)"),
- file_name, safe_strerror (errno));
- do_cleanups (old_chain);
+ file_name.c_str (), safe_strerror (errno));
}
/* This is the implementation of trace_file_write_ops method
}
+/* This is the implementation of trace_file_write_ops method
+ write_tdesc. */
+
+static void
+ctf_write_tdesc (struct trace_file_writer *self)
+{
+ /* Nothing so far. */
+}
+
/* This is the implementation of trace_file_write_ops method
write_definition_end. */
ctf_write_status,
ctf_write_uploaded_tsv,
ctf_write_uploaded_tp,
+ ctf_write_tdesc,
ctf_write_definition_end,
NULL,
&ctf_write_frame_ops,
struct trace_file_writer *
ctf_trace_file_writer_new (void)
{
- struct ctf_trace_file_writer *writer
- = xmalloc (sizeof (struct ctf_trace_file_writer));
+ struct ctf_trace_file_writer *writer = XNEW (struct ctf_trace_file_writer);
writer->base.ops = &ctf_write_ops;
(SCOPE), \
#FIELD))
+#define SET_ENUM_FIELD(EVENT, SCOPE, VAR, TYPE, FIELD) \
+ (VAR)->FIELD = (TYPE) bt_ctf_get_int64 (bt_ctf_get_field ((EVENT), \
+ (SCOPE), \
+ #FIELD))
+
+
/* EVENT is the "status" event and TS is filled in. */
static void
const struct bt_definition *scope
= bt_ctf_get_top_level_scope (event, BT_EVENT_FIELDS);
- SET_INT32_FIELD (event, scope, ts, stop_reason);
+ SET_ENUM_FIELD (event, scope, ts, enum trace_stop_reason, stop_reason);
SET_INT32_FIELD (event, scope, ts, stopping_tracepoint);
SET_INT32_FIELD (event, scope, ts, traceframe_count);
SET_INT32_FIELD (event, scope, ts, traceframes_created);
SET_INT32_FIELD (event, scope, utp, step);
SET_INT32_FIELD (event, scope, utp, pass);
SET_INT32_FIELD (event, scope, utp, hit_count);
- SET_INT32_FIELD (event, scope, utp, type);
+ SET_ENUM_FIELD (event, scope, utp, enum bptype, type);
/* Read 'cmd_strings'. */
SET_ARRAY_FIELD (event, scope, utp, cmd_num, cmd_strings);
{
/* We're only doing regular memory for now. */
if (object != TARGET_OBJECT_MEMORY)
- return -1;
+ return TARGET_XFER_E_IO;
if (readbuf == NULL)
error (_("ctf_xfer_partial: trace file is read-only"));
gdb_byte *contents;
int k;
- contents = xmalloc (mlen);
+ contents = (gdb_byte *) xmalloc (mlen);
for (k = 0; k < mlen; k++)
{
and this address falls within a read-only section, fallback
to reading from executable, up to LOW_ADDR_AVAILABLE */
if (offset < low_addr_available)
- len = min (len, low_addr_available - offset);
+ len = std::min (len, low_addr_available - offset);
res = exec_read_partial_read_only (readbuf, offset, len, xfered_len);
if (res == TARGET_XFER_OK)
struct tracepoint *tp
= get_tracepoint_by_number_on_target (tpnum);
- if (tp && tp->base.loc)
- addr = tp->base.loc->address;
+ if (tp && tp->loc)
+ addr = tp->loc->address;
}
/* Restore the position. */
frame, extract memory range information, and return them in
traceframe_info. */
-static struct traceframe_info *
+static traceframe_info_up
ctf_traceframe_info (struct target_ops *self)
{
- struct traceframe_info *info = XCNEW (struct traceframe_info);
+ traceframe_info_up info (new traceframe_info);
const char *name;
struct bt_iter_pos *pos;
= bt_ctf_get_top_level_scope (event,
BT_EVENT_FIELDS);
const struct bt_definition *def;
- struct mem_range *r;
- r = VEC_safe_push (mem_range_s, info->memory, NULL);
def = bt_ctf_get_field (event, scope, "address");
- r->start = bt_ctf_get_uint64 (def);
+ CORE_ADDR start = bt_ctf_get_uint64 (def);
def = bt_ctf_get_field (event, scope, "length");
- r->length = (uint16_t) bt_ctf_get_uint64 (def);
+ int length = (uint16_t) bt_ctf_get_uint64 (def);
+
+ info->memory.emplace_back (start, length);
}
else if (strcmp (name, "tsv") == 0)
{
const struct bt_definition *def;
def = bt_ctf_get_field (event, scope, "num");
- vnum = (int) bt_ctf_get_int64 (def);
- VEC_safe_push (int, info->tvars, vnum);
+ vnum = (int) bt_ctf_get_uint64 (def);
+ info->tvars.push_back (vnum);
}
else
{
#endif
-/* -Wmissing-prototypes */
-
-extern initialize_file_ftype _initialize_ctf;
-
/* module initialization */
void
projects / deliverable / binutils-gdb.git / blobdiff