#include <inttypes.h>
#include <stdlib.h>
#include <stdio.h>
+#include <stdbool.h>
#include <side/trace.h>
static
void tracer_print_dynamic(const struct side_arg_dynamic_vec *dynamic_item);
+static
+void tracer_print_attr_type(const struct side_attr *attr)
+{
+ printf("{ key: \"%s\", value: ", attr->key);
+ switch (attr->value.type) {
+ case SIDE_ATTR_TYPE_BOOL:
+ printf("%s", attr->value.u.side_bool ? "true" : "false");
+ break;
+ case SIDE_ATTR_TYPE_U8:
+ printf("%" PRIu8, attr->value.u.side_u8);
+ break;
+ case SIDE_ATTR_TYPE_U16:
+ printf("%" PRIu16, attr->value.u.side_u16);
+ break;
+ case SIDE_ATTR_TYPE_U32:
+ printf("%" PRIu32, attr->value.u.side_u32);
+ break;
+ case SIDE_ATTR_TYPE_U64:
+ printf("%" PRIu64, attr->value.u.side_u64);
+ break;
+ case SIDE_ATTR_TYPE_S8:
+ printf("%" PRId8, attr->value.u.side_s8);
+ break;
+ case SIDE_ATTR_TYPE_S16:
+ printf("%" PRId16, attr->value.u.side_s16);
+ break;
+ case SIDE_ATTR_TYPE_S32:
+ printf("%" PRId32, attr->value.u.side_s32);
+ break;
+ case SIDE_ATTR_TYPE_S64:
+ printf("%" PRId64, attr->value.u.side_s64);
+ break;
+ case SIDE_ATTR_TYPE_FLOAT_BINARY16:
+#if __HAVE_FLOAT16
+ printf("%g", (double) attr->value.u.side_float_binary16);
+ break;
+#else
+ printf("ERROR: Unsupported binary16 float type\n");
+ abort();
+#endif
+ case SIDE_ATTR_TYPE_FLOAT_BINARY32:
+#if __HAVE_FLOAT32
+ printf("%g", (double) attr->value.u.side_float_binary32);
+ break;
+#else
+ printf("ERROR: Unsupported binary32 float type\n");
+ abort();
+#endif
+ case SIDE_ATTR_TYPE_FLOAT_BINARY64:
+#if __HAVE_FLOAT64
+ printf("%g", (double) attr->value.u.side_float_binary64);
+ break;
+#else
+ printf("ERROR: Unsupported binary64 float type\n");
+ abort();
+#endif
+ case SIDE_ATTR_TYPE_FLOAT_BINARY128:
+#if __HAVE_FLOAT128
+ printf("%Lg", (long double) attr->value.u.side_float_binary128);
+ break;
+#else
+ printf("ERROR: Unsupported binary128 float type\n");
+ abort();
+#endif
+ case SIDE_ATTR_TYPE_STRING:
+ printf("\"%s\"", attr->value.u.string);
+ break;
+ default:
+ printf("<UNKNOWN TYPE>");
+ abort();
+ }
+ printf(" }");
+}
+
+static
+void print_attributes(const char *prefix_str, const struct side_attr *attr, uint32_t nr_attr)
+{
+ int i;
+
+ if (!nr_attr)
+ return;
+ printf("%s[ ", prefix_str);
+ for (i = 0; i < nr_attr; i++) {
+ printf("%s", i ? ", " : "");
+ tracer_print_attr_type(&attr[i]);
+ }
+ printf(" ]");
+}
+
+static
+void print_enum(const struct side_enum_mappings *side_enum_mappings, int64_t value)
+{
+ int i, print_count = 0;
+
+ printf("%" PRId64 ", labels: [ ", value);
+ for (i = 0; i < side_enum_mappings->nr_mappings; i++) {
+ const struct side_enum_mapping *mapping = &side_enum_mappings->mappings[i];
+
+ if (mapping->range_end < mapping->range_begin) {
+ printf("ERROR: Unexpected enum range: %" PRIu64 "-%" PRIu64 "\n",
+ mapping->range_begin, mapping->range_end);
+ abort();
+ }
+ if (value >= mapping->range_begin && value <= mapping->range_end) {
+ printf("%s", print_count++ ? ", " : "");
+ printf("\"%s\"", mapping->label);
+ }
+ }
+ if (!print_count)
+ printf("<NO LABEL>");
+ printf(" ]");
+}
+
+static
+void print_enum_bitmap(const struct side_enum_mappings *side_enum_mappings, uint64_t value)
+{
+ int i, print_count = 0;
+
+ printf("0x%" PRIx64 ", labels: [ ", value);
+ for (i = 0; i < side_enum_mappings->nr_mappings; i++) {
+ const struct side_enum_mapping *mapping = &side_enum_mappings->mappings[i];
+ bool match = false;
+ int64_t bit;
+
+ if (mapping->range_begin < 0 || mapping->range_end > 63
+ || mapping->range_end < mapping->range_begin) {
+ printf("ERROR: Unexpected enum bitmap range: %" PRIu64 "-%" PRIu64 "\n",
+ mapping->range_begin, mapping->range_end);
+ abort();
+ }
+ for (bit = mapping->range_begin; bit <= mapping->range_end; bit++) {
+ if (value & (1ULL << bit)) {
+ match = true;
+ break;
+ }
+ }
+ if (match) {
+ printf("%s", print_count++ ? ", " : "");
+ printf("\"%s\"", mapping->label);
+ }
+ }
+ if (!print_count)
+ printf("<NO LABEL>");
+ printf(" ]");
+}
+
static
void tracer_print_type(const struct side_type_description *type_desc, const struct side_arg_vec *item)
{
}
break;
}
+ printf("{ ");
+ print_attributes("attr: ", type_desc->attr, type_desc->nr_attr);
+ printf("%s", type_desc->nr_attr ? ", " : "");
+ printf("value: ");
switch (item->type) {
case SIDE_TYPE_BOOL:
printf("%s", item->u.side_bool ? "true" : "false");
case SIDE_TYPE_S64:
printf("%" PRId64, item->u.side_s64);
break;
+
+ case SIDE_TYPE_ENUM_U8:
+ print_enum(type_desc->u.side_enum_mappings,
+ (int64_t) item->u.side_u8);
+ break;
+ case SIDE_TYPE_ENUM_U16:
+ print_enum(type_desc->u.side_enum_mappings,
+ (int64_t) item->u.side_u16);
+ break;
+ case SIDE_TYPE_ENUM_U32:
+ print_enum(type_desc->u.side_enum_mappings,
+ (int64_t) item->u.side_u32);
+ break;
+ case SIDE_TYPE_ENUM_U64:
+ print_enum(type_desc->u.side_enum_mappings,
+ (int64_t) item->u.side_u64);
+ break;
+ case SIDE_TYPE_ENUM_S8:
+ print_enum(type_desc->u.side_enum_mappings,
+ (int64_t) item->u.side_s8);
+ break;
+ case SIDE_TYPE_ENUM_S16:
+ print_enum(type_desc->u.side_enum_mappings,
+ (int64_t) item->u.side_s16);
+ break;
+ case SIDE_TYPE_ENUM_S32:
+ print_enum(type_desc->u.side_enum_mappings,
+ (int64_t) item->u.side_s32);
+ break;
+ case SIDE_TYPE_ENUM_S64:
+ print_enum(type_desc->u.side_enum_mappings,
+ item->u.side_s64);
+ break;
+
+ case SIDE_TYPE_ENUM_BITMAP8:
+ print_enum_bitmap(type_desc->u.side_enum_mappings,
+ (uint64_t) item->u.side_u8);
+ break;
+ case SIDE_TYPE_ENUM_BITMAP16:
+ print_enum_bitmap(type_desc->u.side_enum_mappings,
+ (uint64_t) item->u.side_u16);
+ break;
+ case SIDE_TYPE_ENUM_BITMAP32:
+ print_enum_bitmap(type_desc->u.side_enum_mappings,
+ (uint64_t) item->u.side_u32);
+ break;
+ case SIDE_TYPE_ENUM_BITMAP64:
+ print_enum_bitmap(type_desc->u.side_enum_mappings,
+ item->u.side_u64);
+ break;
+
+ case SIDE_TYPE_FLOAT_BINARY16:
+#if __HAVE_FLOAT16
+ printf("%g", (double) item->u.side_float_binary16);
+ break;
+#else
+ printf("ERROR: Unsupported binary16 float type\n");
+ abort();
+#endif
+ case SIDE_TYPE_FLOAT_BINARY32:
+#if __HAVE_FLOAT32
+ printf("%g", (double) item->u.side_float_binary32);
+ break;
+#else
+ printf("ERROR: Unsupported binary32 float type\n");
+ abort();
+#endif
+ case SIDE_TYPE_FLOAT_BINARY64:
+#if __HAVE_FLOAT64
+ printf("%g", (double) item->u.side_float_binary64);
+ break;
+#else
+ printf("ERROR: Unsupported binary64 float type\n");
+ abort();
+#endif
+ case SIDE_TYPE_FLOAT_BINARY128:
+#if __HAVE_FLOAT128
+ printf("%Lg", (long double) item->u.side_float_binary128);
+ break;
+#else
+ printf("ERROR: Unsupported binary128 float type\n");
+ abort();
+#endif
case SIDE_TYPE_STRING:
printf("\"%s\"", item->u.string);
break;
printf("<UNKNOWN TYPE>");
abort();
}
+ printf(" }");
}
static
printf(" ]");
}
+struct tracer_dynamic_struct_visitor_priv {
+ int i;
+};
+
+static
+enum side_visitor_status tracer_dynamic_struct_write_elem_cb(
+ const struct side_tracer_dynamic_struct_visitor_ctx *tracer_ctx,
+ const struct side_arg_dynamic_event_field *dynamic_field)
+{
+ struct tracer_dynamic_struct_visitor_priv *tracer_priv = tracer_ctx->priv;
+
+ printf("%s", tracer_priv->i++ ? ", " : "");
+ printf("%s:: ", dynamic_field->field_name);
+ tracer_print_dynamic(&dynamic_field->elem);
+ return SIDE_VISITOR_STATUS_OK;
+}
+
static
void tracer_print_dynamic_struct_visitor(const struct side_arg_dynamic_vec *item)
{
- //TODO
+ enum side_visitor_status status;
+ struct tracer_dynamic_struct_visitor_priv tracer_priv = {
+ .i = 0,
+ };
+ const struct side_tracer_dynamic_struct_visitor_ctx tracer_ctx = {
+ .write_field = tracer_dynamic_struct_write_elem_cb,
+ .priv = &tracer_priv,
+ };
+ void *app_ctx = item->u.side_dynamic_struct_visitor.app_ctx;
+
+ printf("[ ");
+ status = item->u.side_dynamic_struct_visitor.visitor(&tracer_ctx, app_ctx);
+ switch (status) {
+ case SIDE_VISITOR_STATUS_OK:
+ break;
+ case SIDE_VISITOR_STATUS_ERROR:
+ printf("ERROR: Visitor error\n");
+ abort();
+ }
+ printf(" ]");
}
static
abort();
}
printf(" ]");
-
}
static
void tracer_print_dynamic(const struct side_arg_dynamic_vec *item)
{
+ printf("{ ");
+ print_attributes("attr:: ", item->attr, item->nr_attr);
+ printf("%s", item->nr_attr ? ", " : "");
+ printf("value: ");
switch (item->dynamic_type) {
case SIDE_DYNAMIC_TYPE_NULL:
printf("<NULL TYPE>");
case SIDE_DYNAMIC_TYPE_S64:
printf("%" PRId64, item->u.side_s64);
break;
+ case SIDE_DYNAMIC_TYPE_FLOAT_BINARY16:
+#if __HAVE_FLOAT16
+ printf("%g", (double) item->u.side_float_binary16);
+ break;
+#else
+ printf("ERROR: Unsupported binary16 float type\n");
+ abort();
+#endif
+ case SIDE_DYNAMIC_TYPE_FLOAT_BINARY32:
+#if __HAVE_FLOAT32
+ printf("%g", (double) item->u.side_float_binary32);
+ break;
+#else
+ printf("ERROR: Unsupported binary32 float type\n");
+ abort();
+#endif
+ case SIDE_DYNAMIC_TYPE_FLOAT_BINARY64:
+#if __HAVE_FLOAT64
+ printf("%g", (double) item->u.side_float_binary64);
+ break;
+#else
+ printf("ERROR: Unsupported binary64 float type\n");
+ abort();
+#endif
+ case SIDE_DYNAMIC_TYPE_FLOAT_BINARY128:
+#if __HAVE_FLOAT128
+ printf("%Lg", (long double) item->u.side_float_binary128);
+ break;
+#else
+ printf("ERROR: Unsupported binary128 float type\n");
+ abort();
+#endif
case SIDE_DYNAMIC_TYPE_STRING:
printf("\"%s\"", item->u.string);
break;
printf("<UNKNOWN TYPE>");
abort();
}
+ printf(" }");
}
static
uint32_t side_sav_len = sav_desc->len;
int i;
- printf("provider: %s, event: %s, ", desc->provider_name, desc->event_name);
+ printf("provider: %s, event: %s", desc->provider_name, desc->event_name);
if (desc->nr_fields != side_sav_len) {
printf("ERROR: number of fields mismatch between description and arguments\n");
abort();
}
+ print_attributes(", attributes: ", desc->attr, desc->nr_attr);
+ printf("%s", side_sav_len ? ", fields: [ " : "");
for (i = 0; i < side_sav_len; i++) {
printf("%s", i ? ", " : "");
tracer_print_field(&desc->fields[i], &sav[i]);
void tracer_call(const struct side_event_description *desc, const struct side_arg_vec_description *sav_desc)
{
- if (side_unlikely(desc->flags & SIDE_EVENT_FLAG_VARIADIC)) {
- printf("ERROR: unexpected variadic event description\n");
- abort();
- }
- tracer_print_static_fields(desc, sav_desc, NULL);
+ int nr_fields = 0;
+
+ tracer_print_static_fields(desc, sav_desc, &nr_fields);
+ if (nr_fields)
+ printf(" ]");
printf("\n");
}
printf("ERROR: unexpected non-variadic event description\n");
abort();
}
+ printf("%s", var_struct_len && !nr_fields ? ", fields: [ " : "");
for (i = 0; i < var_struct_len; i++, nr_fields++) {
printf("%s", nr_fields ? ", " : "");
printf("%s:: ", var_struct->fields[i].field_name);
tracer_print_dynamic(&var_struct->fields[i].elem);
}
+ if (i)
+ printf(" ]");
printf("\n");
}
projects / libside.git / blobdiff