X-Git-Url: http://git.efficios.com/?p=babeltrace.git;a=blobdiff_plain;f=src%2Fplugins%2Fctf%2Ffs-sink%2Ftranslate-ctf-ir-to-tsdl.c;h=85f6bee7e51b27c02c6a6ef5f3b220a8a94ad345;hp=fd0d10f243f13037b2591f9fe88093bda0615355;hb=0235b0db7de5bcacdb3650c92461f2ce5eb2143d;hpb=9c08c816a55bbc538957648b49d41354e43c7cdf diff --git a/src/plugins/ctf/fs-sink/translate-ctf-ir-to-tsdl.c b/src/plugins/ctf/fs-sink/translate-ctf-ir-to-tsdl.c index fd0d10f2..85f6bee7 100644 --- a/src/plugins/ctf/fs-sink/translate-ctf-ir-to-tsdl.c +++ b/src/plugins/ctf/fs-sink/translate-ctf-ir-to-tsdl.c @@ -1,25 +1,11 @@ /* - * Copyright 2019 Philippe Proulx - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. + * SPDX-License-Identifier: MIT * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - * SOFTWARE. + * Copyright 2019 Philippe Proulx */ +#include "translate-ctf-ir-to-tsdl.h" + #include #include "common/macros.h" #include @@ -136,7 +122,7 @@ void append_integer_field_class_from_props(struct ctx *ctx, unsigned int size, g_string_append(ctx->tsdl, "x"); break; default: - abort(); + bt_common_abort(); } g_string_append_c(ctx->tsdl, ';'); @@ -181,17 +167,45 @@ void append_end_block_semi_nl_nl(struct ctx *ctx) g_string_append_c(ctx->tsdl, '\n'); } +static +void append_bool_field_class(struct ctx *ctx, + __attribute__((unused)) struct fs_sink_ctf_field_class_bool *fc) +{ + /* + * CTF 1.8 has no boolean field class type, so this component + * translates it to an 8-bit unsigned integer field class. + */ + append_integer_field_class_from_props(ctx, fc->base.size, + fc->base.base.alignment, false, + BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL, + NULL, NULL, false); +} + +static +void append_bit_array_field_class(struct ctx *ctx, + struct fs_sink_ctf_field_class_bit_array *fc) +{ + /* + * CTF 1.8 has no bit array field class type, so this component + * translates it to an unsigned integer field class with an + * hexadecimal base. + */ + append_integer_field_class_from_props(ctx, fc->size, + fc->base.alignment, false, + BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_HEXADECIMAL, + NULL, NULL, false); +} + static void append_integer_field_class(struct ctx *ctx, struct fs_sink_ctf_field_class_int *fc) { const bt_field_class *ir_fc = fc->base.base.ir_fc; bt_field_class_type type = bt_field_class_get_type(ir_fc); - bool is_signed = type == BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION || - type == BT_FIELD_CLASS_TYPE_SIGNED_INTEGER; + bool is_signed = bt_field_class_type_is(type, + BT_FIELD_CLASS_TYPE_SIGNED_INTEGER); - if (type == BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION || - type == BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION) { + if (bt_field_class_type_is(type, BT_FIELD_CLASS_TYPE_ENUMERATION)) { g_string_append(ctx->tsdl, "enum : "); } @@ -200,8 +214,7 @@ void append_integer_field_class(struct ctx *ctx, bt_field_class_integer_get_preferred_display_base(ir_fc), NULL, NULL, false); - if (type == BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION || - type == BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION) { + if (bt_field_class_type_is(type, BT_FIELD_CLASS_TYPE_ENUMERATION)) { uint64_t i; g_string_append(ctx->tsdl, " {\n"); @@ -305,7 +318,8 @@ void append_float_field_class(struct ctx *ctx, { unsigned int mant_dig, exp_dig; - if (bt_field_class_real_is_single_precision(fc->base.base.ir_fc)) { + if (bt_field_class_get_type(fc->base.base.ir_fc) == + BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL) { mant_dig = 24; exp_dig = 8; } else { @@ -335,6 +349,8 @@ void append_member(struct ctx *ctx, const char *name, GString *lengths = NULL; const char *lengths_str = ""; + BT_ASSERT(fc); + while (fc->type == FS_SINK_CTF_FIELD_CLASS_TYPE_ARRAY || fc->type == FS_SINK_CTF_FIELD_CLASS_TYPE_SEQUENCE) { if (!lengths) { @@ -384,6 +400,11 @@ void append_struct_field_class_members(struct ctx *ctx, struct_fc, i); struct fs_sink_ctf_field_class *fc = named_fc->fc; + /* + * For sequence, option, and variant field classes, if + * the length/tag field class is generated before, write + * it now before the dependent field class. + */ if (fc->type == FS_SINK_CTF_FIELD_CLASS_TYPE_SEQUENCE) { struct fs_sink_ctf_field_class_sequence *seq_fc = (void *) fc; @@ -395,6 +416,42 @@ void append_struct_field_class_members(struct ctx *ctx, BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL, NULL, seq_fc->length_ref->str, true); } + } else if (fc->type == FS_SINK_CTF_FIELD_CLASS_TYPE_OPTION) { + struct fs_sink_ctf_field_class_option *opt_fc = + (void *) fc; + + /* + * CTF 1.8 does not support the option field + * class type. To write something anyway, this + * component translates this type to a variant + * field class where the options are: + * + * * An empty structure field class. + * * The optional field class itself. + * + * The "tag" is always generated/before in that + * case (an 8-bit unsigned enumeration field + * class). + */ + append_indent(ctx); + g_string_append(ctx->tsdl, + "/* The enumeration and variant field classes " + "below were a trace IR option field class. */\n"); + append_indent(ctx); + g_string_append(ctx->tsdl, "enum : "); + append_integer_field_class_from_props(ctx, + 8, 8, false, + BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL, + NULL, NULL, false); + g_string_append(ctx->tsdl, " {\n"); + ctx->indent_level++; + append_indent(ctx); + g_string_append(ctx->tsdl, "none = 0,\n"); + append_indent(ctx); + g_string_append(ctx->tsdl, "content = 1,\n"); + append_end_block(ctx); + g_string_append_printf(ctx->tsdl, " %s;\n", + opt_fc->tag_ref->str); } else if (fc->type == FS_SINK_CTF_FIELD_CLASS_TYPE_VARIANT) { struct fs_sink_ctf_field_class_variant *var_fc = (void *) fc; @@ -410,20 +467,28 @@ void append_struct_field_class_members(struct ctx *ctx, ctx->indent_level++; for (i = 0; i < var_fc->options->len; i++) { - struct fs_sink_ctf_named_field_class *named_fc = + struct fs_sink_ctf_named_field_class *option_named_fc = fs_sink_ctf_field_class_variant_borrow_option_by_index( var_fc, i); append_indent(ctx); g_string_append_printf(ctx->tsdl, "\"%s\" = %" PRIu64 ",\n", - named_fc->name->str, i); + option_named_fc->name->str, i); } append_end_block(ctx); g_string_append_printf(ctx->tsdl, " %s;\n", var_fc->tag_ref->str); } + } else if (fc->type == FS_SINK_CTF_FIELD_CLASS_TYPE_BOOL) { + append_indent(ctx); + g_string_append(ctx->tsdl, + "/* The integer field class below was a trace IR boolean field class. */\n"); + } else if (fc->type == FS_SINK_CTF_FIELD_CLASS_TYPE_BIT_ARRAY) { + append_indent(ctx); + g_string_append(ctx->tsdl, + "/* The integer field class below was a trace IR bit array field class. */\n"); } append_indent(ctx); @@ -443,6 +508,20 @@ void append_struct_field_class(struct ctx *ctx, fc->base.alignment); } +static +void append_option_field_class(struct ctx *ctx, + struct fs_sink_ctf_field_class_option *opt_fc) +{ + g_string_append_printf(ctx->tsdl, "variant <%s> {\n", + opt_fc->tag_ref->str); + ctx->indent_level++; + append_indent(ctx); + g_string_append(ctx->tsdl, "struct { } none;\n"); + append_indent(ctx); + append_member(ctx, "content", opt_fc->content_fc); + append_end_block(ctx); +} + static void append_variant_field_class(struct ctx *ctx, struct fs_sink_ctf_field_class_variant *var_fc) @@ -469,6 +548,12 @@ static void append_field_class(struct ctx *ctx, struct fs_sink_ctf_field_class *fc) { switch (fc->type) { + case FS_SINK_CTF_FIELD_CLASS_TYPE_BOOL: + append_bool_field_class(ctx, (void *) fc); + break; + case FS_SINK_CTF_FIELD_CLASS_TYPE_BIT_ARRAY: + append_bit_array_field_class(ctx, (void *) fc); + break; case FS_SINK_CTF_FIELD_CLASS_TYPE_INT: append_integer_field_class(ctx, (void *) fc); break; @@ -481,11 +566,14 @@ void append_field_class(struct ctx *ctx, struct fs_sink_ctf_field_class *fc) case FS_SINK_CTF_FIELD_CLASS_TYPE_STRUCT: append_struct_field_class(ctx, (void *) fc); break; + case FS_SINK_CTF_FIELD_CLASS_TYPE_OPTION: + append_option_field_class(ctx, (void *) fc); + break; case FS_SINK_CTF_FIELD_CLASS_TYPE_VARIANT: append_variant_field_class(ctx, (void *) fc); break; default: - abort(); + bt_common_abort(); } } @@ -579,7 +667,7 @@ void append_event_class(struct ctx *ctx, struct fs_sink_ctf_event_class *ec) level = 14; break; default: - abort(); + bt_common_abort(); } g_string_append_printf(ctx->tsdl, "%u;\n", level); @@ -872,7 +960,7 @@ void translate_trace_ctf_ir_to_tsdl(struct fs_sink_ctf_trace *trace, * This is checked in * translate_trace_trace_ir_to_ctf_ir(). */ - abort(); + bt_common_abort(); } g_string_append(tsdl, ";\n");