#include <glib.h>
#include <inttypes.h>
#include <errno.h>
-#include <babeltrace/ctf/metadata.h>
-#include <babeltrace/compat/uuid.h>
-#include <babeltrace/endian.h>
+#include <babeltrace/compat/uuid-internal.h>
+#include <babeltrace/endian-internal.h>
#include <babeltrace/ref.h>
-#include <babeltrace/ctf/events-internal.h>
#include <babeltrace/ctf-ir/trace.h>
#include <babeltrace/ctf-ir/stream-class.h>
#include <babeltrace/ctf-ir/event.h>
#include <babeltrace/ctf-ir/event-class.h>
#include <babeltrace/ctf-ir/field-types.h>
#include <babeltrace/ctf-ir/field-types-internal.h>
-#include <babeltrace/ctf-ir/clock.h>
+#include <babeltrace/ctf-ir/clock-class.h>
#include "scanner.h"
#include "parser.h"
/* Error printing wrappers */
#define _PERROR(_fmt, ...) \
do { \
+ if (!ctx->efd) break; \
fprintf(ctx->efd, "[error] %s: " _fmt "\n", \
__func__, __VA_ARGS__); \
} while (0)
#define _PWARNING(_fmt, ...) \
do { \
+ if (!ctx->efd) break; \
fprintf(ctx->efd, "[warning] %s: " _fmt "\n", \
__func__, __VA_ARGS__); \
} while (0)
#define _FPERROR(_stream, _fmt, ...) \
do { \
+ if (!_stream) break; \
fprintf(_stream, "[error] %s: " _fmt "\n", \
__func__, __VA_ARGS__); \
} while (0)
#define _FPWARNING(_stream, _fmt, ...) \
do { \
+ if (!_stream) break; \
fprintf(_stream, "[warning] %s: " _fmt "\n", \
__func__, __VA_ARGS__); \
} while (0)
#define _PERROR_DUP_ATTR(_attr, _entity) \
do { \
+ if (!ctx->efd) break; \
fprintf(ctx->efd, \
"[error] %s: duplicate attribute \"" \
_attr "\" in " _entity "\n", __func__); \
};
/*
- * Visitor context.
+ * Visitor context (private).
*/
struct ctx {
- /* Trace being filled (weak ref.) */
+ /* Trace being filled (owned by this) */
struct bt_ctf_trace *trace;
/* Error stream to use during visit */
/* 1 if trace declaration is visited */
int is_trace_visited;
+ /* 1 if this is an LTTng trace */
+ bool is_lttng;
+
+ /* Offset (ns) to apply to clock classes on creation */
+ uint64_t clock_class_offset_ns;
+
/* Trace attributes */
+ enum bt_ctf_byte_order trace_bo;
uint64_t trace_major;
uint64_t trace_minor;
unsigned char trace_uuid[BABELTRACE_UUID_LEN];
GHashTable *stream_classes;
};
+/*
+ * Visitor (public).
+ */
+struct ctf_visitor_generate_ir { };
+
static
const char *loglevel_str [] = {
[ LOGLEVEL_EMERG ] = "TRACE_EMERG",
* @returns New visitor context, or NULL on error
*/
static
-struct ctx *ctx_create(struct bt_ctf_trace *trace, FILE *efd)
+struct ctx *ctx_create(struct bt_ctf_trace *trace, FILE *efd,
+ uint64_t clock_class_offset_ns)
{
struct ctx *ctx = NULL;
struct ctx_decl_scope *scope = NULL;
- ctx = g_new(struct ctx, 1);
+ ctx = g_new0(struct ctx, 1);
if (!ctx) {
goto error;
}
ctx->trace = trace;
ctx->efd = efd;
ctx->current_scope = scope;
- ctx->is_trace_visited = FALSE;
-
+ ctx->trace_bo = BT_CTF_BYTE_ORDER_NATIVE;
+ ctx->clock_class_offset_ns = clock_class_offset_ns;
return ctx;
error:
g_free(ctx);
ctx_decl_scope_destroy(scope);
-
return NULL;
}
scope = parent_scope;
}
+ bt_put(ctx->trace);
g_hash_table_destroy(ctx->stream_classes);
g_free(ctx);
int signedness = 0;
struct ctf_node *expression;
uint64_t alignment = 0, size = 0;
- struct bt_ctf_clock *mapped_clock = NULL;
+ struct bt_ctf_clock_class *mapped_clock = NULL;
enum bt_ctf_string_encoding encoding = BT_CTF_STRING_ENCODING_NONE;
enum bt_ctf_integer_base base = BT_CTF_INTEGER_BASE_DECIMAL;
enum bt_ctf_byte_order byte_order =
goto error;
}
- _PWARNING("invalid \"map\" attribute in integer declaration: unknown clock: \"%s\"",
+ _PWARNING("invalid \"map\" attribute in integer declaration: unknown clock class: \"%s\"",
s_right);
_SET(&set, _INTEGER_MAP_SET);
g_free(s_right);
continue;
}
- mapped_clock = bt_ctf_trace_get_clock_by_name(
+ mapped_clock = bt_ctf_trace_get_clock_class_by_name(
ctx->trace, clock_name);
if (!mapped_clock) {
- _PERROR("invalid \"map\" attribute in integer declaration: cannot find clock \"%s\"",
+ _PERROR("invalid \"map\" attribute in integer declaration: cannot find clock class \"%s\"",
clock_name);
ret = -EINVAL;
goto error;
if (mapped_clock) {
/* Move clock */
- ret |= bt_ctf_field_type_integer_set_mapped_clock(
+ ret |= bt_ctf_field_type_integer_set_mapped_clock_class(
*integer_decl, mapped_clock);
bt_put(mapped_clock);
mapped_clock = NULL;
char *event_name = NULL;
struct bt_ctf_event_class *event_class = NULL;
struct bt_ctf_event_class *eevent_class;
- struct bt_ctf_stream_class *stream_class;
+ struct bt_ctf_stream_class *stream_class = NULL;
struct bt_list_head *decl_list = &node->u.event.declaration_list;
+ bool pop_scope = false;
if (node->visited) {
goto end;
goto error;
}
-
ret = ctx_push_scope(ctx);
if (ret) {
_PERROR("%s", "cannot push scope");
goto error;
}
+ pop_scope = true;
+
bt_list_for_each_entry(iter, decl_list, siblings) {
ret = visit_event_decl_entry(ctx, iter, event_class,
&stream_id, &set);
if (!_IS_SET(&set, _EVENT_STREAM_ID_SET)) {
GList *keys = NULL;
struct bt_ctf_stream_class *new_stream_class;
+ size_t stream_class_count =
+ g_hash_table_size(ctx->stream_classes) +
+ bt_ctf_trace_get_stream_class_count(ctx->trace);
- /* Allow missing stream_id if there is only a single stream */
- switch (g_hash_table_size(ctx->stream_classes)) {
+ /*
+ * Allow missing stream_id if there is only a single
+ * stream class.
+ */
+ switch (stream_class_count) {
case 0:
- /* Create stream if there's none */
+ /* Create implicit stream class if there's none */
new_stream_class = create_reset_stream_class(ctx);
if (!new_stream_class) {
ret = -EINVAL;
ret = bt_ctf_stream_class_set_id(new_stream_class, 0);
if (ret) {
- _PERROR("%s", "cannot set stream's ID");
+ _PERROR("%s", "cannot set stream class's ID");
BT_PUT(new_stream_class);
goto error;
}
g_hash_table_insert(ctx->stream_classes,
(gpointer) stream_id, new_stream_class);
new_stream_class = NULL;
-
break;
case 1:
- /* Single stream: get its ID */
- keys = g_hash_table_get_keys(ctx->stream_classes);
- stream_id = (int64_t) keys->data;
- g_list_free(keys);
- keys = NULL;
+ /* Single stream class: get its ID */
+ if (g_hash_table_size(ctx->stream_classes) == 1) {
+ keys = g_hash_table_get_keys(ctx->stream_classes);
+ stream_id = (int64_t) keys->data;
+ g_list_free(keys);
+ } else {
+ assert(bt_ctf_trace_get_stream_class_count(
+ ctx->trace) == 1);
+ stream_class =
+ bt_ctf_trace_get_stream_class_by_index(
+ ctx->trace, 0);
+ assert(stream_class);
+ stream_id = bt_ctf_stream_class_get_id(
+ stream_class);
+ BT_PUT(stream_class);
+ }
break;
default:
_PERROR("%s", "missing \"stream_id\" attribute in event declaration");
}
}
-
-
assert(stream_id >= 0);
- /* We have the stream ID now; borrow the stream class if found */
+ /* We have the stream ID now; get the stream class if found */
stream_class = g_hash_table_lookup(ctx->stream_classes,
(gpointer) stream_id);
+ bt_get(stream_class);
if (!stream_class) {
- _PERROR("cannot find stream class with ID %" PRId64,
+ stream_class = bt_ctf_trace_get_stream_class_by_id(ctx->trace,
stream_id);
- ret = -EINVAL;
- goto error;
+ if (!stream_class) {
+ _PERROR("cannot find stream class with ID %" PRId64,
+ stream_id);
+ ret = -EINVAL;
+ goto error;
+ }
}
+ assert(stream_class);
+
if (!_IS_SET(&set, _EVENT_ID_SET)) {
/* Allow only one event without ID per stream */
if (bt_ctf_stream_class_get_event_class_count(stream_class) !=
event_name);
if (eevent_class) {
BT_PUT(eevent_class);
- eevent_class = NULL;
_PERROR("%s",
"duplicate event with name \"%s\" in same stream");
ret = -EEXIST;
goto error;
}
- g_free(event_name);
ret = bt_ctf_stream_class_add_event_class(stream_class, event_class);
BT_PUT(event_class);
- event_class = NULL;
-
if (ret) {
_PERROR("%s", "cannot add event class to stream class");
goto error;
}
-end:
- return 0;
+ goto end;
error:
- g_free(event_name);
- BT_PUT(event_class);
+ bt_put(event_class);
- /* stream_class is borrowed; it still belongs to the hash table */
+end:
+ if (pop_scope) {
+ ctx_pop_scope(ctx);
+ }
+ g_free(event_name);
+ bt_put(stream_class);
return ret;
}
int ret = 0;
struct ctf_node *iter;
struct bt_ctf_stream_class *stream_class = NULL;
+ struct bt_ctf_stream_class *existing_stream_class = NULL;
struct bt_list_head *decl_list = &node->u.stream.declaration_list;
if (node->visited) {
goto error;
}
+ /*
+ * Make sure that this stream class's ID is currently unique in
+ * the trace.
+ */
+ if (g_hash_table_lookup(ctx->stream_classes, (gpointer) id)) {
+ _PERROR("a stream class with ID: %" PRId64 " already exists in the trace", id);
+ ret = -EINVAL;
+ goto error;
+ }
+
+ existing_stream_class = bt_ctf_trace_get_stream_class_by_id(ctx->trace,
+ id);
+ if (existing_stream_class) {
+ _PERROR("a stream class with ID: %" PRId64 " already exists in the trace", id);
+ ret = -EINVAL;
+ goto error;
+ }
+
/* Move reference to visitor's context */
g_hash_table_insert(ctx->stream_classes, (gpointer) (int64_t) id,
stream_class);
stream_class = NULL;
-
-end:
- return 0;
+ goto end;
error:
- BT_PUT(stream_class);
+ bt_put(stream_class);
+end:
+ bt_put(existing_stream_class);
return ret;
}
goto error;
}
+ if (strcmp(left, "tracer_name") == 0) {
+ if (strncmp(right, "lttng", 5) == 0) {
+ ctx->is_lttng = 1;
+ }
+ }
+
printf_verbose("env.%s = \"%s\"\n", left, right);
ret = bt_ctf_trace_set_environment_field_string(
ctx->trace, left, right);
goto error;
}
- ret = bt_ctf_trace_set_byte_order(
+ ctx->trace_bo = bo;
+ ret = bt_ctf_trace_set_native_byte_order(
ctx->trace, bo);
if (ret) {
_PERROR("cannot set trace's byte order (%d)",
static
int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node,
- struct bt_ctf_clock *clock, int *set)
+ struct bt_ctf_clock_class *clock, int *set)
{
int ret = 0;
char *left = NULL;
char *right;
if (_IS_SET(set, _CLOCK_NAME_SET)) {
- _PERROR_DUP_ATTR("name", "clock declaration");
+ _PERROR_DUP_ATTR("name", "clock class declaration");
ret = -EPERM;
goto error;
}
right = concatenate_unary_strings(
&entry_node->u.ctf_expression.right);
if (!right) {
- _PERROR("%s", "unexpected unary expression for clock declaration's \"name\" attribute");
+ _PERROR("%s", "unexpected unary expression for clock class declaration's \"name\" attribute");
ret = -EINVAL;
goto error;
}
- ret = bt_ctf_clock_set_name(clock, right);
+ ret = bt_ctf_clock_class_set_name(clock, right);
if (ret) {
- _PERROR("%s", "cannot set clock's name");
+ _PERROR("%s", "cannot set clock class's name");
g_free(right);
goto error;
}
unsigned char uuid[BABELTRACE_UUID_LEN];
if (_IS_SET(set, _CLOCK_UUID_SET)) {
- _PERROR_DUP_ATTR("uuid", "clock declaration");
+ _PERROR_DUP_ATTR("uuid", "clock class declaration");
ret = -EPERM;
goto error;
}
ret = get_unary_uuid(&entry_node->u.ctf_expression.right, uuid);
if (ret) {
- _PERROR("%s", "invalid clock UUID");
+ _PERROR("%s", "invalid clock class UUID");
goto error;
}
- ret = bt_ctf_clock_set_uuid(clock, uuid);
+ ret = bt_ctf_clock_class_set_uuid(clock, uuid);
if (ret) {
- _PERROR("%s", "cannot set clock's UUID");
+ _PERROR("%s", "cannot set clock class's UUID");
goto error;
}
char *right;
if (_IS_SET(set, _CLOCK_DESCRIPTION_SET)) {
- _PERROR_DUP_ATTR("description", "clock declaration");
+ _PERROR_DUP_ATTR("description", "clock class declaration");
ret = -EPERM;
goto error;
}
right = concatenate_unary_strings(
&entry_node->u.ctf_expression.right);
if (!right) {
- _PERROR("%s", "unexpected unary expression for clock's \"description\" attribute");
+ _PERROR("%s", "unexpected unary expression for clock class's \"description\" attribute");
ret = -EINVAL;
goto error;
}
- ret = bt_ctf_clock_set_description(clock, right);
+ ret = bt_ctf_clock_class_set_description(clock, right);
if (ret) {
- _PERROR("%s", "cannot set clock's description");
+ _PERROR("%s", "cannot set clock class's description");
g_free(right);
goto error;
}
uint64_t freq;
if (_IS_SET(set, _CLOCK_FREQ_SET)) {
- _PERROR_DUP_ATTR("freq", "clock declaration");
+ _PERROR_DUP_ATTR("freq", "clock class declaration");
ret = -EPERM;
goto error;
}
ret = get_unary_unsigned(
&entry_node->u.ctf_expression.right, &freq);
if (ret) {
- _PERROR("%s", "unexpected unary expression for clock declaration's \"freq\" attribute");
+ _PERROR("%s", "unexpected unary expression for clock class declaration's \"freq\" attribute");
ret = -EINVAL;
goto error;
}
- ret = bt_ctf_clock_set_frequency(clock, freq);
+ ret = bt_ctf_clock_class_set_frequency(clock, freq);
if (ret) {
- _PERROR("%s", "cannot set clock's frequency");
+ _PERROR("%s", "cannot set clock class's frequency");
goto error;
}
uint64_t precision;
if (_IS_SET(set, _CLOCK_PRECISION_SET)) {
- _PERROR_DUP_ATTR("precision", "clock declaration");
+ _PERROR_DUP_ATTR("precision", "clock class declaration");
ret = -EPERM;
goto error;
}
ret = get_unary_unsigned(
&entry_node->u.ctf_expression.right, &precision);
if (ret) {
- _PERROR("%s", "unexpected unary expression for clock declaration's \"precision\" attribute");
+ _PERROR("%s", "unexpected unary expression for clock class declaration's \"precision\" attribute");
ret = -EINVAL;
goto error;
}
- ret = bt_ctf_clock_set_precision(clock, precision);
+ ret = bt_ctf_clock_class_set_precision(clock, precision);
if (ret) {
- _PERROR("%s", "cannot set clock's precision");
+ _PERROR("%s", "cannot set clock class's precision");
goto error;
}
uint64_t offset_s;
if (_IS_SET(set, _CLOCK_OFFSET_S_SET)) {
- _PERROR_DUP_ATTR("offset_s", "clock declaration");
+ _PERROR_DUP_ATTR("offset_s", "clock class declaration");
ret = -EPERM;
goto error;
}
ret = get_unary_unsigned(
&entry_node->u.ctf_expression.right, &offset_s);
if (ret) {
- _PERROR("%s", "unexpected unary expression for clock declaration's \"offset_s\" attribute");
+ _PERROR("%s", "unexpected unary expression for clock class declaration's \"offset_s\" attribute");
ret = -EINVAL;
goto error;
}
- ret = bt_ctf_clock_set_offset_s(clock, offset_s);
+ ret = bt_ctf_clock_class_set_offset_s(clock, offset_s);
if (ret) {
- _PERROR("%s", "cannot set clock's offset in seconds");
+ _PERROR("%s", "cannot set clock class's offset in seconds");
goto error;
}
uint64_t offset;
if (_IS_SET(set, _CLOCK_OFFSET_SET)) {
- _PERROR_DUP_ATTR("offset", "clock declaration");
+ _PERROR_DUP_ATTR("offset", "clock class declaration");
ret = -EPERM;
goto error;
}
ret = get_unary_unsigned(
&entry_node->u.ctf_expression.right, &offset);
if (ret) {
- _PERROR("%s", "unexpected unary expression for clock declaration's \"offset\" attribute");
+ _PERROR("%s", "unexpected unary expression for clock class declaration's \"offset\" attribute");
ret = -EINVAL;
goto error;
}
- ret = bt_ctf_clock_set_offset(clock, offset);
+ ret = bt_ctf_clock_class_set_offset_cycles(clock, offset);
if (ret) {
- _PERROR("%s", "cannot set clock's offset in cycles");
+ _PERROR("%s", "cannot set clock class's offset in cycles");
goto error;
}
struct ctf_node *right;
if (_IS_SET(set, _CLOCK_ABSOLUTE_SET)) {
- _PERROR_DUP_ATTR("absolute", "clock declaration");
+ _PERROR_DUP_ATTR("absolute", "clock class declaration");
ret = -EPERM;
goto error;
}
struct ctf_node, siblings);
ret = get_boolean(ctx->efd, right);
if (ret < 0) {
- _PERROR("%s", "unexpected unary expression for clock declaration's \"absolute\" attribute");
+ _PERROR("%s", "unexpected unary expression for clock class declaration's \"absolute\" attribute");
ret = -EINVAL;
goto error;
}
- ret = bt_ctf_clock_set_is_absolute(clock, ret);
+ ret = bt_ctf_clock_class_set_is_absolute(clock, ret);
if (ret) {
- _PERROR("%s", "cannot set clock's absolute option");
+ _PERROR("%s", "cannot set clock class's absolute option");
goto error;
}
_SET(set, _CLOCK_ABSOLUTE_SET);
} else {
- _PWARNING("unknown attribute \"%s\" in clock declaration",
+ _PWARNING("unknown attribute \"%s\" in clock class declaration",
left);
}
return ret;
}
+static
+uint64_t cycles_from_ns(uint64_t frequency, uint64_t ns)
+{
+ uint64_t cycles;
+
+ /* 1GHz */
+ if (frequency == 1000000000ULL) {
+ cycles = ns;
+ } else {
+ cycles = (uint64_t) (((double) ns * (double) frequency) / 1e9);
+ }
+
+ return cycles;
+}
+
+static
+int apply_clock_class_offset(struct ctx *ctx, struct bt_ctf_clock_class *clock)
+{
+ int ret;
+ uint64_t freq;
+ int64_t offset_cycles;
+
+ freq = bt_ctf_clock_class_get_frequency(clock);
+ if (freq == -1ULL) {
+ _PERROR("%s", "cannot get clock class frequency");
+ ret = -1;
+ goto end;
+ }
+
+ ret = bt_ctf_clock_class_get_offset_cycles(clock, &offset_cycles);
+ if (ret) {
+ _PERROR("%s", "cannot get offset in cycles");
+ ret = -1;
+ goto end;
+ }
+
+ offset_cycles += cycles_from_ns(freq, ctx->clock_class_offset_ns);
+ ret = bt_ctf_clock_class_set_offset_cycles(clock, offset_cycles);
+
+end:
+ return ret;
+}
+
static
int visit_clock_decl(struct ctx *ctx, struct ctf_node *clock_node)
{
int ret = 0;
int set = 0;
- struct bt_ctf_clock *clock;
+ struct bt_ctf_clock_class *clock;
struct ctf_node *entry_node;
struct bt_list_head *decl_list = &clock_node->u.clock.declaration_list;
+ const char *clock_class_name;
if (clock_node->visited) {
return 0;
}
clock_node->visited = TRUE;
- clock = bt_ctf_clock_create(NULL);
+ clock = bt_ctf_clock_class_create(NULL);
if (!clock) {
_PERROR("%s", "cannot create clock");
ret = -ENOMEM;
if (!_IS_SET(&set, _CLOCK_NAME_SET)) {
_PERROR("%s",
- "missing \"name\" attribute in clock declaration");
+ "missing \"name\" attribute in clock class declaration");
ret = -EPERM;
goto error;
}
- if (bt_ctf_trace_get_clock_count(ctx->trace) != 0) {
- _PERROR("%s", "only CTF traces with a single clock declaration are supported as of this version");
- ret = -EINVAL;
+ clock_class_name = bt_ctf_clock_class_get_name(clock);
+ assert(clock_class_name);
+ if (ctx->is_lttng && strcmp(clock_class_name, "monotonic") == 0) {
+ /*
+ * Old versions of LTTng forgot to set its clock class
+ * as absolute, even if it is. This is important because
+ * it's a condition to be able to sort notifications
+ * from different sources.
+ */
+ ret = bt_ctf_clock_class_set_is_absolute(clock, 1);
+ if (ret) {
+ _PERROR("%s", "cannot set clock class's absolute option");
+ goto error;
+ }
+ }
+
+ ret = apply_clock_class_offset(ctx, clock);
+ if (ret) {
+ _PERROR("%s", "cannot apply clock class offset ");
goto error;
}
- ret = bt_ctf_trace_add_clock(ctx->trace, clock);
+ ret = bt_ctf_trace_add_clock_class(ctx->trace, clock);
if (ret) {
- _PERROR("%s", "cannot add clock to trace");
+ _PERROR("%s", "cannot add clock class to trace");
goto error;
}
}
static
-int add_stream_classes_to_trace(struct ctx *ctx)
+int move_ctx_stream_classes_to_trace(struct ctx *ctx)
{
int ret;
GHashTableIter iter;
}
}
+ g_hash_table_remove_all(ctx->stream_classes);
+
end:
return ret;
}
-int ctf_visitor_generate_ir(FILE *efd, struct ctf_node *node,
- struct bt_ctf_trace **trace)
+BT_HIDDEN
+struct ctf_visitor_generate_ir *ctf_visitor_generate_ir_create(FILE *efd,
+ uint64_t clock_class_offset_ns)
{
- int ret = 0;
+ int ret;
struct ctx *ctx = NULL;
+ struct bt_ctf_trace *trace;
- printf_verbose("CTF visitor: AST -> CTF IR...\n");
-
- *trace = bt_ctf_trace_create();
- if (!*trace) {
+ trace = bt_ctf_trace_create();
+ if (!trace) {
_FPERROR(efd, "%s", "cannot create trace");
- ret = -ENOMEM;
goto error;
}
/* Set packet header to NULL to override the default one */
- ret = bt_ctf_trace_set_packet_header_type(*trace, NULL);
+ ret = bt_ctf_trace_set_packet_header_type(trace, NULL);
if (ret) {
- _FPERROR(efd,
- "%s",
+ _FPERROR(efd, "%s",
"cannot set initial, empty packet header structure");
goto error;
}
- ctx = ctx_create(*trace, efd);
+ /* Create visitor's context */
+ ctx = ctx_create(trace, efd, clock_class_offset_ns);
if (!ctx) {
_FPERROR(efd, "%s", "cannot create visitor context");
- ret = -ENOMEM;
goto error;
}
+ trace = NULL;
+ goto end;
+
+error:
+ ctx_destroy(ctx);
+ ctx = NULL;
+
+end:
+ bt_put(trace);
+ return (void *) ctx;
+}
+
+BT_HIDDEN
+void ctf_visitor_generate_ir_destroy(struct ctf_visitor_generate_ir *visitor)
+{
+ ctx_destroy((void *) visitor);
+}
+
+BT_HIDDEN
+struct bt_ctf_trace *ctf_visitor_generate_ir_get_trace(
+ struct ctf_visitor_generate_ir *visitor)
+{
+ struct ctx *ctx = (void *) visitor;
+
+ assert(ctx);
+ assert(ctx->trace);
+ return bt_get(ctx->trace);
+}
+
+BT_HIDDEN
+int ctf_visitor_generate_ir_visit_node(struct ctf_visitor_generate_ir *visitor,
+ struct ctf_node *node)
+{
+ int ret = 0;
+ struct ctx *ctx = (void *) visitor;
+
+ printf_verbose("CTF visitor: AST -> CTF IR...\n");
+
switch (node->type) {
case NODE_ROOT:
{
int found_callsite = FALSE;
/*
- * Find trace declaration's byte order first (for early
- * type aliases).
+ * The first thing we need is the native byte order of
+ * the trace block, because early type aliases can have
+ * a `byte_order` attribute set to `native`. If we don't
+ * have the native byte order yet, and we don't have any
+ * trace block yet, then fail with EINCOMPLETE.
*/
- bt_list_for_each_entry(iter, &node->u.root.trace, siblings) {
- if (got_trace_decl) {
- _PERROR("%s", "duplicate trace declaration");
- goto error;
+ if (ctx->trace_bo == BT_CTF_BYTE_ORDER_NATIVE) {
+ bt_list_for_each_entry(iter, &node->u.root.trace, siblings) {
+ if (got_trace_decl) {
+ _PERROR("%s", "duplicate trace declaration");
+ ret = -1;
+ goto end;
+ }
+
+ ret = set_trace_byte_order(ctx, iter);
+ if (ret) {
+ _PERROR("cannot set trace's native byte order (%d)",
+ ret);
+ goto end;
+ }
+
+ got_trace_decl = TRUE;
+ }
+
+ if (!got_trace_decl) {
+ ret = -EINCOMPLETE;
+ goto end;
}
+ }
+
+ assert(ctx->trace_bo == BT_CTF_BYTE_ORDER_LITTLE_ENDIAN ||
+ ctx->trace_bo == BT_CTF_BYTE_ORDER_BIG_ENDIAN);
+ assert(ctx->current_scope &&
+ ctx->current_scope->parent_scope == NULL);
- ret = set_trace_byte_order(ctx, iter);
+ /* Environment */
+ bt_list_for_each_entry(iter, &node->u.root.env, siblings) {
+ ret = visit_env(ctx, iter);
if (ret) {
- _PERROR("cannot set trace's byte order (%d)",
+ _PERROR("error while visiting environment block (%d)",
ret);
- goto error;
+ goto end;
}
-
- got_trace_decl = TRUE;
}
- if (!got_trace_decl) {
- _PERROR("no trace declaration found (%d)", ret);
- ret = -EPERM;
- goto error;
- }
+ assert(ctx->current_scope &&
+ ctx->current_scope->parent_scope == NULL);
/*
- * Visit clocks first since any early integer can be mapped
- * to one.
+ * Visit clock blocks.
*/
bt_list_for_each_entry(iter, &node->u.root.clock, siblings) {
ret = visit_clock_decl(ctx, iter);
if (ret) {
- _PERROR("error while visiting clock declaration (%d)",
+ _PERROR("error while visiting clock class declaration (%d)",
ret);
- goto error;
+ goto end;
}
}
+ assert(ctx->current_scope &&
+ ctx->current_scope->parent_scope == NULL);
+
/*
* Visit root declarations next, as they can be used by any
* following entity.
if (ret) {
_PERROR("error while visiting root declaration (%d)",
ret);
- goto error;
+ goto end;
}
}
- /* Callsite are not supported */
+ assert(ctx->current_scope &&
+ ctx->current_scope->parent_scope == NULL);
+
+ /* Callsite blocks are not supported */
bt_list_for_each_entry(iter, &node->u.root.callsite, siblings) {
found_callsite = TRUE;
break;
}
+ assert(ctx->current_scope &&
+ ctx->current_scope->parent_scope == NULL);
+
if (found_callsite) {
_PWARNING("%s", "\"callsite\" blocks are not supported as of this version");
}
- /* Environment */
- bt_list_for_each_entry(iter, &node->u.root.env, siblings) {
- ret = visit_env(ctx, iter);
- if (ret) {
- _PERROR("error while visiting environment block (%d)",
- ret);
- goto error;
- }
- }
-
/* Trace */
bt_list_for_each_entry(iter, &node->u.root.trace, siblings) {
ret = visit_trace_decl(ctx, iter);
if (ret) {
_PERROR("%s", "error while visiting trace declaration");
- goto error;
+ goto end;
}
}
+ assert(ctx->current_scope &&
+ ctx->current_scope->parent_scope == NULL);
+
/* Streams */
bt_list_for_each_entry(iter, &node->u.root.stream, siblings) {
ret = visit_stream_decl(ctx, iter);
if (ret) {
_PERROR("%s", "error while visiting stream declaration");
- goto error;
+ goto end;
}
}
+ assert(ctx->current_scope &&
+ ctx->current_scope->parent_scope == NULL);
+
/* Events */
bt_list_for_each_entry(iter, &node->u.root.event, siblings) {
ret = visit_event_decl(ctx, iter);
if (ret) {
_PERROR("%s", "error while visiting event declaration");
- goto error;
+ goto end;
}
}
+
+ assert(ctx->current_scope &&
+ ctx->current_scope->parent_scope == NULL);
break;
}
- case NODE_UNKNOWN:
default:
- _PERROR("unknown node type: %d", (int) node->type);
+ _PERROR("cannot decode node type: %d", (int) node->type);
ret = -EINVAL;
- goto error;
+ goto end;
}
- /* Add stream classes to trace now */
- ret = add_stream_classes_to_trace(ctx);
+ /* Move decoded stream classes to trace, if any */
+ ret = move_ctx_stream_classes_to_trace(ctx);
if (ret) {
- _PERROR("%s", "cannot add stream classes to trace");
+ _PERROR("%s", "cannot move stream classes to trace");
}
- ctx_destroy(ctx);
- printf_verbose("done!\n");
-
- return ret;
-
-error:
- ctx_destroy(ctx);
- BT_PUT(*trace);
-
+end:
return ret;
}
projects / babeltrace.git / blobdiff