X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=formats%2Fctf%2Fir%2Fevent-types.c;h=9d2bd39b0a108b8239ba9b649f9cb38e19ae16f4;hb=32fe3f28047342b3b0ad04ce0c03bfb97e11127f;hp=703e708e228cde046aa7c74c6982b37cb92295b3;hpb=6c827042b878570fc8418a7d3c99b2657c2541da;p=babeltrace.git diff --git a/formats/ctf/ir/event-types.c b/formats/ctf/ir/event-types.c index 703e708e..9d2bd39b 100644 --- a/formats/ctf/ir/event-types.c +++ b/formats/ctf/ir/event-types.c @@ -29,6 +29,8 @@ #include #include #include +#include +#include #include #include #include @@ -52,26 +54,26 @@ struct range_overlap_query { }; static -void bt_ctf_field_type_destroy(struct bt_ctf_ref *); +void bt_ctf_field_type_destroy(struct bt_ref *); static -void bt_ctf_field_type_integer_destroy(struct bt_ctf_ref *); +void bt_ctf_field_type_integer_destroy(struct bt_ctf_field_type *); static -void bt_ctf_field_type_enumeration_destroy(struct bt_ctf_ref *); +void bt_ctf_field_type_enumeration_destroy(struct bt_ctf_field_type *); static -void bt_ctf_field_type_floating_point_destroy(struct bt_ctf_ref *); +void bt_ctf_field_type_floating_point_destroy(struct bt_ctf_field_type *); static -void bt_ctf_field_type_structure_destroy(struct bt_ctf_ref *); +void bt_ctf_field_type_structure_destroy(struct bt_ctf_field_type *); static -void bt_ctf_field_type_variant_destroy(struct bt_ctf_ref *); +void bt_ctf_field_type_variant_destroy(struct bt_ctf_field_type *); static -void bt_ctf_field_type_array_destroy(struct bt_ctf_ref *); +void bt_ctf_field_type_array_destroy(struct bt_ctf_field_type *); static -void bt_ctf_field_type_sequence_destroy(struct bt_ctf_ref *); +void bt_ctf_field_type_sequence_destroy(struct bt_ctf_field_type *); static -void bt_ctf_field_type_string_destroy(struct bt_ctf_ref *); +void bt_ctf_field_type_string_destroy(struct bt_ctf_field_type *); static -void (* const type_destroy_funcs[])(struct bt_ctf_ref *) = { +void (* const type_destroy_funcs[])(struct bt_ctf_field_type *) = { [CTF_TYPE_INTEGER] = bt_ctf_field_type_integer_destroy, [CTF_TYPE_ENUM] = bt_ctf_field_type_enumeration_destroy, @@ -291,19 +293,23 @@ gint compare_enumeration_mappings_unsigned(struct enumeration_mapping **a, } static -void bt_ctf_field_type_init(struct bt_ctf_field_type *type) +void bt_ctf_field_type_init(struct bt_ctf_field_type *type, int init_bo) { enum ctf_type_id type_id = type->declaration->id; - int ret; assert(type && (type_id > CTF_TYPE_UNKNOWN) && (type_id < NR_CTF_TYPES)); - bt_ctf_ref_init(&type->ref_count); + bt_ctf_base_init(type, bt_ctf_field_type_destroy); type->freeze = type_freeze_funcs[type_id]; type->serialize = type_serialize_funcs[type_id]; - ret = bt_ctf_field_type_set_byte_order(type, BT_CTF_BYTE_ORDER_NATIVE); - assert(!ret); + + if (init_bo) { + int ret = bt_ctf_field_type_set_byte_order(type, + BT_CTF_BYTE_ORDER_NATIVE); + assert(!ret); + } + type->declaration->alignment = 1; } @@ -342,23 +348,25 @@ end: } static -void bt_ctf_field_type_destroy(struct bt_ctf_ref *ref) +void bt_ctf_field_type_destroy(struct bt_ref *ref) { struct bt_ctf_field_type *type; + struct bt_ctf_base *base; enum ctf_type_id type_id; if (!ref) { return; } - type = container_of(ref, struct bt_ctf_field_type, ref_count); + base = container_of(ref, struct bt_ctf_base, ref_count); + type = container_of(base, struct bt_ctf_field_type, base); type_id = type->declaration->id; if (type_id <= CTF_TYPE_UNKNOWN || type_id >= NR_CTF_TYPES) { return; } - type_destroy_funcs[type_id](ref); + type_destroy_funcs[type_id](type); } BT_HIDDEN @@ -424,7 +432,7 @@ struct bt_ctf_field_type *bt_ctf_field_type_integer_create(unsigned int size) integer->declaration.len = size; integer->declaration.base = BT_CTF_INTEGER_BASE_DECIMAL; integer->declaration.encoding = CTF_STRING_NONE; - bt_ctf_field_type_init(&integer->parent); + bt_ctf_field_type_init(&integer->parent, TRUE); return &integer->parent; } @@ -628,7 +636,7 @@ struct bt_ctf_field_type *bt_ctf_field_type_enumeration_create( enumeration->container = integer_container_type; enumeration->entries = g_ptr_array_new_with_free_func( (GDestroyNotify)destroy_enumeration_mapping); - bt_ctf_field_type_init(&enumeration->parent); + bt_ctf_field_type_init(&enumeration->parent, FALSE); return &enumeration->parent; error: g_free(enumeration); @@ -1033,7 +1041,7 @@ struct bt_ctf_field_type *bt_ctf_field_type_floating_point_create(void) floating_point->mantissa.p.alignment = 1; floating_point->exp.p.alignment = 1; - bt_ctf_field_type_init(&floating_point->parent); + bt_ctf_field_type_init(&floating_point->parent, TRUE); end: return floating_point ? &floating_point->parent : NULL; } @@ -1144,7 +1152,7 @@ struct bt_ctf_field_type *bt_ctf_field_type_structure_create(void) structure->fields = g_ptr_array_new_with_free_func( (GDestroyNotify)destroy_structure_field); structure->field_name_to_index = g_hash_table_new(NULL, NULL); - bt_ctf_field_type_init(&structure->parent); + bt_ctf_field_type_init(&structure->parent, TRUE); return &structure->parent; error: return NULL; @@ -1285,7 +1293,7 @@ struct bt_ctf_field_type *bt_ctf_field_type_variant_create( struct bt_ctf_field_type_enumeration, parent); } - bt_ctf_field_type_init(&variant->parent); + bt_ctf_field_type_init(&variant->parent, TRUE); /* A variant's alignment is undefined */ variant->parent.declaration->alignment = 0; return &variant->parent; @@ -1530,7 +1538,7 @@ struct bt_ctf_field_type *bt_ctf_field_type_array_create( bt_ctf_field_type_get(element_type); array->element_type = element_type; array->length = length; - bt_ctf_field_type_init(&array->parent); + bt_ctf_field_type_init(&array->parent, FALSE); return &array->parent; error: return NULL; @@ -1590,7 +1598,7 @@ struct bt_ctf_field_type *bt_ctf_field_type_sequence_create( bt_ctf_field_type_get(element_type); sequence->element_type = element_type; sequence->length_field_name = g_string_new(length_field_name); - bt_ctf_field_type_init(&sequence->parent); + bt_ctf_field_type_init(&sequence->parent, FALSE); return &sequence->parent; error: return NULL; @@ -1642,7 +1650,7 @@ struct bt_ctf_field_type *bt_ctf_field_type_string_create(void) string->parent.declaration = &string->declaration.p; string->parent.declaration->id = CTF_TYPE_STRING; - bt_ctf_field_type_init(&string->parent); + bt_ctf_field_type_init(&string->parent, TRUE); string->declaration.encoding = CTF_STRING_UTF8; string->parent.declaration->alignment = CHAR_BIT; return &string->parent; @@ -1776,14 +1784,20 @@ end: return ret; } +static inline +int is_power_of_two(unsigned int value) +{ + return ((value & (value - 1)) == 0) && value > 0; +} + int bt_ctf_field_type_set_alignment(struct bt_ctf_field_type *type, unsigned int alignment) { int ret = 0; enum ctf_type_id type_id; - /* Alignment must be bit-aligned (1) or byte aligned */ - if (!type || type->frozen || (alignment != 1 && (alignment & 0x7))) { + /* Alignment must be a power of two */ + if (!type || type->frozen || !is_power_of_two(alignment)) { ret = -1; goto end; } @@ -1800,8 +1814,8 @@ int bt_ctf_field_type_set_alignment(struct bt_ctf_field_type *type, goto end; } - if (type_id == CTF_TYPE_STRUCT || type_id == CTF_TYPE_VARIANT || - type_id == CTF_TYPE_SEQUENCE || type_id == CTF_TYPE_ARRAY) { + if (type_id == CTF_TYPE_VARIANT || type_id == CTF_TYPE_SEQUENCE || + type_id == CTF_TYPE_ARRAY) { /* Setting an alignment on these types makes no sense */ ret = -1; goto end; @@ -1910,20 +1924,12 @@ enum ctf_type_id bt_ctf_field_type_get_type_id( void bt_ctf_field_type_get(struct bt_ctf_field_type *type) { - if (!type) { - return; - } - - bt_ctf_ref_get(&type->ref_count); + bt_ctf_get(type); } void bt_ctf_field_type_put(struct bt_ctf_field_type *type) { - if (!type) { - return; - } - - bt_ctf_ref_put(&type->ref_count, bt_ctf_field_type_destroy); + bt_ctf_put(type); } BT_HIDDEN @@ -2215,6 +2221,18 @@ end: return ret; } +BT_HIDDEN +struct bt_ctf_field_path *bt_ctf_field_type_sequence_get_length_field_path( + struct bt_ctf_field_type *type) +{ + struct bt_ctf_field_type_sequence *sequence; + + sequence = container_of(type, struct bt_ctf_field_type_sequence, + parent); + + return sequence->length_field_path; +} + BT_HIDDEN int bt_ctf_field_type_variant_set_tag_field_path(struct bt_ctf_field_type *type, struct bt_ctf_field_path *path) @@ -2237,6 +2255,18 @@ end: return ret; } +BT_HIDDEN +struct bt_ctf_field_path *bt_ctf_field_type_variant_get_tag_field_path( + struct bt_ctf_field_type *type) +{ + struct bt_ctf_field_type_variant *variant; + + variant = container_of(type, struct bt_ctf_field_type_variant, + parent); + + return variant->tag_path; +} + BT_HIDDEN int bt_ctf_field_type_variant_set_tag(struct bt_ctf_field_type *type, struct bt_ctf_field_type *tag) @@ -2292,17 +2322,15 @@ end: } static -void bt_ctf_field_type_integer_destroy(struct bt_ctf_ref *ref) +void bt_ctf_field_type_integer_destroy(struct bt_ctf_field_type *type) { - struct bt_ctf_field_type_integer *integer; + struct bt_ctf_field_type_integer *integer = + (struct bt_ctf_field_type_integer *) type; - if (!ref) { + if (!type) { return; } - integer = container_of( - container_of(ref, struct bt_ctf_field_type, ref_count), - struct bt_ctf_field_type_integer, parent); if (integer->mapped_clock) { bt_ctf_clock_put(integer->mapped_clock); } @@ -2310,66 +2338,58 @@ void bt_ctf_field_type_integer_destroy(struct bt_ctf_ref *ref) } static -void bt_ctf_field_type_enumeration_destroy(struct bt_ctf_ref *ref) +void bt_ctf_field_type_enumeration_destroy(struct bt_ctf_field_type *type) { - struct bt_ctf_field_type_enumeration *enumeration; + struct bt_ctf_field_type_enumeration *enumeration = + (struct bt_ctf_field_type_enumeration *) type; - if (!ref) { + if (!type) { return; } - enumeration = container_of( - container_of(ref, struct bt_ctf_field_type, ref_count), - struct bt_ctf_field_type_enumeration, parent); g_ptr_array_free(enumeration->entries, TRUE); bt_ctf_field_type_put(enumeration->container); g_free(enumeration); } static -void bt_ctf_field_type_floating_point_destroy(struct bt_ctf_ref *ref) +void bt_ctf_field_type_floating_point_destroy(struct bt_ctf_field_type *type) { - struct bt_ctf_field_type_floating_point *floating_point; + struct bt_ctf_field_type_floating_point *floating_point = + (struct bt_ctf_field_type_floating_point *) type; - if (!ref) { + if (!type) { return; } - floating_point = container_of( - container_of(ref, struct bt_ctf_field_type, ref_count), - struct bt_ctf_field_type_floating_point, parent); g_free(floating_point); } static -void bt_ctf_field_type_structure_destroy(struct bt_ctf_ref *ref) +void bt_ctf_field_type_structure_destroy(struct bt_ctf_field_type *type) { - struct bt_ctf_field_type_structure *structure; + struct bt_ctf_field_type_structure *structure = + (struct bt_ctf_field_type_structure *) type; - if (!ref) { + if (!type) { return; } - structure = container_of( - container_of(ref, struct bt_ctf_field_type, ref_count), - struct bt_ctf_field_type_structure, parent); g_ptr_array_free(structure->fields, TRUE); g_hash_table_destroy(structure->field_name_to_index); g_free(structure); } static -void bt_ctf_field_type_variant_destroy(struct bt_ctf_ref *ref) +void bt_ctf_field_type_variant_destroy(struct bt_ctf_field_type *type) { - struct bt_ctf_field_type_variant *variant; + struct bt_ctf_field_type_variant *variant = + (struct bt_ctf_field_type_variant *) type; - if (!ref) { + if (!type) { return; } - variant = container_of( - container_of(ref, struct bt_ctf_field_type, ref_count), - struct bt_ctf_field_type_variant, parent); g_ptr_array_free(variant->fields, TRUE); g_hash_table_destroy(variant->field_name_to_index); g_string_free(variant->tag_name, TRUE); @@ -2379,33 +2399,29 @@ void bt_ctf_field_type_variant_destroy(struct bt_ctf_ref *ref) } static -void bt_ctf_field_type_array_destroy(struct bt_ctf_ref *ref) +void bt_ctf_field_type_array_destroy(struct bt_ctf_field_type *type) { - struct bt_ctf_field_type_array *array; + struct bt_ctf_field_type_array *array = + (struct bt_ctf_field_type_array *) type; - if (!ref) { + if (!type) { return; } - array = container_of( - container_of(ref, struct bt_ctf_field_type, ref_count), - struct bt_ctf_field_type_array, parent); bt_ctf_field_type_put(array->element_type); g_free(array); } static -void bt_ctf_field_type_sequence_destroy(struct bt_ctf_ref *ref) +void bt_ctf_field_type_sequence_destroy(struct bt_ctf_field_type *type) { - struct bt_ctf_field_type_sequence *sequence; + struct bt_ctf_field_type_sequence *sequence = + (struct bt_ctf_field_type_sequence *) type; - if (!ref) { + if (!type) { return; } - sequence = container_of( - container_of(ref, struct bt_ctf_field_type, ref_count), - struct bt_ctf_field_type_sequence, parent); bt_ctf_field_type_put(sequence->element_type); g_string_free(sequence->length_field_name, TRUE); bt_ctf_field_path_destroy(sequence->length_field_path); @@ -2413,17 +2429,15 @@ void bt_ctf_field_type_sequence_destroy(struct bt_ctf_ref *ref) } static -void bt_ctf_field_type_string_destroy(struct bt_ctf_ref *ref) +void bt_ctf_field_type_string_destroy(struct bt_ctf_field_type *type) { - struct bt_ctf_field_type_string *string; + struct bt_ctf_field_type_string *string = + (struct bt_ctf_field_type_string *) type; - if (!ref) { + if (!type) { return; } - string = container_of( - container_of(ref, struct bt_ctf_field_type, ref_count), - struct bt_ctf_field_type_string, parent); g_free(string); }