lib/ctf-ir/field-types.c

   1 /*
   2  * field-types.c
   3  *
   4  * Babeltrace CTF IR - Event Types
   5  *
   6  * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   7  *
   8  * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a copy
  11  * of this software and associated documentation files (the "Software"), to deal
  12  * in the Software without restriction, including without limitation the rights
  13  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  14  * copies of the Software, and to permit persons to whom the Software is
  15  * furnished to do so, subject to the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be included in
  18  * all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  23  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  25  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  26  * SOFTWARE.
  27  */
  28
  29 #define BT_LOG_TAG "FIELD-TYPES"
  30 #include <babeltrace/lib-logging-internal.h>
  31
  32 #include <babeltrace/ctf-ir/field-types-internal.h>
  33 #include <babeltrace/ctf-ir/field-path-internal.h>
  34 #include <babeltrace/ctf-ir/utils.h>
  35 #include <babeltrace/ref.h>
  36 #include <babeltrace/ctf-ir/clock-class.h>
  37 #include <babeltrace/ctf-ir/clock-class-internal.h>
  38 #include <babeltrace/ctf-writer/writer-internal.h>
  39 #include <babeltrace/object-internal.h>
  40 #include <babeltrace/ref.h>
  41 #include <babeltrace/compiler-internal.h>
  42 #include <babeltrace/endian-internal.h>
  43 #include <float.h>
  44 #include <inttypes.h>
  45 #include <stdlib.h>
  46
  47 struct range_overlap_query {
  48         union {
  49                 uint64_t _unsigned;
  50                 int64_t _signed;
  51         } range_start;
  52
  53         union {
  54                 uint64_t _unsigned;
  55                 int64_t _signed;
  56         } range_end;
  57         int overlaps;
  58         GQuark mapping_name;
  59 };
  60
  61 static
  62 void bt_field_type_destroy(struct bt_object *);
  63 static
  64 void bt_field_type_integer_destroy(struct bt_field_type *);
  65 static
  66 void bt_field_type_enumeration_destroy(struct bt_field_type *);
  67 static
  68 void bt_field_type_floating_point_destroy(struct bt_field_type *);
  69 static
  70 void bt_field_type_structure_destroy(struct bt_field_type *);
  71 static
  72 void bt_field_type_variant_destroy(struct bt_field_type *);
  73 static
  74 void bt_field_type_array_destroy(struct bt_field_type *);
  75 static
  76 void bt_field_type_sequence_destroy(struct bt_field_type *);
  77 static
  78 void bt_field_type_string_destroy(struct bt_field_type *);
  79
  80 static
  81 void (* const type_destroy_funcs[])(struct bt_field_type *) = {
  82         [BT_FIELD_TYPE_ID_INTEGER] = bt_field_type_integer_destroy,
  83         [BT_FIELD_TYPE_ID_ENUM] =
  84                 bt_field_type_enumeration_destroy,
  85         [BT_FIELD_TYPE_ID_FLOAT] =
  86                 bt_field_type_floating_point_destroy,
  87         [BT_FIELD_TYPE_ID_STRUCT] = bt_field_type_structure_destroy,
  88         [BT_FIELD_TYPE_ID_VARIANT] = bt_field_type_variant_destroy,
  89         [BT_FIELD_TYPE_ID_ARRAY] = bt_field_type_array_destroy,
  90         [BT_FIELD_TYPE_ID_SEQUENCE] = bt_field_type_sequence_destroy,
  91         [BT_FIELD_TYPE_ID_STRING] = bt_field_type_string_destroy,
  92 };
  93
  94 static
  95 void generic_field_type_freeze(struct bt_field_type *);
  96 static
  97 void bt_field_type_integer_freeze(struct bt_field_type *);
  98 static
  99 void bt_field_type_enumeration_freeze(struct bt_field_type *);
 100 static
 101 void bt_field_type_structure_freeze(struct bt_field_type *);
 102 static
 103 void bt_field_type_variant_freeze(struct bt_field_type *);
 104 static
 105 void bt_field_type_array_freeze(struct bt_field_type *);
 106 static
 107 void bt_field_type_sequence_freeze(struct bt_field_type *);
 108
 109 static
 110 type_freeze_func const type_freeze_funcs[] = {
 111         [BT_FIELD_TYPE_ID_INTEGER] = bt_field_type_integer_freeze,
 112         [BT_FIELD_TYPE_ID_ENUM] = bt_field_type_enumeration_freeze,
 113         [BT_FIELD_TYPE_ID_FLOAT] = generic_field_type_freeze,
 114         [BT_FIELD_TYPE_ID_STRUCT] = bt_field_type_structure_freeze,
 115         [BT_FIELD_TYPE_ID_VARIANT] = bt_field_type_variant_freeze,
 116         [BT_FIELD_TYPE_ID_ARRAY] = bt_field_type_array_freeze,
 117         [BT_FIELD_TYPE_ID_SEQUENCE] = bt_field_type_sequence_freeze,
 118         [BT_FIELD_TYPE_ID_STRING] = generic_field_type_freeze,
 119 };
 120
 121 static
 122 int bt_field_type_integer_serialize(struct bt_field_type *,
 123                 struct metadata_context *);
 124 static
 125 int bt_field_type_enumeration_serialize(struct bt_field_type *,
 126                 struct metadata_context *);
 127 static
 128 int bt_field_type_floating_point_serialize(
 129                 struct bt_field_type *, struct metadata_context *);
 130 static
 131 int bt_field_type_structure_serialize(struct bt_field_type *,
 132                 struct metadata_context *);
 133 static
 134 int bt_field_type_variant_serialize(struct bt_field_type *,
 135                 struct metadata_context *);
 136 static
 137 int bt_field_type_array_serialize(struct bt_field_type *,
 138                 struct metadata_context *);
 139 static
 140 int bt_field_type_sequence_serialize(struct bt_field_type *,
 141                 struct metadata_context *);
 142 static
 143 int bt_field_type_string_serialize(struct bt_field_type *,
 144                 struct metadata_context *);
 145
 146 static
 147 type_serialize_func const type_serialize_funcs[] = {
 148         [BT_FIELD_TYPE_ID_INTEGER] = bt_field_type_integer_serialize,
 149         [BT_FIELD_TYPE_ID_ENUM] =
 150                 bt_field_type_enumeration_serialize,
 151         [BT_FIELD_TYPE_ID_FLOAT] =
 152                 bt_field_type_floating_point_serialize,
 153         [BT_FIELD_TYPE_ID_STRUCT] =
 154                 bt_field_type_structure_serialize,
 155         [BT_FIELD_TYPE_ID_VARIANT] = bt_field_type_variant_serialize,
 156         [BT_FIELD_TYPE_ID_ARRAY] = bt_field_type_array_serialize,
 157         [BT_FIELD_TYPE_ID_SEQUENCE] = bt_field_type_sequence_serialize,
 158         [BT_FIELD_TYPE_ID_STRING] = bt_field_type_string_serialize,
 159 };
 160
 161 static
 162 void bt_field_type_integer_set_byte_order(struct bt_field_type *,
 163                 enum bt_byte_order byte_order);
 164 static
 165 void bt_field_type_enumeration_set_byte_order(struct bt_field_type *,
 166                 enum bt_byte_order byte_order);
 167 static
 168 void bt_field_type_floating_point_set_byte_order(
 169                 struct bt_field_type *, enum bt_byte_order byte_order);
 170 static
 171 void bt_field_type_structure_set_byte_order(struct bt_field_type *,
 172                 enum bt_byte_order byte_order);
 173 static
 174 void bt_field_type_variant_set_byte_order(struct bt_field_type *,
 175                 enum bt_byte_order byte_order);
 176 static
 177 void bt_field_type_array_set_byte_order(struct bt_field_type *,
 178                 enum bt_byte_order byte_order);
 179 static
 180 void bt_field_type_sequence_set_byte_order(struct bt_field_type *,
 181                 enum bt_byte_order byte_order);
 182
 183 static
 184 void (* const set_byte_order_funcs[])(struct bt_field_type *,
 185                 enum bt_byte_order) = {
 186         [BT_FIELD_TYPE_ID_INTEGER] = bt_field_type_integer_set_byte_order,
 187         [BT_FIELD_TYPE_ID_ENUM] =
 188                 bt_field_type_enumeration_set_byte_order,
 189         [BT_FIELD_TYPE_ID_FLOAT] =
 190                 bt_field_type_floating_point_set_byte_order,
 191         [BT_FIELD_TYPE_ID_STRUCT] =
 192                 bt_field_type_structure_set_byte_order,
 193         [BT_FIELD_TYPE_ID_VARIANT] = bt_field_type_variant_set_byte_order,
 194         [BT_FIELD_TYPE_ID_ARRAY] = bt_field_type_array_set_byte_order,
 195         [BT_FIELD_TYPE_ID_SEQUENCE] = bt_field_type_sequence_set_byte_order,
 196         [BT_FIELD_TYPE_ID_STRING] = NULL,
 197 };
 198
 199 static
 200 struct bt_field_type *bt_field_type_integer_copy(
 201                 struct bt_field_type *);
 202 static
 203 struct bt_field_type *bt_field_type_enumeration_copy(
 204                 struct bt_field_type *);
 205 static
 206 struct bt_field_type *bt_field_type_floating_point_copy(
 207                 struct bt_field_type *);
 208 static
 209 struct bt_field_type *bt_field_type_structure_copy(
 210                 struct bt_field_type *);
 211 static
 212 struct bt_field_type *bt_field_type_variant_copy(
 213                 struct bt_field_type *);
 214 static
 215 struct bt_field_type *bt_field_type_array_copy(
 216                 struct bt_field_type *);
 217 static
 218 struct bt_field_type *bt_field_type_sequence_copy(
 219                 struct bt_field_type *);
 220 static
 221 struct bt_field_type *bt_field_type_string_copy(
 222                 struct bt_field_type *);
 223
 224 static
 225 struct bt_field_type *(* const type_copy_funcs[])(
 226                 struct bt_field_type *) = {
 227         [BT_FIELD_TYPE_ID_INTEGER] = bt_field_type_integer_copy,
 228         [BT_FIELD_TYPE_ID_ENUM] = bt_field_type_enumeration_copy,
 229         [BT_FIELD_TYPE_ID_FLOAT] = bt_field_type_floating_point_copy,
 230         [BT_FIELD_TYPE_ID_STRUCT] = bt_field_type_structure_copy,
 231         [BT_FIELD_TYPE_ID_VARIANT] = bt_field_type_variant_copy,
 232         [BT_FIELD_TYPE_ID_ARRAY] = bt_field_type_array_copy,
 233         [BT_FIELD_TYPE_ID_SEQUENCE] = bt_field_type_sequence_copy,
 234         [BT_FIELD_TYPE_ID_STRING] = bt_field_type_string_copy,
 235 };
 236
 237 static
 238 int bt_field_type_integer_compare(struct bt_field_type *,
 239                 struct bt_field_type *);
 240 static
 241 int bt_field_type_floating_point_compare(struct bt_field_type *,
 242                 struct bt_field_type *);
 243 static
 244 int bt_field_type_enumeration_compare(struct bt_field_type *,
 245                 struct bt_field_type *);
 246 static
 247 int bt_field_type_string_compare(struct bt_field_type *,
 248                 struct bt_field_type *);
 249 static
 250 int bt_field_type_structure_compare(struct bt_field_type *,
 251                 struct bt_field_type *);
 252 static
 253 int bt_field_type_variant_compare(struct bt_field_type *,
 254                 struct bt_field_type *);
 255 static
 256 int bt_field_type_array_compare(struct bt_field_type *,
 257                 struct bt_field_type *);
 258 static
 259 int bt_field_type_sequence_compare(struct bt_field_type *,
 260                 struct bt_field_type *);
 261
 262 static
 263 int (* const type_compare_funcs[])(struct bt_field_type *,
 264                 struct bt_field_type *) = {
 265         [BT_FIELD_TYPE_ID_INTEGER] = bt_field_type_integer_compare,
 266         [BT_FIELD_TYPE_ID_ENUM] = bt_field_type_enumeration_compare,
 267         [BT_FIELD_TYPE_ID_FLOAT] = bt_field_type_floating_point_compare,
 268         [BT_FIELD_TYPE_ID_STRUCT] = bt_field_type_structure_compare,
 269         [BT_FIELD_TYPE_ID_VARIANT] = bt_field_type_variant_compare,
 270         [BT_FIELD_TYPE_ID_ARRAY] = bt_field_type_array_compare,
 271         [BT_FIELD_TYPE_ID_SEQUENCE] = bt_field_type_sequence_compare,
 272         [BT_FIELD_TYPE_ID_STRING] = bt_field_type_string_compare,
 273 };
 274
 275 static
 276 int bt_field_type_integer_validate(struct bt_field_type *);
 277 static
 278 int bt_field_type_enumeration_validate(struct bt_field_type *);
 279 static
 280 int bt_field_type_structure_validate(struct bt_field_type *);
 281 static
 282 int bt_field_type_variant_validate(struct bt_field_type *);
 283 static
 284 int bt_field_type_array_validate(struct bt_field_type *);
 285 static
 286 int bt_field_type_sequence_validate(struct bt_field_type *);
 287
 288 static
 289 int (* const type_validate_funcs[])(struct bt_field_type *) = {
 290         [BT_FIELD_TYPE_ID_INTEGER] = bt_field_type_integer_validate,
 291         [BT_FIELD_TYPE_ID_FLOAT] = NULL,
 292         [BT_FIELD_TYPE_ID_STRING] = NULL,
 293         [BT_FIELD_TYPE_ID_ENUM] = bt_field_type_enumeration_validate,
 294         [BT_FIELD_TYPE_ID_STRUCT] = bt_field_type_structure_validate,
 295         [BT_FIELD_TYPE_ID_VARIANT] = bt_field_type_variant_validate,
 296         [BT_FIELD_TYPE_ID_ARRAY] = bt_field_type_array_validate,
 297         [BT_FIELD_TYPE_ID_SEQUENCE] = bt_field_type_sequence_validate,
 298 };
 299
 300 static
 301 void destroy_enumeration_mapping(struct enumeration_mapping *mapping)
 302 {
 303         g_free(mapping);
 304 }
 305
 306 static
 307 void destroy_structure_field(struct structure_field *field)
 308 {
 309         if (!field) {
 310                 return;
 311         }
 312
 313         BT_LOGD("Destroying structure/variant field type's field object: "
 314                 "addr=%p, field-ft-addr=%p, field-name=\"%s\"",
 315                 field, field->type, g_quark_to_string(field->name));
 316         BT_LOGD_STR("Putting field type.");
 317         bt_put(field->type);
 318         g_free(field);
 319 }
 320
 321 static
 322 void check_ranges_overlap(gpointer element, gpointer query)
 323 {
 324         struct enumeration_mapping *mapping = element;
 325         struct range_overlap_query *overlap_query = query;
 326
 327         if (mapping->range_start._signed <= overlap_query->range_end._signed
 328                         && overlap_query->range_start._signed <=
 329                         mapping->range_end._signed) {
 330                 overlap_query->overlaps = 1;
 331                 overlap_query->mapping_name = mapping->string;
 332         }
 333
 334         overlap_query->overlaps |=
 335                 mapping->string == overlap_query->mapping_name;
 336
 337         if (overlap_query->overlaps) {
 338                 BT_LOGV("Overlapping enumeration field type mappings: "
 339                         "mapping-name=\"%s\", "
 340                         "mapping-a-range-start=%" PRId64 ", "
 341                         "mapping-a-range-end=%" PRId64 ", "
 342                         "mapping-b-range-start=%" PRId64 ", "
 343                         "mapping-b-range-end=%" PRId64,
 344                         g_quark_to_string(mapping->string),
 345                         mapping->range_start._signed,
 346                         mapping->range_end._signed,
 347                         overlap_query->range_start._signed,
 348                         overlap_query->range_end._signed);
 349         }
 350 }
 351
 352 static
 353 void check_ranges_overlap_unsigned(gpointer element, gpointer query)
 354 {
 355         struct enumeration_mapping *mapping = element;
 356         struct range_overlap_query *overlap_query = query;
 357
 358         if (mapping->range_start._unsigned <= overlap_query->range_end._unsigned
 359                         && overlap_query->range_start._unsigned <=
 360                         mapping->range_end._unsigned) {
 361                 overlap_query->overlaps = 1;
 362                 overlap_query->mapping_name = mapping->string;
 363         }
 364
 365         overlap_query->overlaps |=
 366                 mapping->string == overlap_query->mapping_name;
 367
 368         if (overlap_query->overlaps) {
 369                 BT_LOGW("Overlapping enumeration field type mappings: "
 370                         "mapping-name=\"%s\", "
 371                         "mapping-a-range-start=%" PRIu64 ", "
 372                         "mapping-a-range-end=%" PRIu64 ", "
 373                         "mapping-b-range-start=%" PRIu64 ", "
 374                         "mapping-b-range-end=%" PRIu64,
 375                         g_quark_to_string(mapping->string),
 376                         mapping->range_start._unsigned,
 377                         mapping->range_end._unsigned,
 378                         overlap_query->range_start._unsigned,
 379                         overlap_query->range_end._unsigned);
 380         }
 381 }
 382
 383 static
 384 gint compare_enumeration_mappings_signed(struct enumeration_mapping **a,
 385                 struct enumeration_mapping **b)
 386 {
 387         return ((*a)->range_start._signed < (*b)->range_start._signed) ? -1 : 1;
 388 }
 389
 390 static
 391 gint compare_enumeration_mappings_unsigned(struct enumeration_mapping **a,
 392                 struct enumeration_mapping **b)
 393 {
 394         return ((*a)->range_start._unsigned < (*b)->range_start._unsigned) ? -1 : 1;
 395 }
 396
 397 static
 398 void bt_field_type_init(struct bt_field_type *type, bt_bool init_bo)
 399 {
 400         assert(type && (type->id > BT_FIELD_TYPE_ID_UNKNOWN) &&
 401                 (type->id < BT_FIELD_TYPE_ID_NR));
 402
 403         bt_object_init(type, bt_field_type_destroy);
 404         type->freeze = type_freeze_funcs[type->id];
 405         type->serialize = type_serialize_funcs[type->id];
 406
 407         if (init_bo) {
 408                 int ret;
 409                 const enum bt_byte_order bo = BT_BYTE_ORDER_NATIVE;
 410
 411                 BT_LOGD("Setting initial field type's byte order: bo=%s",
 412                         bt_byte_order_string(bo));
 413                 ret = bt_field_type_set_byte_order(type, bo);
 414                 assert(ret == 0);
 415         }
 416
 417         type->alignment = 1;
 418 }
 419
 420 static
 421 int add_structure_field(GPtrArray *fields,
 422                 GHashTable *field_name_to_index,
 423                 struct bt_field_type *field_type,
 424                 const char *field_name)
 425 {
 426         int ret = 0;
 427         GQuark name_quark = g_quark_from_string(field_name);
 428         struct structure_field *field;
 429
 430         /* Make sure structure does not contain a field of the same name */
 431         if (g_hash_table_lookup_extended(field_name_to_index,
 432                         GUINT_TO_POINTER(name_quark), NULL, NULL)) {
 433                 BT_LOGW("Structure or variant field type already contains a field type with this name: "
 434                         "field-name=\"%s\"", field_name);
 435                 ret = -1;
 436                 goto end;
 437         }
 438
 439         field = g_new0(struct structure_field, 1);
 440         if (!field) {
 441                 BT_LOGE_STR("Failed to allocate one structure/variant field type field.");
 442                 ret = -1;
 443                 goto end;
 444         }
 445
 446         bt_get(field_type);
 447         field->name = name_quark;
 448         field->type = field_type;
 449         g_hash_table_insert(field_name_to_index,
 450                 GUINT_TO_POINTER(name_quark),
 451                 GUINT_TO_POINTER(fields->len));
 452         g_ptr_array_add(fields, field);
 453         BT_LOGV("Added structure/variant field type field: field-ft-addr=%p, "
 454                 "field-name=\"%s\"", field_type, field_name);
 455 end:
 456         return ret;
 457 }
 458
 459 static
 460 void bt_field_type_destroy(struct bt_object *obj)
 461 {
 462         struct bt_field_type *type;
 463         enum bt_field_type_id type_id;
 464
 465         type = container_of(obj, struct bt_field_type, base);
 466         type_id = type->id;
 467         assert(type_id > BT_FIELD_TYPE_ID_UNKNOWN &&
 468                 type_id < BT_FIELD_TYPE_ID_NR);
 469         type_destroy_funcs[type_id](type);
 470 }
 471
 472 static
 473 int bt_field_type_integer_validate(struct bt_field_type *type)
 474 {
 475         int ret = 0;
 476
 477         struct bt_field_type_integer *integer =
 478                 container_of(type, struct bt_field_type_integer,
 479                         parent);
 480
 481         if (integer->mapped_clock && integer->is_signed) {
 482                 BT_LOGW("Invalid integer field type: cannot be signed and have a mapped clock class: "
 483                         "ft-addr=%p, clock-class-addr=%p, clock-class-name=\"%s\"",
 484                         type, integer->mapped_clock,
 485                         bt_clock_class_get_name(integer->mapped_clock));
 486                 ret = -1;
 487                 goto end;
 488         }
 489
 490 end:
 491         return ret;
 492 }
 493
 494 static
 495 struct enumeration_mapping *get_enumeration_mapping(
 496                 struct bt_field_type *type, uint64_t index)
 497 {
 498         struct enumeration_mapping *mapping = NULL;
 499         struct bt_field_type_enumeration *enumeration;
 500
 501         enumeration = container_of(type, struct bt_field_type_enumeration,
 502                 parent);
 503         if (index >= enumeration->entries->len) {
 504                 BT_LOGW("Invalid parameter: index is out of bounds: "
 505                         "addr=%p, index=%" PRIu64 ", count=%u",
 506                         type, index, enumeration->entries->len);
 507                 goto end;
 508         }
 509
 510         mapping = g_ptr_array_index(enumeration->entries, index);
 511 end:
 512         return mapping;
 513 }
 514
 515 /*
 516  * Note: This algorithm is O(n^2) vs number of enumeration mappings.
 517  * Only used when freezing an enumeration.
 518  */
 519 static
 520 void set_enumeration_range_overlap(
 521                 struct bt_field_type *type)
 522 {
 523         int64_t i, j, len;
 524         struct bt_field_type *container_type;
 525         struct bt_field_type_enumeration *enumeration_type;
 526         int is_signed;
 527
 528         BT_LOGV("Setting enumeration field type's overlap flag: addr=%p",
 529                 type);
 530         enumeration_type = container_of(type,
 531                         struct bt_field_type_enumeration, parent);
 532
 533         len = enumeration_type->entries->len;
 534         container_type = enumeration_type->container;
 535         is_signed = bt_field_type_integer_is_signed(container_type);
 536
 537         for (i = 0; i < len; i++) {
 538                 for (j = i + 1; j < len; j++) {
 539                         struct enumeration_mapping *mapping[2];
 540
 541                         mapping[0] = get_enumeration_mapping(type, i);
 542                         mapping[1] = get_enumeration_mapping(type, j);
 543                         if (is_signed) {
 544                                 if (mapping[0]->range_start._signed
 545                                                         <= mapping[1]->range_end._signed
 546                                                 && mapping[0]->range_end._signed
 547                                                         >= mapping[1]->range_start._signed) {
 548                                         enumeration_type->has_overlapping_ranges = BT_TRUE;
 549                                         goto end;
 550                                 }
 551                         } else {
 552                                 if (mapping[0]->range_start._unsigned
 553                                                         <= mapping[1]->range_end._unsigned
 554                                                 && mapping[0]->range_end._unsigned
 555                                                         >= mapping[1]->range_start._unsigned) {
 556                                         enumeration_type->has_overlapping_ranges = BT_TRUE;
 557                                         goto end;
 558                                 }
 559                         }
 560                 }
 561         }
 562
 563 end:
 564         if (enumeration_type->has_overlapping_ranges) {
 565                 BT_LOGV_STR("Enumeration field type has overlapping ranges.");
 566         } else {
 567                 BT_LOGV_STR("Enumeration field type has no overlapping ranges.");
 568         }
 569 }
 570
 571 static
 572 int bt_field_type_enumeration_validate(struct bt_field_type *type)
 573 {
 574         int ret = 0;
 575
 576         struct bt_field_type_enumeration *enumeration =
 577                 container_of(type, struct bt_field_type_enumeration,
 578                         parent);
 579         struct bt_field_type *container_type =
 580                 bt_field_type_enumeration_get_container_type(type);
 581
 582         assert(container_type);
 583         ret = bt_field_type_validate(container_type);
 584         if (ret) {
 585                 BT_LOGW("Invalid enumeration field type: container type is invalid: "
 586                         "enum-ft-addr=%p, int-ft-addr=%p",
 587                         type, container_type);
 588                 goto end;
 589         }
 590
 591         /* Ensure enum has entries */
 592         if (enumeration->entries->len == 0) {
 593                 BT_LOGW("Invalid enumeration field type: no entries: "
 594                         "addr=%p", type);
 595                 ret = -1;
 596                 goto end;
 597         }
 598
 599 end:
 600         BT_PUT(container_type);
 601         return ret;
 602 }
 603
 604 static
 605 int bt_field_type_sequence_validate(struct bt_field_type *type)
 606 {
 607         int ret = 0;
 608         struct bt_field_type *element_type = NULL;
 609         struct bt_field_type_sequence *sequence =
 610                 container_of(type, struct bt_field_type_sequence,
 611                 parent);
 612
 613         /* Length field name should be set at this point */
 614         if (sequence->length_field_name->len == 0) {
 615                 BT_LOGW("Invalid sequence field type: no length field name: "
 616                         "addr=%p", type);
 617                 ret = -1;
 618                 goto end;
 619         }
 620
 621         element_type = bt_field_type_sequence_get_element_type(type);
 622         assert(element_type);
 623         ret = bt_field_type_validate(element_type);
 624         if (ret) {
 625                 BT_LOGW("Invalid sequence field type: invalid element field type: "
 626                         "seq-ft-addr=%p, element-ft-add=%p",
 627                         type, element_type);
 628         }
 629
 630 end:
 631         BT_PUT(element_type);
 632
 633         return ret;
 634 }
 635
 636 static
 637 int bt_field_type_array_validate(struct bt_field_type *type)
 638 {
 639         int ret = 0;
 640         struct bt_field_type *element_type = NULL;
 641
 642         element_type = bt_field_type_array_get_element_type(type);
 643         assert(element_type);
 644         ret = bt_field_type_validate(element_type);
 645         if (ret) {
 646                 BT_LOGW("Invalid array field type: invalid element field type: "
 647                         "array-ft-addr=%p, element-ft-add=%p",
 648                         type, element_type);
 649         }
 650
 651         BT_PUT(element_type);
 652         return ret;
 653 }
 654
 655 static
 656 int bt_field_type_structure_validate(struct bt_field_type *type)
 657 {
 658         int ret = 0;
 659         struct bt_field_type *child_type = NULL;
 660         int64_t field_count = bt_field_type_structure_get_field_count(type);
 661         int64_t i;
 662
 663         assert(field_count >= 0);
 664
 665         for (i = 0; i < field_count; ++i) {
 666                 const char *field_name;
 667
 668                 ret = bt_field_type_structure_get_field_by_index(type,
 669                         &field_name, &child_type, i);
 670                 assert(ret == 0);
 671                 ret = bt_field_type_validate(child_type);
 672                 if (ret) {
 673                         BT_LOGW("Invalid structure field type: "
 674                                 "a contained field type is invalid: "
 675                                 "struct-ft-addr=%p, field-ft-addr=%p, "
 676                                 "field-name=\"%s\", field-index=%" PRId64,
 677                                 type, child_type, field_name, i);
 678                         goto end;
 679                 }
 680
 681                 BT_PUT(child_type);
 682         }
 683
 684 end:
 685         BT_PUT(child_type);
 686
 687         return ret;
 688 }
 689
 690 static
 691 bt_bool bt_field_type_enumeration_has_overlapping_ranges(
 692                 struct bt_field_type_enumeration *enumeration_type)
 693 {
 694         if (!enumeration_type->parent.frozen) {
 695                 set_enumeration_range_overlap(&enumeration_type->parent);
 696         }
 697         return enumeration_type->has_overlapping_ranges;
 698 }
 699
 700 static
 701 int bt_field_type_variant_validate(struct bt_field_type *type)
 702 {
 703         int ret = 0;
 704         int64_t field_count;
 705         struct bt_field_type *child_type = NULL;
 706         struct bt_field_type_variant *variant =
 707                 container_of(type, struct bt_field_type_variant,
 708                         parent);
 709         int64_t i;
 710
 711         if (variant->tag_name->len == 0) {
 712                 BT_LOGW("Invalid variant field type: no tag field name: "
 713                         "addr=%p", type);
 714                 ret = -1;
 715                 goto end;
 716         }
 717
 718         if (!variant->tag) {
 719                 BT_LOGW("Invalid variant field type: no tag field type: "
 720                         "addr=%p, tag-field-name=\"%s\"", type,
 721                         variant->tag_name->str);
 722                 ret = -1;
 723                 goto end;
 724         }
 725
 726         if (bt_field_type_enumeration_has_overlapping_ranges(
 727                         variant->tag)) {
 728                 BT_LOGW("Invalid variant field type: enumeration tag field type has overlapping ranges: "
 729                         "variant-ft-addr=%p, tag-field-name=\"%s\", "
 730                         "enum-ft-addr=%p", type, variant->tag_name->str,
 731                         variant->tag);
 732                 ret = -1;
 733                 goto end;
 734         }
 735
 736         /*
 737          * It is valid to have a variant field type which does not have
 738          * the fields corresponding to each label in the associated
 739          * enumeration.
 740          *
 741          * It is also valid to have variant field type fields which
 742          * cannot be selected because the variant field type tag has no
 743          * mapping named as such. This scenario, while not ideal, cannot
 744          * cause any error.
 745          *
 746          * If a non-existing field happens to be selected by an
 747          * enumeration while reading a variant field, an error will be
 748          * generated at that point (while reading the stream).
 749          */
 750         field_count = bt_field_type_variant_get_field_count(type);
 751         if (field_count < 0) {
 752                 BT_LOGW("Invalid variant field type: no fields: "
 753                         "addr=%p, tag-field-name=\"%s\"",
 754                         type, variant->tag_name->str);
 755                 ret = -1;
 756                 goto end;
 757         }
 758
 759         for (i = 0; i < field_count; ++i) {
 760                 const char *field_name;
 761
 762                 ret = bt_field_type_variant_get_field_by_index(type,
 763                         &field_name, &child_type, i);
 764                 assert(ret == 0);
 765                 ret = bt_field_type_validate(child_type);
 766                 if (ret) {
 767                         BT_LOGW("Invalid variant field type: "
 768                                 "a contained field type is invalid: "
 769                                 "variant-ft-addr=%p, tag-field-name=\"%s\", "
 770                                 "field-ft-addr=%p, field-name=\"%s\", "
 771                                 "field-index=%" PRId64,
 772                                 type, variant->tag_name->str, child_type,
 773                                 field_name, i);
 774                         goto end;
 775                 }
 776
 777                 BT_PUT(child_type);
 778         }
 779
 780 end:
 781         BT_PUT(child_type);
 782
 783         return ret;
 784 }
 785
 786 /*
 787  * This function validates a given field type without considering
 788  * where this field type is located. It only validates the properties
 789  * of the given field type and the properties of its children if
 790  * applicable.
 791  */
 792 BT_HIDDEN
 793 int bt_field_type_validate(struct bt_field_type *type)
 794 {
 795         int ret = 0;
 796         enum bt_field_type_id id = bt_field_type_get_type_id(type);
 797
 798         assert(type);
 799
 800         if (type->valid) {
 801                 /* Already marked as valid */
 802                 goto end;
 803         }
 804
 805         if (type_validate_funcs[id]) {
 806                 ret = type_validate_funcs[id](type);
 807         }
 808
 809         if (!ret && type->frozen) {
 810                 /* Field type is valid */
 811                 BT_LOGV("Marking field type as valid: addr=%p", type);
 812                 type->valid = 1;
 813         }
 814
 815 end:
 816         return ret;
 817 }
 818
 819 struct bt_field_type *bt_field_type_integer_create(unsigned int size)
 820 {
 821         struct bt_field_type_integer *integer =
 822                 g_new0(struct bt_field_type_integer, 1);
 823
 824         BT_LOGD("Creating integer field type object: size=%u", size);
 825
 826         if (!integer) {
 827                 BT_LOGE_STR("Failed to allocate one integer field type.");
 828                 return NULL;
 829         }
 830
 831         if (size == 0 || size > 64) {
 832                 BT_LOGW("Invalid parameter: size must be between 1 and 64: "
 833                         "size=%u", size);
 834                 return NULL;
 835         }
 836
 837         integer->parent.id = BT_FIELD_TYPE_ID_INTEGER;
 838         integer->size = size;
 839         integer->base = BT_INTEGER_BASE_DECIMAL;
 840         integer->encoding = BT_STRING_ENCODING_NONE;
 841         bt_field_type_init(&integer->parent, TRUE);
 842         BT_LOGD("Created integer field type object: addr=%p, size=%u",
 843                 &integer->parent, size);
 844         return &integer->parent;
 845 }
 846
 847 int bt_field_type_integer_get_size(struct bt_field_type *type)
 848 {
 849         int ret = 0;
 850         struct bt_field_type_integer *integer;
 851
 852         if (!type) {
 853                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
 854                 ret = -1;
 855                 goto end;
 856         }
 857
 858         if (type->id != BT_FIELD_TYPE_ID_INTEGER) {
 859                 BT_LOGW("Invalid parameter: field type is not an integer field type: "
 860                         "addr=%p, ft-id=%s", type,
 861                         bt_field_type_id_string(type->id));
 862                 ret = -1;
 863                 goto end;
 864         }
 865
 866         integer = container_of(type, struct bt_field_type_integer, parent);
 867         ret = (int) integer->size;
 868 end:
 869         return ret;
 870 }
 871
 872 int bt_ctf_field_type_integer_get_signed(struct bt_field_type *type)
 873 {
 874         int ret = 0;
 875         struct bt_field_type_integer *integer;
 876
 877         if (!type) {
 878                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
 879                 ret = -1;
 880                 goto end;
 881         }
 882
 883         if (type->id != BT_FIELD_TYPE_ID_INTEGER) {
 884                 BT_LOGW("Invalid parameter: field type is not an integer field type: "
 885                         "addr=%p, ft-id=%s", type,
 886                         bt_field_type_id_string(type->id));
 887                 ret = -1;
 888                 goto end;
 889         }
 890
 891         integer = container_of(type, struct bt_field_type_integer, parent);
 892         ret = integer->is_signed;
 893 end:
 894         return ret;
 895 }
 896
 897 bt_bool bt_field_type_integer_is_signed(
 898                 struct bt_field_type *int_field_type)
 899 {
 900         return bt_ctf_field_type_integer_get_signed(int_field_type) ?
 901                 BT_TRUE : BT_FALSE;
 902 }
 903
 904 int bt_field_type_integer_set_is_signed(struct bt_field_type *type,
 905                 bt_bool is_signed)
 906 {
 907         int ret = 0;
 908         struct bt_field_type_integer *integer;
 909
 910         if (!type) {
 911                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
 912                 ret = -1;
 913                 goto end;
 914         }
 915
 916         if (type->frozen) {
 917                 BT_LOGW("Invalid parameter: field type is frozen: addr=%p",
 918                         type);
 919                 ret = -1;
 920                 goto end;
 921         }
 922
 923         if (type->id != BT_FIELD_TYPE_ID_INTEGER) {
 924                 BT_LOGW("Invalid parameter: field type is not an integer field type: "
 925                         "addr=%p, ft-id=%s", type,
 926                         bt_field_type_id_string(type->id));
 927                 ret = -1;
 928                 goto end;
 929         }
 930
 931         integer = container_of(type, struct bt_field_type_integer, parent);
 932         integer->is_signed = !!is_signed;
 933         BT_LOGV("Set integer field type's signedness: addr=%p, is-signed=%d",
 934                 type, is_signed);
 935 end:
 936         return ret;
 937 }
 938
 939 int bt_field_type_integer_set_size(struct bt_field_type *type,
 940                 unsigned int size)
 941 {
 942         int ret = 0;
 943         struct bt_field_type_integer *integer;
 944
 945         if (!type) {
 946                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
 947                 ret = -1;
 948                 goto end;
 949         }
 950
 951         if (type->frozen) {
 952                 BT_LOGW("Invalid parameter: field type is frozen: addr=%p",
 953                         type);
 954                 ret = -1;
 955                 goto end;
 956         }
 957
 958         if (type->id != BT_FIELD_TYPE_ID_INTEGER) {
 959                 BT_LOGW("Invalid parameter: field type is not an integer field type: "
 960                         "addr=%p, ft-id=%s", type,
 961                         bt_field_type_id_string(type->id));
 962                 ret = -1;
 963                 goto end;
 964         }
 965
 966         if (size == 0 || size > 64) {
 967                 BT_LOGW("Invalid parameter: size must be between 1 and 64: "
 968                         "addr=%p, size=%u", type, size);
 969                 ret = -1;
 970                 goto end;
 971         }
 972
 973         integer = container_of(type, struct bt_field_type_integer, parent);
 974         integer->size = size;
 975         BT_LOGV("Set integer field type's size: addr=%p, size=%u",
 976                 type, size);
 977 end:
 978         return ret;
 979 }
 980
 981 enum bt_integer_base bt_field_type_integer_get_base(
 982                 struct bt_field_type *type)
 983 {
 984         enum bt_integer_base ret = BT_INTEGER_BASE_UNKNOWN;
 985         struct bt_field_type_integer *integer;
 986
 987         if (!type) {
 988                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
 989                 goto end;
 990         }
 991
 992         if (type->id != BT_FIELD_TYPE_ID_INTEGER) {
 993                 BT_LOGW("Invalid parameter: field type is not an integer field type: "
 994                         "addr=%p, ft-id=%s", type,
 995                         bt_field_type_id_string(type->id));
 996                 goto end;
 997         }
 998
 999         integer = container_of(type, struct bt_field_type_integer, parent);
1000         ret = integer->base;
1001 end:
1002         return ret;
1003 }
1004
1005 int bt_field_type_integer_set_base(struct bt_field_type *type,
1006                 enum bt_integer_base base)
1007 {
1008         int ret = 0;
1009
1010         if (!type) {
1011                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
1012                 ret = -1;
1013                 goto end;
1014         }
1015
1016         if (type->frozen) {
1017                 BT_LOGW("Invalid parameter: field type is frozen: addr=%p",
1018                         type);
1019                 ret = -1;
1020                 goto end;
1021         }
1022
1023         if (type->id != BT_FIELD_TYPE_ID_INTEGER) {
1024                 BT_LOGW("Invalid parameter: field type is not an integer field type: "
1025                         "addr=%p, ft-id=%s", type,
1026                         bt_field_type_id_string(type->id));
1027                 ret = -1;
1028                 goto end;
1029         }
1030
1031         switch (base) {
1032         case BT_INTEGER_BASE_UNSPECIFIED:
1033         case BT_INTEGER_BASE_BINARY:
1034         case BT_INTEGER_BASE_OCTAL:
1035         case BT_INTEGER_BASE_DECIMAL:
1036         case BT_INTEGER_BASE_HEXADECIMAL:
1037         {
1038                 struct bt_field_type_integer *integer = container_of(type,
1039                         struct bt_field_type_integer, parent);
1040                 integer->base = base;
1041                 break;
1042         }
1043         default:
1044                 BT_LOGW("Invalid parameter: unknown integer field type base: "
1045                         "addr=%p, base=%d", type, base);
1046                 ret = -1;
1047         }
1048
1049         BT_LOGV("Set integer field type's base: addr=%p, base=%s",
1050                 type, bt_integer_base_string(base));
1051
1052 end:
1053         return ret;
1054 }
1055
1056 enum bt_string_encoding bt_field_type_integer_get_encoding(
1057                 struct bt_field_type *type)
1058 {
1059         enum bt_string_encoding ret = BT_STRING_ENCODING_UNKNOWN;
1060         struct bt_field_type_integer *integer;
1061
1062         if (!type) {
1063                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
1064                 goto end;
1065         }
1066
1067         if (type->id != BT_FIELD_TYPE_ID_INTEGER) {
1068                 BT_LOGW("Invalid parameter: field type is not an integer field type: "
1069                         "addr=%p, ft-id=%s", type,
1070                         bt_field_type_id_string(type->id));
1071                 goto end;
1072         }
1073
1074         integer = container_of(type, struct bt_field_type_integer, parent);
1075         ret = integer->encoding;
1076 end:
1077         return ret;
1078 }
1079
1080 int bt_field_type_integer_set_encoding(struct bt_field_type *type,
1081                 enum bt_string_encoding encoding)
1082 {
1083         int ret = 0;
1084         struct bt_field_type_integer *integer;
1085
1086         if (!type) {
1087                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
1088                 ret = -1;
1089                 goto end;
1090         }
1091
1092         if (type->frozen) {
1093                 BT_LOGW("Invalid parameter: field type is frozen: addr=%p",
1094                         type);
1095                 ret = -1;
1096                 goto end;
1097         }
1098
1099         if (type->id != BT_FIELD_TYPE_ID_INTEGER) {
1100                 BT_LOGW("Invalid parameter: field type is not an integer field type: "
1101                         "addr=%p, ft-id=%s", type,
1102                         bt_field_type_id_string(type->id));
1103                 ret = -1;
1104                 goto end;
1105         }
1106
1107         if (encoding != BT_STRING_ENCODING_UTF8 &&
1108                         encoding != BT_STRING_ENCODING_ASCII &&
1109                         encoding != BT_STRING_ENCODING_NONE) {
1110                 BT_LOGW("Invalid parameter: unknown string encoding: "
1111                         "addr=%p, encoding=%d", type, encoding);
1112                 ret = -1;
1113                 goto end;
1114         }
1115
1116         integer = container_of(type, struct bt_field_type_integer, parent);
1117         integer->encoding = encoding;
1118         BT_LOGV("Set integer field type's encoding: addr=%p, encoding=%s",
1119                 type, bt_string_encoding_string(encoding));
1120 end:
1121         return ret;
1122 }
1123
1124 struct bt_clock_class *bt_field_type_integer_get_mapped_clock_class(
1125                 struct bt_field_type *type)
1126 {
1127         struct bt_field_type_integer *integer;
1128         struct bt_clock_class *clock_class = NULL;
1129
1130         if (!type) {
1131                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
1132                 goto end;
1133         }
1134
1135         integer = container_of(type, struct bt_field_type_integer, parent);
1136         clock_class = integer->mapped_clock;
1137         bt_get(clock_class);
1138 end:
1139         return clock_class;
1140 }
1141
1142 BT_HIDDEN
1143 int bt_field_type_integer_set_mapped_clock_class_no_check(
1144                 struct bt_field_type *type,
1145                 struct bt_clock_class *clock_class)
1146 {
1147         struct bt_field_type_integer *integer;
1148         int ret = 0;
1149
1150         if (!type) {
1151                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
1152                 ret = -1;
1153                 goto end;
1154         }
1155
1156         if (!clock_class) {
1157                 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
1158                 ret = -1;
1159                 goto end;
1160         }
1161
1162         if (type->id != BT_FIELD_TYPE_ID_INTEGER) {
1163                 BT_LOGW("Invalid parameter: field type is not an integer field type: "
1164                         "addr=%p, ft-id=%s", type,
1165                         bt_field_type_id_string(type->id));
1166                 goto end;
1167         }
1168
1169         if (!bt_clock_class_is_valid(clock_class)) {
1170                 BT_LOGW("Invalid parameter: clock class is invalid: ft-addr=%p"
1171                         "clock-class-addr=%p, clock-class-name=\"%s\"",
1172                         type, clock_class,
1173                         bt_clock_class_get_name(clock_class));
1174                 ret = -1;
1175                 goto end;
1176         }
1177
1178         integer = container_of(type, struct bt_field_type_integer, parent);
1179         bt_put(integer->mapped_clock);
1180         integer->mapped_clock = bt_get(clock_class);
1181         BT_LOGV("Set integer field type's mapped clock class: ft-addr=%p, "
1182                 "clock-class-addr=%p, clock-class-name=\"%s\"",
1183                 type, clock_class, bt_clock_class_get_name(clock_class));
1184 end:
1185         return ret;
1186 }
1187
1188 int bt_field_type_integer_set_mapped_clock_class(
1189                 struct bt_field_type *type,
1190                 struct bt_clock_class *clock_class)
1191 {
1192         int ret = 0;
1193
1194         if (!type) {
1195                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
1196                 ret = -1;
1197                 goto end;
1198         }
1199
1200         if (type->frozen) {
1201                 BT_LOGW("Invalid parameter: field type is frozen: addr=%p",
1202                         type);
1203                 ret = -1;
1204                 goto end;
1205         }
1206
1207         ret = bt_field_type_integer_set_mapped_clock_class_no_check(
1208                 type, clock_class);
1209
1210 end:
1211         return ret;
1212 }
1213
1214 static
1215 void bt_field_type_enum_iter_destroy(struct bt_object *obj)
1216 {
1217         struct bt_field_type_enumeration_mapping_iterator *iter =
1218                 container_of(obj,
1219                         struct bt_field_type_enumeration_mapping_iterator,
1220                         base);
1221
1222         BT_LOGD("Destroying enumeration field type mapping iterator: addr=%p",
1223                 obj);
1224         BT_LOGD_STR("Putting parent enumeration field type.");
1225         bt_put(&iter->enumeration_type->parent);
1226         g_free(iter);
1227 }
1228
1229 static
1230 struct bt_field_type_enumeration_mapping_iterator *
1231 bt_field_type_enumeration_find_mappings_type(
1232                 struct bt_field_type *type,
1233                 enum bt_field_type_enumeration_mapping_iterator_type iterator_type)
1234 {
1235         struct bt_field_type_enumeration *enumeration_type;
1236         struct bt_field_type_enumeration_mapping_iterator *iter = NULL;
1237
1238         if (!type) {
1239                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
1240                 goto end;
1241         }
1242
1243         if (type->id != BT_FIELD_TYPE_ID_ENUM) {
1244                 BT_LOGW("Invalid parameter: field type is not an enumeration field type: "
1245                         "addr=%p, ft-id=%s", type,
1246                         bt_field_type_id_string(type->id));
1247                 goto end;
1248         }
1249
1250         enumeration_type = container_of(type,
1251                 struct bt_field_type_enumeration, parent);
1252         iter = g_new0(struct bt_field_type_enumeration_mapping_iterator, 1);
1253         if (!iter) {
1254                 BT_LOGE_STR("Failed to allocate one enumeration field type mapping.");
1255                 goto end;
1256         }
1257
1258         bt_object_init(&iter->base, bt_field_type_enum_iter_destroy);
1259         bt_get(type);
1260         iter->enumeration_type = enumeration_type;
1261         iter->index = -1;
1262         iter->type = iterator_type;
1263 end:
1264         return iter;
1265 }
1266
1267 struct bt_field_type_enumeration_mapping_iterator *
1268 bt_field_type_enumeration_find_mappings_by_name(
1269                 struct bt_field_type *type, const char *name)
1270 {
1271         struct bt_field_type_enumeration_mapping_iterator *iter;
1272
1273         iter = bt_field_type_enumeration_find_mappings_type(
1274                         type, ITERATOR_BY_NAME);
1275         if (!iter) {
1276                 BT_LOGE("Cannot create enumeration field type mapping iterator: "
1277                         "ft-addr=%p, mapping-name=\"%s\"", type, name);
1278                 goto error;
1279         }
1280
1281         iter->u.name_quark = g_quark_try_string(name);
1282         if (!iter->u.name_quark) {
1283                 /*
1284                  * No results are possible, set the iterator's position at the
1285                  * end.
1286                  */
1287                 iter->index = iter->enumeration_type->entries->len;
1288         }
1289         return iter;
1290 error:
1291         bt_put(iter);
1292         return NULL;
1293 }
1294
1295 int bt_field_type_enumeration_mapping_iterator_next(
1296                 struct bt_field_type_enumeration_mapping_iterator *iter)
1297 {
1298         struct bt_field_type_enumeration *enumeration;
1299         struct bt_field_type *type;
1300         int i, ret = 0, len;
1301
1302         if (!iter) {
1303                 BT_LOGW_STR("Invalid parameter: enumeration field type mapping iterator is NULL.");
1304                 ret = -1;
1305                 goto end;
1306         }
1307
1308         enumeration = iter->enumeration_type;
1309         type = &enumeration->parent;
1310         len = enumeration->entries->len;
1311         for (i = iter->index + 1; i < len; i++) {
1312                 struct enumeration_mapping *mapping =
1313                         get_enumeration_mapping(type, i);
1314
1315                 switch (iter->type) {
1316                 case ITERATOR_BY_NAME:
1317                         if (mapping->string == iter->u.name_quark) {
1318                                 iter->index = i;
1319                                 goto end;
1320                         }
1321                         break;
1322                 case ITERATOR_BY_SIGNED_VALUE:
1323                 {
1324                         int64_t value = iter->u.signed_value;
1325
1326                         if (value >= mapping->range_start._signed &&
1327                                         value <= mapping->range_end._signed) {
1328                                 iter->index = i;
1329                                 goto end;
1330                         }
1331                         break;
1332                 }
1333                 case ITERATOR_BY_UNSIGNED_VALUE:
1334                 {
1335                         uint64_t value = iter->u.unsigned_value;
1336
1337                         if (value >= mapping->range_start._unsigned &&
1338                                         value <= mapping->range_end._unsigned) {
1339                                 iter->index = i;
1340                                 goto end;
1341                         }
1342                         break;
1343                 }
1344                 default:
1345                         BT_LOGF("Invalid enumeration field type mapping iterator type: "
1346                                 "type=%d", iter->type);
1347                         abort();
1348                 }
1349         }
1350
1351         ret = -1;
1352 end:
1353         return ret;
1354 }
1355
1356 struct bt_field_type_enumeration_mapping_iterator *
1357 bt_field_type_enumeration_find_mappings_by_signed_value(
1358                 struct bt_field_type *type, int64_t value)
1359 {
1360         struct bt_field_type_enumeration_mapping_iterator *iter;
1361
1362         iter = bt_field_type_enumeration_find_mappings_type(
1363                         type, ITERATOR_BY_SIGNED_VALUE);
1364         if (!iter) {
1365                 BT_LOGE("Cannot create enumeration field type mapping iterator: "
1366                         "ft-addr=%p, value=%" PRId64, type, value);
1367                 goto error;
1368         }
1369
1370         if (bt_ctf_field_type_integer_get_signed(
1371                         iter->enumeration_type->container) != 1) {
1372                 BT_LOGW("Invalid parameter: enumeration field type is unsigned: "
1373                         "enum-ft-addr=%p, int-ft-addr=%p",
1374                         type, iter->enumeration_type->container);
1375                 goto error;
1376         }
1377
1378         iter->u.signed_value = value;
1379         return iter;
1380 error:
1381         bt_put(iter);
1382         return NULL;
1383 }
1384
1385 struct bt_field_type_enumeration_mapping_iterator *
1386 bt_field_type_enumeration_find_mappings_by_unsigned_value(
1387                 struct bt_field_type *type, uint64_t value)
1388 {
1389         struct bt_field_type_enumeration_mapping_iterator *iter;
1390
1391         iter = bt_field_type_enumeration_find_mappings_type(
1392                         type, ITERATOR_BY_UNSIGNED_VALUE);
1393         if (!iter) {
1394                 BT_LOGE("Cannot create enumeration field type mapping iterator: "
1395                         "ft-addr=%p, value=%" PRIu64, type, value);
1396                 goto error;
1397         }
1398
1399         if (bt_ctf_field_type_integer_get_signed(
1400                         iter->enumeration_type->container) != 0) {
1401                 BT_LOGW("Invalid parameter: enumeration field type is signed: "
1402                         "enum-ft-addr=%p, int-ft-addr=%p",
1403                         type, iter->enumeration_type->container);
1404                 goto error;
1405         }
1406         iter->u.unsigned_value = value;
1407         return iter;
1408 error:
1409         bt_put(iter);
1410         return NULL;
1411 }
1412
1413 int bt_field_type_enumeration_mapping_iterator_get_signed(
1414                 struct bt_field_type_enumeration_mapping_iterator *iter,
1415                 const char **mapping_name, int64_t *range_begin,
1416                 int64_t *range_end)
1417 {
1418         int ret = 0;
1419
1420         if (!iter) {
1421                 BT_LOGW_STR("Invalid parameter: enumeration field type mapping iterator is NULL.");
1422                 ret = -1;
1423                 goto end;
1424         }
1425
1426         if (iter->index == -1) {
1427                 BT_LOGW_STR("Invalid enumeration field type mapping iterator access: position=-1");
1428                 ret = -1;
1429                 goto end;
1430         }
1431
1432         ret = bt_field_type_enumeration_get_mapping_signed(
1433                         &iter->enumeration_type->parent, iter->index,
1434                         mapping_name, range_begin, range_end);
1435 end:
1436         return ret;
1437 }
1438
1439 int bt_field_type_enumeration_mapping_iterator_get_unsigned(
1440                 struct bt_field_type_enumeration_mapping_iterator *iter,
1441                 const char **mapping_name, uint64_t *range_begin,
1442                 uint64_t *range_end)
1443 {
1444         int ret = 0;
1445
1446         if (!iter) {
1447                 BT_LOGW_STR("Invalid parameter: enumeration field type mapping iterator is NULL.");
1448                 ret = -1;
1449                 goto end;
1450         }
1451
1452         if (iter->index == -1) {
1453                 BT_LOGW_STR("Invalid enumeration field type mapping iterator access: position=-1");
1454                 ret = -1;
1455                 goto end;
1456         }
1457
1458         ret = bt_field_type_enumeration_get_mapping_unsigned(
1459                         &iter->enumeration_type->parent, iter->index,
1460                         mapping_name, range_begin, range_end);
1461 end:
1462         return ret;
1463 }
1464
1465 int bt_field_type_enumeration_get_mapping_signed(
1466                 struct bt_field_type *enum_field_type,
1467                 uint64_t index, const char **mapping_name, int64_t *range_begin,
1468                 int64_t *range_end)
1469 {
1470         int ret = 0;
1471         struct enumeration_mapping *mapping;
1472
1473         if (!enum_field_type) {
1474                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
1475                 ret = -1;
1476                 goto end;
1477         }
1478
1479         mapping = get_enumeration_mapping(enum_field_type, index);
1480         if (!mapping) {
1481                 /* get_enumeration_mapping() reports any error */
1482                 ret = -1;
1483                 goto end;
1484         }
1485
1486         if (mapping_name) {
1487                 *mapping_name = g_quark_to_string(mapping->string);
1488                 assert(*mapping_name);
1489         }
1490
1491         if (range_begin) {
1492                 *range_begin = mapping->range_start._signed;
1493         }
1494
1495         if (range_end) {
1496                 *range_end = mapping->range_end._signed;
1497         }
1498 end:
1499         return ret;
1500 }
1501
1502 int bt_field_type_enumeration_get_mapping_unsigned(
1503                 struct bt_field_type *enum_field_type,
1504                 uint64_t index,
1505                 const char **mapping_name, uint64_t *range_begin,
1506                 uint64_t *range_end)
1507 {
1508         int ret = 0;
1509         struct enumeration_mapping *mapping;
1510
1511         if (!enum_field_type) {
1512                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
1513                 ret = -1;
1514                 goto end;
1515         }
1516
1517         mapping = get_enumeration_mapping(enum_field_type, index);
1518         if (!mapping) {
1519                 /* get_enumeration_mapping() reports any error */
1520                 ret = -1;
1521                 goto end;
1522         }
1523
1524         if (mapping_name) {
1525                 *mapping_name = g_quark_to_string(mapping->string);
1526                 assert(*mapping_name);
1527         }
1528
1529         if (range_begin) {
1530                 *range_begin = mapping->range_start._unsigned;
1531         }
1532
1533         if (range_end) {
1534                 *range_end = mapping->range_end._unsigned;
1535         }
1536 end:
1537         return ret;
1538 }
1539
1540 struct bt_field_type *bt_field_type_enumeration_create(
1541                 struct bt_field_type *integer_container_type)
1542 {
1543         struct bt_field_type_enumeration *enumeration = NULL;
1544
1545         BT_LOGD("Creating enumeration field type object: int-ft-addr=%p",
1546                 integer_container_type);
1547
1548         if (!integer_container_type) {
1549                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
1550                 goto error;
1551         }
1552
1553         if (integer_container_type->id != BT_FIELD_TYPE_ID_INTEGER) {
1554                 BT_LOGW("Invalid parameter: container field type is not an integer field type: "
1555                         "container-ft-addr=%p, container-ft-id=%s",
1556                         integer_container_type,
1557                         bt_field_type_id_string(integer_container_type->id));
1558                 goto error;
1559         }
1560
1561         enumeration = g_new0(struct bt_field_type_enumeration, 1);
1562         if (!enumeration) {
1563                 BT_LOGE_STR("Failed to allocate one enumeration field type.");
1564                 goto error;
1565         }
1566
1567         enumeration->parent.id = BT_FIELD_TYPE_ID_ENUM;
1568         bt_get(integer_container_type);
1569         enumeration->container = integer_container_type;
1570         enumeration->entries = g_ptr_array_new_with_free_func(
1571                 (GDestroyNotify)destroy_enumeration_mapping);
1572         bt_field_type_init(&enumeration->parent, FALSE);
1573         BT_LOGD("Created enumeration field type object: addr=%p, "
1574                 "int-ft-addr=%p, int-ft-size=%u",
1575                 &enumeration->parent, integer_container_type,
1576                 bt_field_type_integer_get_size(integer_container_type));
1577         return &enumeration->parent;
1578 error:
1579         g_free(enumeration);
1580         return NULL;
1581 }
1582
1583 struct bt_field_type *bt_field_type_enumeration_get_container_type(
1584                 struct bt_field_type *type)
1585 {
1586         struct bt_field_type *container_type = NULL;
1587         struct bt_field_type_enumeration *enumeration_type;
1588
1589         if (!type) {
1590                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
1591                 goto end;
1592         }
1593
1594         if (type->id != BT_FIELD_TYPE_ID_ENUM) {
1595                 BT_LOGW("Invalid parameter: field type is not an enumeration field type: "
1596                         "addr=%p, ft-id=%s", type,
1597                         bt_field_type_id_string(type->id));
1598                 goto end;
1599         }
1600
1601         enumeration_type = container_of(type,
1602                 struct bt_field_type_enumeration, parent);
1603         container_type = enumeration_type->container;
1604         bt_get(container_type);
1605 end:
1606         return container_type;
1607 }
1608
1609 int bt_field_type_enumeration_add_mapping_signed(
1610                 struct bt_field_type *type, const char *string,
1611                 int64_t range_start, int64_t range_end)
1612 {
1613         int ret = 0;
1614         GQuark mapping_name;
1615         struct enumeration_mapping *mapping;
1616         struct bt_field_type_enumeration *enumeration;
1617         char *escaped_string;
1618
1619         if (!type) {
1620                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
1621                 ret = -1;
1622                 goto end;
1623         }
1624
1625         if (!string) {
1626                 BT_LOGW_STR("Invalid parameter: string is NULL.");
1627                 ret = -1;
1628                 goto end;
1629         }
1630
1631         if (type->frozen) {
1632                 BT_LOGW("Invalid parameter: field type is frozen: addr=%p",
1633                         type);
1634                 ret = -1;
1635                 goto end;
1636         }
1637
1638         if (type->id != BT_FIELD_TYPE_ID_ENUM) {
1639                 BT_LOGW("Invalid parameter: field type is not an enumeration field type: "
1640                         "addr=%p, ft-id=%s", type,
1641                         bt_field_type_id_string(type->id));
1642                 ret = -1;
1643                 goto end;
1644         }
1645
1646         if (range_end < range_start) {
1647                 BT_LOGW("Invalid parameter: range's end is lesser than range's start: "
1648                         "addr=%p, range-start=%" PRId64 ", range-end=%" PRId64,
1649                         type, range_start, range_end);
1650                 ret = -1;
1651                 goto end;
1652         }
1653
1654         if (strlen(string) == 0) {
1655                 BT_LOGW("Invalid parameter: mapping name is an empty string: "
1656                         "enum-ft-addr=%p, mapping-name-addr=%p", type,
1657                         string);
1658                 ret = -1;
1659                 goto end;
1660         }
1661
1662         escaped_string = g_strescape(string, NULL);
1663         if (!escaped_string) {
1664                 BT_LOGE("Cannot escape mapping name: enum-ft-addr=%p, "
1665                         "mapping-name-addr=%p, mapping-name=\"%s\"",
1666                         type, string, string);
1667                 ret = -1;
1668                 goto end;
1669         }
1670
1671         mapping = g_new(struct enumeration_mapping, 1);
1672         if (!mapping) {
1673                 BT_LOGE_STR("Failed to allocate one enumeration mapping.");
1674                 ret = -1;
1675                 goto error_free;
1676         }
1677         mapping_name = g_quark_from_string(escaped_string);
1678         *mapping = (struct enumeration_mapping) {
1679                 .range_start._signed = range_start,
1680                 .range_end._signed = range_end,
1681                 .string =  mapping_name,
1682         };
1683         enumeration = container_of(type, struct bt_field_type_enumeration,
1684                 parent);
1685         g_ptr_array_add(enumeration->entries, mapping);
1686         g_ptr_array_sort(enumeration->entries,
1687                 (GCompareFunc)compare_enumeration_mappings_signed);
1688         BT_LOGV("Added mapping to signed enumeration field type: addr=%p, "
1689                 "name=\"%s\", range-start=%" PRId64 ", "
1690                 "range-end=%" PRId64,
1691                 type, string, range_start, range_end);
1692 error_free:
1693         free(escaped_string);
1694 end:
1695         return ret;
1696 }
1697
1698 int bt_field_type_enumeration_add_mapping_unsigned(
1699                 struct bt_field_type *type, const char *string,
1700                 uint64_t range_start, uint64_t range_end)
1701 {
1702         int ret = 0;
1703         GQuark mapping_name;
1704         struct enumeration_mapping *mapping;
1705         struct bt_field_type_enumeration *enumeration;
1706         char *escaped_string;
1707
1708         if (!type) {
1709                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
1710                 ret = -1;
1711                 goto end;
1712         }
1713
1714         if (!string) {
1715                 BT_LOGW_STR("Invalid parameter: string is NULL.");
1716                 ret = -1;
1717                 goto end;
1718         }
1719
1720         if (type->frozen) {
1721                 BT_LOGW("Invalid parameter: field type is frozen: addr=%p",
1722                         type);
1723                 ret = -1;
1724                 goto end;
1725         }
1726
1727         if (type->id != BT_FIELD_TYPE_ID_ENUM) {
1728                 BT_LOGW("Invalid parameter: field type is not an enumeration field type: "
1729                         "addr=%p, ft-id=%s", type,
1730                         bt_field_type_id_string(type->id));
1731                 ret = -1;
1732                 goto end;
1733         }
1734
1735         if (range_end < range_start) {
1736                 BT_LOGW("Invalid parameter: range's end is lesser than range's start: "
1737                         "addr=%p, range-start=%" PRIu64 ", range-end=%" PRIu64,
1738                         type, range_start, range_end);
1739                 ret = -1;
1740                 goto end;
1741         }
1742
1743         if (strlen(string) == 0) {
1744                 BT_LOGW("Invalid parameter: mapping name is an empty string: "
1745                         "enum-ft-addr=%p, mapping-name-addr=%p", type,
1746                         string);
1747                 ret = -1;
1748                 goto end;
1749         }
1750
1751         escaped_string = g_strescape(string, NULL);
1752         if (!escaped_string) {
1753                 BT_LOGE("Cannot escape mapping name: enum-ft-addr=%p, "
1754                         "mapping-name-addr=%p, mapping-name=\"%s\"",
1755                         type, string, string);
1756                 ret = -1;
1757                 goto end;
1758         }
1759
1760         mapping = g_new(struct enumeration_mapping, 1);
1761         if (!mapping) {
1762                 BT_LOGE_STR("Failed to allocate one enumeration mapping.");
1763                 ret = -1;
1764                 goto error_free;
1765         }
1766         mapping_name = g_quark_from_string(escaped_string);
1767         *mapping = (struct enumeration_mapping) {
1768                 .range_start._unsigned = range_start,
1769                 .range_end._unsigned = range_end,
1770                 .string = mapping_name,
1771         };
1772         enumeration = container_of(type, struct bt_field_type_enumeration,
1773                 parent);
1774         g_ptr_array_add(enumeration->entries, mapping);
1775         g_ptr_array_sort(enumeration->entries,
1776                 (GCompareFunc)compare_enumeration_mappings_unsigned);
1777         BT_LOGV("Added mapping to unsigned enumeration field type: addr=%p, "
1778                 "name=\"%s\", range-start=%" PRIu64 ", "
1779                 "range-end=%" PRIu64,
1780                 type, string, range_start, range_end);
1781 error_free:
1782         free(escaped_string);
1783 end:
1784         return ret;
1785 }
1786
1787 int64_t bt_field_type_enumeration_get_mapping_count(
1788                 struct bt_field_type *type)
1789 {
1790         int64_t ret = 0;
1791         struct bt_field_type_enumeration *enumeration;
1792
1793         if (!type) {
1794                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
1795                 ret = (int64_t) -1;
1796                 goto end;
1797         }
1798
1799         if (type->id != BT_FIELD_TYPE_ID_ENUM) {
1800                 BT_LOGW("Invalid parameter: field type is not an enumeration field type: "
1801                         "addr=%p, ft-id=%s", type,
1802                         bt_field_type_id_string(type->id));
1803                 ret = (int64_t) -1;
1804                 goto end;
1805         }
1806
1807         enumeration = container_of(type, struct bt_field_type_enumeration,
1808                 parent);
1809         ret = (int64_t) enumeration->entries->len;
1810 end:
1811         return ret;
1812 }
1813
1814 struct bt_field_type *bt_field_type_floating_point_create(void)
1815 {
1816         struct bt_field_type_floating_point *floating_point =
1817                 g_new0(struct bt_field_type_floating_point, 1);
1818
1819         BT_LOGD_STR("Creating floating point number field type object.");
1820
1821         if (!floating_point) {
1822                 BT_LOGE_STR("Failed to allocate one floating point number field type.");
1823                 goto end;
1824         }
1825
1826         floating_point->parent.id = BT_FIELD_TYPE_ID_FLOAT;
1827         floating_point->exp_dig = sizeof(float) * CHAR_BIT - FLT_MANT_DIG;
1828         floating_point->mant_dig = FLT_MANT_DIG;
1829         bt_field_type_init(&floating_point->parent, TRUE);
1830         BT_LOGD("Created floating point number field type object: addr=%p, "
1831                 "exp-size=%u, mant-size=%u", &floating_point->parent,
1832                 floating_point->exp_dig, floating_point->mant_dig);
1833 end:
1834         return floating_point ? &floating_point->parent : NULL;
1835 }
1836
1837 int bt_field_type_floating_point_get_exponent_digits(
1838                 struct bt_field_type *type)
1839 {
1840         int ret = 0;
1841         struct bt_field_type_floating_point *floating_point;
1842
1843         if (!type) {
1844                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
1845                 ret = -1;
1846                 goto end;
1847         }
1848
1849         if (type->id != BT_FIELD_TYPE_ID_FLOAT) {
1850                 BT_LOGW("Invalid parameter: field type is not a floating point number field type: "
1851                         "addr=%p, ft-id=%s", type,
1852                         bt_field_type_id_string(type->id));
1853                 ret = -1;
1854                 goto end;
1855         }
1856
1857         floating_point = container_of(type,
1858                 struct bt_field_type_floating_point, parent);
1859         ret = (int) floating_point->exp_dig;
1860 end:
1861         return ret;
1862 }
1863
1864 int bt_field_type_floating_point_set_exponent_digits(
1865                 struct bt_field_type *type,
1866                 unsigned int exponent_digits)
1867 {
1868         int ret = 0;
1869         struct bt_field_type_floating_point *floating_point;
1870
1871         if (!type) {
1872                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
1873                 ret = -1;
1874                 goto end;
1875         }
1876
1877         if (type->frozen) {
1878                 BT_LOGW("Invalid parameter: field type is frozen: addr=%p",
1879                         type);
1880                 ret = -1;
1881                 goto end;
1882         }
1883
1884         if (type->id != BT_FIELD_TYPE_ID_FLOAT) {
1885                 BT_LOGW("Invalid parameter: field type is not a floating point number field type: "
1886                         "addr=%p, ft-id=%s", type,
1887                         bt_field_type_id_string(type->id));
1888                 ret = -1;
1889                 goto end;
1890         }
1891
1892         floating_point = container_of(type,
1893                 struct bt_field_type_floating_point, parent);
1894         if ((exponent_digits != sizeof(float) * CHAR_BIT - FLT_MANT_DIG) &&
1895                 (exponent_digits != sizeof(double) * CHAR_BIT - DBL_MANT_DIG) &&
1896                 (exponent_digits !=
1897                         sizeof(long double) * CHAR_BIT - LDBL_MANT_DIG)) {
1898                 BT_LOGW("Invalid parameter: invalid exponent size: "
1899                         "addr=%p, exp-size=%u", type, exponent_digits);
1900                 ret = -1;
1901                 goto end;
1902         }
1903
1904         floating_point->exp_dig = exponent_digits;
1905         BT_LOGV("Set floating point number field type's exponent size: addr=%p, "
1906                 "exp-size=%u", type, exponent_digits);
1907 end:
1908         return ret;
1909 }
1910
1911 int bt_field_type_floating_point_get_mantissa_digits(
1912                 struct bt_field_type *type)
1913 {
1914         int ret = 0;
1915         struct bt_field_type_floating_point *floating_point;
1916
1917         if (!type) {
1918                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
1919                 ret = -1;
1920                 goto end;
1921         }
1922
1923         if (type->id != BT_FIELD_TYPE_ID_FLOAT) {
1924                 BT_LOGW("Invalid parameter: field type is not a floating point number field type: "
1925                         "addr=%p, ft-id=%s", type,
1926                         bt_field_type_id_string(type->id));
1927                 ret = -1;
1928                 goto end;
1929         }
1930
1931         floating_point = container_of(type,
1932                 struct bt_field_type_floating_point, parent);
1933         ret = (int) floating_point->mant_dig;
1934 end:
1935         return ret;
1936 }
1937
1938 int bt_field_type_floating_point_set_mantissa_digits(
1939                 struct bt_field_type *type,
1940                 unsigned int mantissa_digits)
1941 {
1942         int ret = 0;
1943         struct bt_field_type_floating_point *floating_point;
1944
1945         if (!type) {
1946                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
1947                 ret = -1;
1948                 goto end;
1949         }
1950
1951         if (type->frozen) {
1952                 BT_LOGW("Invalid parameter: field type is frozen: addr=%p",
1953                         type);
1954                 ret = -1;
1955                 goto end;
1956         }
1957
1958         if (type->id != BT_FIELD_TYPE_ID_FLOAT) {
1959                 BT_LOGW("Invalid parameter: field type is not a floating point number field type: "
1960                         "addr=%p, ft-id=%s", type,
1961                         bt_field_type_id_string(type->id));
1962                 ret = -1;
1963                 goto end;
1964         }
1965
1966         floating_point = container_of(type,
1967                 struct bt_field_type_floating_point, parent);
1968
1969         if ((mantissa_digits != FLT_MANT_DIG) &&
1970                 (mantissa_digits != DBL_MANT_DIG) &&
1971                 (mantissa_digits != LDBL_MANT_DIG)) {
1972                 BT_LOGW("Invalid parameter: invalid mantissa size: "
1973                         "addr=%p, mant-size=%u", type, mantissa_digits);
1974                 ret = -1;
1975                 goto end;
1976         }
1977
1978         floating_point->mant_dig = mantissa_digits;
1979         BT_LOGV("Set floating point number field type's mantissa size: addr=%p, "
1980                 "mant-size=%u", type, mantissa_digits);
1981 end:
1982         return ret;
1983 }
1984
1985 struct bt_field_type *bt_field_type_structure_create(void)
1986 {
1987         struct bt_field_type_structure *structure =
1988                 g_new0(struct bt_field_type_structure, 1);
1989
1990         BT_LOGD_STR("Creating structure field type object.");
1991
1992         if (!structure) {
1993                 BT_LOGE_STR("Failed to allocate one structure field type.");
1994                 goto error;
1995         }
1996
1997         structure->parent.id = BT_FIELD_TYPE_ID_STRUCT;
1998         structure->fields = g_ptr_array_new_with_free_func(
1999                 (GDestroyNotify)destroy_structure_field);
2000         structure->field_name_to_index = g_hash_table_new(NULL, NULL);
2001         bt_field_type_init(&structure->parent, TRUE);
2002         BT_LOGD("Created structure field type object: addr=%p",
2003                 &structure->parent);
2004         return &structure->parent;
2005 error:
2006         return NULL;
2007 }
2008
2009 int bt_field_type_structure_add_field(struct bt_field_type *type,
2010                 struct bt_field_type *field_type,
2011                 const char *field_name)
2012 {
2013         int ret = 0;
2014         struct bt_field_type_structure *structure;
2015
2016         /*
2017          * TODO: check that `field_type` does not contain `type`,
2018          *       recursively.
2019          */
2020         if (!type) {
2021                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2022                 ret = -1;
2023                 goto end;
2024         }
2025
2026         if (!field_name) {
2027                 BT_LOGW_STR("Invalid parameter: field name is NULL.");
2028                 ret = -1;
2029                 goto end;
2030         }
2031
2032         if (type->frozen) {
2033                 BT_LOGW("Invalid parameter: field type is frozen: addr=%p",
2034                         type);
2035                 ret = -1;
2036                 goto end;
2037         }
2038
2039         if (type->id != BT_FIELD_TYPE_ID_STRUCT) {
2040                 BT_LOGW("Invalid parameter: field type is not a structure field type: "
2041                         "addr=%p, ft-id=%s", type,
2042                         bt_field_type_id_string(type->id));
2043                 ret = -1;
2044                 goto end;
2045         }
2046
2047         if (type == field_type) {
2048                 BT_LOGW("Invalid parameter: structure field type and field type to add are the same: "
2049                         "addr=%p", type);
2050                 ret = -1;
2051                 goto end;
2052         }
2053
2054         structure = container_of(type,
2055                 struct bt_field_type_structure, parent);
2056         if (add_structure_field(structure->fields,
2057                         structure->field_name_to_index, field_type, field_name)) {
2058                 BT_LOGW("Cannot add field to structure field type: "
2059                         "struct-ft-addr=%p, field-ft-addr=%p, field-name=\"%s\"",
2060                         type, field_type, field_name);
2061                 ret = -1;
2062                 goto end;
2063         }
2064
2065         BT_LOGV("Added structure field type field: struct-ft-addr=%p, "
2066                 "field-ft-addr=%p, field-name=\"%s\"", type,
2067                 field_type, field_name);
2068 end:
2069         return ret;
2070 }
2071
2072 int64_t bt_field_type_structure_get_field_count(
2073                 struct bt_field_type *type)
2074 {
2075         int64_t ret = 0;
2076         struct bt_field_type_structure *structure;
2077
2078         if (!type) {
2079                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2080                 ret = (int64_t) -1;
2081                 goto end;
2082         }
2083
2084         if (type->id != BT_FIELD_TYPE_ID_STRUCT) {
2085                 BT_LOGW("Invalid parameter: field type is not a structure field type: "
2086                         "addr=%p, ft-id=%s", type,
2087                         bt_field_type_id_string(type->id));
2088                 ret = (int64_t) -1;
2089                 goto end;
2090         }
2091
2092         structure = container_of(type, struct bt_field_type_structure,
2093                 parent);
2094         ret = (int64_t) structure->fields->len;
2095 end:
2096         return ret;
2097 }
2098
2099 int bt_field_type_structure_get_field_by_index(
2100                 struct bt_field_type *type,
2101                 const char **field_name, struct bt_field_type **field_type,
2102                 uint64_t index)
2103 {
2104         struct bt_field_type_structure *structure;
2105         struct structure_field *field;
2106         int ret = 0;
2107
2108         if (!type) {
2109                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2110                 ret = -1;
2111                 goto end;
2112         }
2113
2114         if (type->id != BT_FIELD_TYPE_ID_STRUCT) {
2115                 BT_LOGW("Invalid parameter: field type is not a structure field type: "
2116                         "addr=%p, ft-id=%s", type,
2117                         bt_field_type_id_string(type->id));
2118                 ret = -1;
2119                 goto end;
2120         }
2121
2122         structure = container_of(type, struct bt_field_type_structure,
2123                 parent);
2124         if (index >= structure->fields->len) {
2125                 BT_LOGW("Invalid parameter: index is out of bounds: "
2126                         "addr=%p, index=%" PRIu64 ", count=%u",
2127                         type, index, structure->fields->len);
2128                 ret = -1;
2129                 goto end;
2130         }
2131
2132         field = g_ptr_array_index(structure->fields, index);
2133         if (field_type) {
2134                 *field_type = field->type;
2135                 bt_get(field->type);
2136         }
2137         if (field_name) {
2138                 *field_name = g_quark_to_string(field->name);
2139                 assert(*field_name);
2140         }
2141 end:
2142         return ret;
2143 }
2144
2145 struct bt_field_type *bt_field_type_structure_get_field_type_by_name(
2146                 struct bt_field_type *type,
2147                 const char *name)
2148 {
2149         size_t index;
2150         GQuark name_quark;
2151         struct structure_field *field;
2152         struct bt_field_type_structure *structure;
2153         struct bt_field_type *field_type = NULL;
2154
2155         if (!type) {
2156                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2157                 goto end;
2158         }
2159
2160         if (!name) {
2161                 BT_LOGW_STR("Invalid parameter: name is NULL.");
2162                 goto end;
2163         }
2164
2165         name_quark = g_quark_try_string(name);
2166         if (!name_quark) {
2167                 BT_LOGV("No such structure field type field name: "
2168                         "ft-addr=%p, field-name=\"%s\"",
2169                         type, name);
2170                 goto end;
2171         }
2172
2173         structure = container_of(type, struct bt_field_type_structure,
2174                 parent);
2175         if (!g_hash_table_lookup_extended(structure->field_name_to_index,
2176                         GUINT_TO_POINTER(name_quark), NULL, (gpointer *)&index)) {
2177                 BT_LOGV("No such structure field type field name: "
2178                         "ft-addr=%p, field-name=\"%s\"",
2179                         type, name);
2180                 goto end;
2181         }
2182
2183         field = structure->fields->pdata[index];
2184         field_type = field->type;
2185         bt_get(field_type);
2186 end:
2187         return field_type;
2188 }
2189
2190 struct bt_field_type *bt_field_type_variant_create(
2191         struct bt_field_type *enum_tag, const char *tag_name)
2192 {
2193         struct bt_field_type_variant *variant = NULL;
2194
2195         BT_LOGD("Creating variant field type object: "
2196                 "tag-ft-addr=%p, tag-field-name=\"%s\"",
2197                 enum_tag, tag_name);
2198
2199         if (tag_name && !bt_identifier_is_valid(tag_name)) {
2200                 BT_LOGW("Invalid parameter: tag field name is not a valid CTF identifier: "
2201                         "tag-ft-addr=%p, tag-field-name=\"%s\"",
2202                         enum_tag, tag_name);
2203                 goto error;
2204         }
2205
2206         variant = g_new0(struct bt_field_type_variant, 1);
2207         if (!variant) {
2208                 BT_LOGE_STR("Failed to allocate one variant field type.");
2209                 goto error;
2210         }
2211
2212         variant->parent.id = BT_FIELD_TYPE_ID_VARIANT;
2213         variant->tag_name = g_string_new(tag_name);
2214         variant->field_name_to_index = g_hash_table_new(NULL, NULL);
2215         variant->fields = g_ptr_array_new_with_free_func(
2216                 (GDestroyNotify) destroy_structure_field);
2217         if (enum_tag) {
2218                 bt_get(enum_tag);
2219                 variant->tag = container_of(enum_tag,
2220                         struct bt_field_type_enumeration, parent);
2221         }
2222
2223         bt_field_type_init(&variant->parent, TRUE);
2224         /* A variant's alignment is undefined */
2225         variant->parent.alignment = 0;
2226         BT_LOGD("Created variant field type object: addr=%p, "
2227                 "tag-ft-addr=%p, tag-field-name=\"%s\"",
2228                 &variant->parent, enum_tag, tag_name);
2229         return &variant->parent;
2230 error:
2231         return NULL;
2232 }
2233
2234 struct bt_field_type *bt_field_type_variant_get_tag_type(
2235                 struct bt_field_type *type)
2236 {
2237         struct bt_field_type_variant *variant;
2238         struct bt_field_type *tag_type = NULL;
2239
2240         if (!type) {
2241                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2242                 goto end;
2243         }
2244
2245         if (type->id != BT_FIELD_TYPE_ID_VARIANT) {
2246                 BT_LOGW("Invalid parameter: field type is not a variant field type: "
2247                         "addr=%p, ft-id=%s", type,
2248                         bt_field_type_id_string(type->id));
2249                 goto end;
2250         }
2251
2252         variant = container_of(type, struct bt_field_type_variant, parent);
2253         if (!variant->tag) {
2254                 BT_LOGV("Variant field type has no tag field type: "
2255                         "addr=%p", type);
2256                 goto end;
2257         }
2258
2259         tag_type = &variant->tag->parent;
2260         bt_get(tag_type);
2261 end:
2262         return tag_type;
2263 }
2264
2265 const char *bt_field_type_variant_get_tag_name(
2266                 struct bt_field_type *type)
2267 {
2268         struct bt_field_type_variant *variant;
2269         const char *tag_name = NULL;
2270
2271         if (!type) {
2272                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2273                 goto end;
2274         }
2275
2276         if (type->id != BT_FIELD_TYPE_ID_VARIANT) {
2277                 BT_LOGW("Invalid parameter: field type is not a variant field type: "
2278                         "addr=%p, ft-id=%s", type,
2279                         bt_field_type_id_string(type->id));
2280                 goto end;
2281         }
2282
2283         variant = container_of(type, struct bt_field_type_variant, parent);
2284         if (variant->tag_name->len == 0) {
2285                 BT_LOGV("Variant field type has no tag field name: "
2286                         "addr=%p", type);
2287                 goto end;
2288         }
2289
2290         tag_name = variant->tag_name->str;
2291 end:
2292         return tag_name;
2293 }
2294
2295 int bt_field_type_variant_set_tag_name(
2296                 struct bt_field_type *type, const char *name)
2297 {
2298         int ret = 0;
2299         struct bt_field_type_variant *variant;
2300
2301         if (!type) {
2302                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2303                 ret = -1;
2304                 goto end;
2305         }
2306
2307         if (type->frozen) {
2308                 BT_LOGW("Invalid parameter: field type is frozen: addr=%p",
2309                         type);
2310                 ret = -1;
2311                 goto end;
2312         }
2313
2314         if (type->id != BT_FIELD_TYPE_ID_VARIANT) {
2315                 BT_LOGW("Invalid parameter: field type is not a variant field type: "
2316                         "addr=%p, ft-id=%s", type,
2317                         bt_field_type_id_string(type->id));
2318                 ret = -1;
2319                 goto end;
2320         }
2321
2322         if (!bt_identifier_is_valid(name)) {
2323                 BT_LOGW("Invalid parameter: tag field name is not a valid CTF identifier: "
2324                         "variant-ft-addr=%p, tag-field-name=\"%s\"",
2325                         type, name);
2326                 ret = -1;
2327                 goto end;
2328         }
2329
2330         variant = container_of(type, struct bt_field_type_variant, parent);
2331         g_string_assign(variant->tag_name, name);
2332         BT_LOGV("Set variant field type's tag field name: addr=%p, "
2333                 "tag-field-name=\"%s\"", type, name);
2334 end:
2335         return ret;
2336 }
2337
2338 int bt_field_type_variant_add_field(struct bt_field_type *type,
2339                 struct bt_field_type *field_type,
2340                 const char *field_name)
2341 {
2342         size_t i;
2343         int ret = 0;
2344         struct bt_field_type_variant *variant;
2345         GQuark field_name_quark = g_quark_from_string(field_name);
2346
2347         /*
2348          * TODO: check that `field_type` does not contain `type`,
2349          *       recursively.
2350          */
2351         if (!type) {
2352                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2353                 ret = -1;
2354                 goto end;
2355         }
2356
2357         if (type->frozen) {
2358                 BT_LOGW("Invalid parameter: field type is frozen: addr=%p",
2359                         type);
2360                 ret = -1;
2361                 goto end;
2362         }
2363
2364         if (type->id != BT_FIELD_TYPE_ID_VARIANT) {
2365                 BT_LOGW("Invalid parameter: field type is not a variant field type: "
2366                         "addr=%p, ft-id=%s", type,
2367                         bt_field_type_id_string(type->id));
2368                 ret = -1;
2369                 goto end;
2370         }
2371
2372         if (type == field_type) {
2373                 BT_LOGW("Invalid parameter: variant field type and field type to add are the same: "
2374                         "addr=%p", type);
2375                 ret = -1;
2376                 goto end;
2377         }
2378
2379         variant = container_of(type, struct bt_field_type_variant, parent);
2380
2381         /* The user has explicitly provided a tag; validate against it. */
2382         if (variant->tag) {
2383                 int name_found = 0;
2384
2385                 /* Make sure this name is present in the enum tag */
2386                 for (i = 0; i < variant->tag->entries->len; i++) {
2387                         struct enumeration_mapping *mapping =
2388                                 g_ptr_array_index(variant->tag->entries, i);
2389
2390                         if (mapping->string == field_name_quark) {
2391                                 name_found = 1;
2392                                 break;
2393                         }
2394                 }
2395
2396                 if (!name_found) {
2397                         /* Validation failed */
2398                         BT_LOGW("Invalid parameter: field name does not name a tag field type's mapping: "
2399                                 "variant-ft-addr=%p, tag-ft-addr=%p, "
2400                                 "tag-field-name=\"%s\""
2401                                 "field-ft-addr=%p, field-name=\"%s\"",
2402                                 type, variant->tag, variant->tag_name->str,
2403                                 field_type, field_name);
2404                         ret = -1;
2405                         goto end;
2406                 }
2407         }
2408
2409         if (add_structure_field(variant->fields, variant->field_name_to_index,
2410                         field_type, field_name)) {
2411                 BT_LOGW("Cannot add field to variant field type: "
2412                         "variant-ft-addr=%p, field-ft-addr=%p, field-name=\"%s\"",
2413                         type, field_type, field_name);
2414                 ret = -1;
2415                 goto end;
2416         }
2417
2418         BT_LOGV("Added variant field type field: variant-ft-addr=%p, "
2419                 "field-ft-addr=%p, field-name=\"%s\"", type,
2420                 field_type, field_name);
2421
2422 end:
2423         return ret;
2424 }
2425
2426 struct bt_field_type *bt_field_type_variant_get_field_type_by_name(
2427                 struct bt_field_type *type,
2428                 const char *field_name)
2429 {
2430         size_t index;
2431         GQuark name_quark;
2432         struct structure_field *field;
2433         struct bt_field_type_variant *variant;
2434         struct bt_field_type *field_type = NULL;
2435
2436         if (!type) {
2437                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2438                 goto end;
2439         }
2440
2441         if (!field_name) {
2442                 BT_LOGW_STR("Invalid parameter: field name is NULL.");
2443                 goto end;
2444         }
2445
2446         name_quark = g_quark_try_string(field_name);
2447         if (!name_quark) {
2448                 BT_LOGV("No such variant field type field name: "
2449                         "ft-addr=%p, field-name=\"%s\"",
2450                         type, field_name);
2451                 goto end;
2452         }
2453
2454         variant = container_of(type, struct bt_field_type_variant, parent);
2455         if (!g_hash_table_lookup_extended(variant->field_name_to_index,
2456                         GUINT_TO_POINTER(name_quark), NULL, (gpointer *)&index)) {
2457                 BT_LOGV("No such variant field type field name: "
2458                         "ft-addr=%p, field-name=\"%s\"",
2459                         type, field_name);
2460                 goto end;
2461         }
2462
2463         field = g_ptr_array_index(variant->fields, index);
2464         field_type = field->type;
2465         bt_get(field_type);
2466 end:
2467         return field_type;
2468 }
2469
2470 struct bt_field_type *bt_field_type_variant_get_field_type_from_tag(
2471                 struct bt_field_type *type,
2472                 struct bt_field *tag)
2473 {
2474         int ret;
2475         const char *enum_value;
2476         struct bt_field_type *field_type = NULL;
2477         struct bt_field_type_enumeration_mapping_iterator *iter = NULL;
2478
2479         if (!type) {
2480                 BT_LOGW_STR("Invalid parameter: variant field type is NULL.");
2481                 goto end;
2482         }
2483
2484         if (!tag) {
2485                 BT_LOGW_STR("Invalid parameter: tag field is NULL.");
2486                 goto end;
2487         }
2488
2489         if (type->id != BT_FIELD_TYPE_ID_VARIANT) {
2490                 BT_LOGW("Invalid parameter: field type is not a variant field type: "
2491                         "addr=%p, ft-id=%s", type,
2492                         bt_field_type_id_string(type->id));
2493                 goto end;
2494         }
2495
2496         iter = bt_field_enumeration_get_mappings(tag);
2497         ret = bt_field_type_enumeration_mapping_iterator_next(iter);
2498         if (!iter || ret) {
2499                 BT_LOGE("Cannot get enumeration field type mapping iterator from enumeration field: "
2500                         "enum-field-addr=%p", tag);
2501                 goto end;
2502         }
2503
2504         ret = bt_field_type_enumeration_mapping_iterator_get_signed(iter,
2505                 &enum_value, NULL, NULL);
2506         if (ret) {
2507                 BT_LOGW("Cannot get enumeration field type mapping iterator's current mapping: "
2508                         "iter-addr=%p", iter);
2509                 goto end;
2510         }
2511
2512         field_type = bt_field_type_variant_get_field_type_by_name(
2513                 type, enum_value);
2514 end:
2515         bt_put(iter);
2516         return field_type;
2517 }
2518
2519 int64_t bt_field_type_variant_get_field_count(struct bt_field_type *type)
2520 {
2521         int64_t ret = 0;
2522         struct bt_field_type_variant *variant;
2523
2524         if (!type) {
2525                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2526                 ret = (int64_t) -1;
2527                 goto end;
2528         }
2529
2530         if (type->id != BT_FIELD_TYPE_ID_VARIANT) {
2531                 BT_LOGW("Invalid parameter: field type is not a variant field type: "
2532                         "addr=%p, ft-id=%s", type,
2533                         bt_field_type_id_string(type->id));
2534                 ret = (int64_t) -1;
2535                 goto end;
2536         }
2537
2538         variant = container_of(type, struct bt_field_type_variant,
2539                 parent);
2540         ret = (int64_t) variant->fields->len;
2541 end:
2542         return ret;
2543
2544 }
2545
2546 int bt_field_type_variant_get_field_by_index(struct bt_field_type *type,
2547                 const char **field_name, struct bt_field_type **field_type,
2548                 uint64_t index)
2549 {
2550         struct bt_field_type_variant *variant;
2551         struct structure_field *field;
2552         int ret = 0;
2553
2554         if (!type) {
2555                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2556                 ret = -1;
2557                 goto end;
2558         }
2559
2560         if (type->id != BT_FIELD_TYPE_ID_VARIANT) {
2561                 BT_LOGW("Invalid parameter: field type is not a variant field type: "
2562                         "addr=%p, ft-id=%s", type,
2563                         bt_field_type_id_string(type->id));
2564                 ret = -1;
2565                 goto end;
2566         }
2567
2568         variant = container_of(type, struct bt_field_type_variant,
2569                 parent);
2570         if (index >= variant->fields->len) {
2571                 BT_LOGW("Invalid parameter: index is out of bounds: "
2572                         "addr=%p, index=%" PRIu64 ", count=%u",
2573                         type, index, variant->fields->len);
2574                 ret = -1;
2575                 goto end;
2576         }
2577
2578         field = g_ptr_array_index(variant->fields, index);
2579         if (field_type) {
2580                 *field_type = field->type;
2581                 bt_get(field->type);
2582         }
2583         if (field_name) {
2584                 *field_name = g_quark_to_string(field->name);
2585                 assert(*field_name);
2586         }
2587 end:
2588         return ret;
2589 }
2590
2591 struct bt_field_type *bt_field_type_array_create(
2592                 struct bt_field_type *element_type,
2593                 unsigned int length)
2594 {
2595         struct bt_field_type_array *array = NULL;
2596
2597         BT_LOGD("Creating array field type object: element-ft-addr=%p, "
2598                 "length=%u", element_type, length);
2599
2600         if (!element_type) {
2601                 BT_LOGW_STR("Invalid parameter: element field type is NULL.");
2602                 goto error;
2603         }
2604
2605         if (length == 0) {
2606                 BT_LOGW_STR("Invalid parameter: length is zero.");
2607                 goto error;
2608         }
2609
2610         array = g_new0(struct bt_field_type_array, 1);
2611         if (!array) {
2612                 BT_LOGE_STR("Failed to allocate one array field type.");
2613                 goto error;
2614         }
2615
2616         array->parent.id = BT_FIELD_TYPE_ID_ARRAY;
2617         bt_get(element_type);
2618         array->element_type = element_type;
2619         array->length = length;
2620         bt_field_type_init(&array->parent, FALSE);
2621         BT_LOGD("Created array field type object: addr=%p, "
2622                 "element-ft-addr=%p, length=%u",
2623                 &array->parent, element_type, length);
2624         return &array->parent;
2625 error:
2626         return NULL;
2627 }
2628
2629 struct bt_field_type *bt_field_type_array_get_element_type(
2630                 struct bt_field_type *type)
2631 {
2632         struct bt_field_type *ret = NULL;
2633         struct bt_field_type_array *array;
2634
2635         if (!type) {
2636                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2637                 goto end;
2638         }
2639
2640         if (type->id != BT_FIELD_TYPE_ID_ARRAY) {
2641                 BT_LOGW("Invalid parameter: field type is not an array field type: "
2642                         "addr=%p, ft-id=%s", type,
2643                         bt_field_type_id_string(type->id));
2644                 goto end;
2645         }
2646
2647         array = container_of(type, struct bt_field_type_array, parent);
2648         ret = array->element_type;
2649         bt_get(ret);
2650 end:
2651         return ret;
2652 }
2653
2654 BT_HIDDEN
2655 int bt_field_type_array_set_element_type(struct bt_field_type *type,
2656                 struct bt_field_type *element_type)
2657 {
2658         int ret = 0;
2659         struct bt_field_type_array *array;
2660
2661         if (!type) {
2662                 BT_LOGW_STR("Invalid parameter: array field type is NULL.");
2663                 ret = -1;
2664                 goto end;
2665         }
2666
2667         if (!element_type) {
2668                 BT_LOGW_STR("Invalid parameter: element field type is NULL.");
2669                 ret = -1;
2670                 goto end;
2671         }
2672
2673         if (type->id != BT_FIELD_TYPE_ID_ARRAY) {
2674                 BT_LOGW("Invalid parameter: field type is not an array field type: "
2675                         "addr=%p, ft-id=%s", type,
2676                         bt_field_type_id_string(type->id));
2677                 ret = -1;
2678                 goto end;
2679         }
2680
2681         array = container_of(type, struct bt_field_type_array, parent);
2682
2683         if (array->element_type) {
2684                 BT_PUT(array->element_type);
2685         }
2686
2687         array->element_type = element_type;
2688         bt_get(array->element_type);
2689         BT_LOGV("Set array field type's element field type: array-ft-addr=%p, "
2690                 "element-ft-addr=%p", type, element_type);
2691
2692 end:
2693         return ret;
2694 }
2695
2696 int64_t bt_field_type_array_get_length(struct bt_field_type *type)
2697 {
2698         int64_t ret;
2699         struct bt_field_type_array *array;
2700
2701         if (!type) {
2702                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2703                 ret = (int64_t) -1;
2704                 goto end;
2705         }
2706
2707         if (type->id != BT_FIELD_TYPE_ID_ARRAY) {
2708                 BT_LOGW("Invalid parameter: field type is not an array field type: "
2709                         "addr=%p, ft-id=%s", type,
2710                         bt_field_type_id_string(type->id));
2711                 ret = (int64_t) -1;
2712                 goto end;
2713         }
2714
2715         array = container_of(type, struct bt_field_type_array, parent);
2716         ret = (int64_t) array->length;
2717 end:
2718         return ret;
2719 }
2720
2721 struct bt_field_type *bt_field_type_sequence_create(
2722                 struct bt_field_type *element_type,
2723                 const char *length_field_name)
2724 {
2725         struct bt_field_type_sequence *sequence = NULL;
2726
2727         BT_LOGD("Creating sequence field type object: element-ft-addr=%p, "
2728                 "length-field-name=\"%s\"", element_type, length_field_name);
2729
2730         if (!element_type) {
2731                 BT_LOGW_STR("Invalid parameter: element field type is NULL.");
2732                 goto error;
2733         }
2734
2735         if (!bt_identifier_is_valid(length_field_name)) {
2736                 BT_LOGW("Invalid parameter: length field name is not a valid CTF identifier: "
2737                         "length-field-name=\"%s\"", length_field_name);
2738                 goto error;
2739         }
2740
2741         sequence = g_new0(struct bt_field_type_sequence, 1);
2742         if (!sequence) {
2743                 BT_LOGE_STR("Failed to allocate one sequence field type.");
2744                 goto error;
2745         }
2746
2747         sequence->parent.id = BT_FIELD_TYPE_ID_SEQUENCE;
2748         bt_get(element_type);
2749         sequence->element_type = element_type;
2750         sequence->length_field_name = g_string_new(length_field_name);
2751         bt_field_type_init(&sequence->parent, FALSE);
2752         BT_LOGD("Created sequence field type object: addr=%p, "
2753                 "element-ft-addr=%p, length-field-name=\"%s\"",
2754                 &sequence->parent, element_type, length_field_name);
2755         return &sequence->parent;
2756 error:
2757         return NULL;
2758 }
2759
2760 struct bt_field_type *bt_field_type_sequence_get_element_type(
2761                 struct bt_field_type *type)
2762 {
2763         struct bt_field_type *ret = NULL;
2764         struct bt_field_type_sequence *sequence;
2765
2766         if (!type) {
2767                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2768                 goto end;
2769         }
2770
2771         if (type->id != BT_FIELD_TYPE_ID_SEQUENCE) {
2772                 BT_LOGW("Invalid parameter: field type is not a sequence field type: "
2773                         "addr=%p, ft-id=%s", type,
2774                         bt_field_type_id_string(type->id));
2775                 goto end;
2776         }
2777
2778         sequence = container_of(type, struct bt_field_type_sequence,
2779                 parent);
2780         ret = sequence->element_type;
2781         bt_get(ret);
2782 end:
2783         return ret;
2784 }
2785
2786 BT_HIDDEN
2787 int bt_field_type_sequence_set_element_type(struct bt_field_type *type,
2788                 struct bt_field_type *element_type)
2789 {
2790         int ret = 0;
2791         struct bt_field_type_sequence *sequence;
2792
2793         if (!type) {
2794                 BT_LOGW_STR("Invalid parameter: sequence field type is NULL.");
2795                 ret = -1;
2796                 goto end;
2797         }
2798
2799         if (!element_type) {
2800                 BT_LOGW_STR("Invalid parameter: element field type is NULL.");
2801                 ret = -1;
2802                 goto end;
2803         }
2804
2805         if (type->id != BT_FIELD_TYPE_ID_SEQUENCE) {
2806                 BT_LOGW("Invalid parameter: field type is not a sequence field type: "
2807                         "addr=%p, ft-id=%s", type,
2808                         bt_field_type_id_string(type->id));
2809                 ret = -1;
2810                 goto end;
2811         }
2812
2813         sequence = container_of(type, struct bt_field_type_sequence, parent);
2814         if (sequence->element_type) {
2815                 BT_PUT(sequence->element_type);
2816         }
2817
2818         sequence->element_type = element_type;
2819         bt_get(sequence->element_type);
2820         BT_LOGV("Set sequence field type's element field type: sequence-ft-addr=%p, "
2821                 "element-ft-addr=%p", type, element_type);
2822
2823 end:
2824         return ret;
2825 }
2826
2827 const char *bt_field_type_sequence_get_length_field_name(
2828                 struct bt_field_type *type)
2829 {
2830         const char *ret = NULL;
2831         struct bt_field_type_sequence *sequence;
2832
2833         if (!type) {
2834                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2835                 goto end;
2836         }
2837
2838         if (type->id != BT_FIELD_TYPE_ID_SEQUENCE) {
2839                 BT_LOGW("Invalid parameter: field type is not a sequence field type: "
2840                         "addr=%p, ft-id=%s", type,
2841                         bt_field_type_id_string(type->id));
2842                 goto end;
2843         }
2844
2845         sequence = container_of(type, struct bt_field_type_sequence,
2846                 parent);
2847         ret = sequence->length_field_name->str;
2848 end:
2849         return ret;
2850 }
2851
2852 struct bt_field_type *bt_field_type_string_create(void)
2853 {
2854         struct bt_field_type_string *string =
2855                 g_new0(struct bt_field_type_string, 1);
2856
2857         BT_LOGD_STR("Creating string field type object.");
2858
2859         if (!string) {
2860                 BT_LOGE_STR("Failed to allocate one string field type.");
2861                 return NULL;
2862         }
2863
2864         string->parent.id = BT_FIELD_TYPE_ID_STRING;
2865         bt_field_type_init(&string->parent, TRUE);
2866         string->encoding = BT_STRING_ENCODING_UTF8;
2867         string->parent.alignment = CHAR_BIT;
2868         BT_LOGD("Created string field type object: addr=%p", &string->parent);
2869         return &string->parent;
2870 }
2871
2872 enum bt_string_encoding bt_field_type_string_get_encoding(
2873                 struct bt_field_type *type)
2874 {
2875         struct bt_field_type_string *string;
2876         enum bt_string_encoding ret = BT_STRING_ENCODING_UNKNOWN;
2877
2878         if (!type) {
2879                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2880                 goto end;
2881         }
2882
2883         if (type->id != BT_FIELD_TYPE_ID_STRING) {
2884                 BT_LOGW("Invalid parameter: field type is not a string field type: "
2885                         "addr=%p, ft-id=%s", type,
2886                         bt_field_type_id_string(type->id));
2887                 goto end;
2888         }
2889
2890         string = container_of(type, struct bt_field_type_string,
2891                 parent);
2892         ret = string->encoding;
2893 end:
2894         return ret;
2895 }
2896
2897 int bt_field_type_string_set_encoding(struct bt_field_type *type,
2898                 enum bt_string_encoding encoding)
2899 {
2900         int ret = 0;
2901         struct bt_field_type_string *string;
2902
2903         if (!type) {
2904                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2905                 ret = -1;
2906                 goto end;
2907         }
2908
2909         if (type->id != BT_FIELD_TYPE_ID_STRING) {
2910                 BT_LOGW("Invalid parameter: field type is not a string field type: "
2911                         "addr=%p, ft-id=%s", type,
2912                         bt_field_type_id_string(type->id));
2913                 ret = -1;
2914                 goto end;
2915         }
2916
2917         if (encoding != BT_STRING_ENCODING_UTF8 &&
2918                         encoding != BT_STRING_ENCODING_ASCII) {
2919                 BT_LOGW("Invalid parameter: unknown string encoding: "
2920                         "addr=%p, encoding=%d", type, encoding);
2921                 ret = -1;
2922                 goto end;
2923         }
2924
2925         string = container_of(type, struct bt_field_type_string, parent);
2926         string->encoding = encoding;
2927         BT_LOGV("Set string field type's encoding: addr=%p, encoding=%s",
2928                 type, bt_string_encoding_string(encoding));
2929 end:
2930         return ret;
2931 }
2932
2933 int bt_field_type_get_alignment(struct bt_field_type *type)
2934 {
2935         int ret;
2936         enum bt_field_type_id type_id;
2937
2938         if (!type) {
2939                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2940                 ret = -1;
2941                 goto end;
2942         }
2943
2944         if (type->frozen) {
2945                 ret = (int) type->alignment;
2946                 goto end;
2947         }
2948
2949         type_id = bt_field_type_get_type_id(type);
2950         switch (type_id) {
2951         case BT_FIELD_TYPE_ID_SEQUENCE:
2952         {
2953                 struct bt_field_type *element =
2954                         bt_field_type_sequence_get_element_type(type);
2955
2956                 assert(element);
2957                 ret = bt_field_type_get_alignment(element);
2958                 bt_put(element);
2959                 break;
2960         }
2961         case BT_FIELD_TYPE_ID_ARRAY:
2962         {
2963                 struct bt_field_type *element =
2964                         bt_field_type_array_get_element_type(type);
2965
2966                 assert(element);
2967                 ret = bt_field_type_get_alignment(element);
2968                 bt_put(element);
2969                 break;
2970         }
2971         case BT_FIELD_TYPE_ID_STRUCT:
2972         {
2973                 int64_t i, element_count;
2974
2975                 element_count = bt_field_type_structure_get_field_count(
2976                         type);
2977                 assert(element_count >= 0);
2978
2979                 for (i = 0; i < element_count; i++) {
2980                         struct bt_field_type *field = NULL;
2981                         int field_alignment;
2982
2983                         ret = bt_field_type_structure_get_field_by_index(
2984                                 type, NULL, &field, i);
2985                         assert(ret == 0);
2986                         assert(field);
2987                         field_alignment = bt_field_type_get_alignment(
2988                                 field);
2989                         bt_put(field);
2990                         if (field_alignment < 0) {
2991                                 ret = field_alignment;
2992                                 goto end;
2993                         }
2994
2995                         type->alignment = MAX(field_alignment, type->alignment);
2996                 }
2997                 ret = (int) type->alignment;
2998                 break;
2999         }
3000         case BT_FIELD_TYPE_ID_ENUM:
3001         {
3002                 struct bt_field_type *container =
3003                         bt_field_type_enumeration_get_container_type(type);
3004
3005                 ret = bt_field_type_get_alignment(container);
3006                 bt_put(container);
3007                 break;
3008         }
3009         case BT_FIELD_TYPE_ID_UNKNOWN:
3010                 BT_LOGW("Invalid parameter: unknown field type ID: "
3011                         "addr=%p, ft-id=%d", type, type_id);
3012                 ret = -1;
3013                 break;
3014         default:
3015                 ret = (int) type->alignment;
3016                 break;
3017         }
3018 end:
3019         return ret;
3020 }
3021
3022 static inline
3023 int is_power_of_two(unsigned int value)
3024 {
3025         return ((value & (value - 1)) == 0) && value > 0;
3026 }
3027
3028 int bt_field_type_set_alignment(struct bt_field_type *type,
3029                 unsigned int alignment)
3030 {
3031         int ret = 0;
3032         enum bt_field_type_id type_id;
3033
3034         /* Alignment must be a power of two */
3035         if (!type) {
3036                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
3037                 ret = -1;
3038                 goto end;
3039         }
3040
3041         if (type->frozen) {
3042                 BT_LOGW("Invalid parameter: field type is frozen: addr=%p",
3043                         type);
3044                 ret = -1;
3045                 goto end;
3046         }
3047
3048         if (!is_power_of_two(alignment)) {
3049                 BT_LOGW("Invalid parameter: alignment is not a power of two: "
3050                         "addr=%p, align=%u", type, alignment);
3051                 ret = -1;
3052                 goto end;
3053         }
3054
3055         type_id = bt_field_type_get_type_id(type);
3056         if (type_id == BT_FIELD_TYPE_ID_UNKNOWN) {
3057                 BT_LOGW("Invalid parameter: unknown field type ID: "
3058                         "addr=%p, ft-id=%d", type, type_id);
3059                 ret = -1;
3060                 goto end;
3061         }
3062
3063         if (type->id == BT_FIELD_TYPE_ID_STRING &&
3064                         alignment != CHAR_BIT) {
3065                 BT_LOGW("Invalid parameter: alignment must be %u for a string field type: "
3066                         "addr=%p, align=%u", CHAR_BIT, type, alignment);
3067                 ret = -1;
3068                 goto end;
3069         }
3070
3071         if (type_id == BT_FIELD_TYPE_ID_VARIANT ||
3072                         type_id == BT_FIELD_TYPE_ID_SEQUENCE ||
3073                         type_id == BT_FIELD_TYPE_ID_ARRAY) {
3074                 /* Setting an alignment on these types makes no sense */
3075                 BT_LOGW("Invalid parameter: cannot set the alignment of this field type: "
3076                         "addr=%p, ft-id=%s", type,
3077                         bt_field_type_id_string(type->id));
3078                 ret = -1;
3079                 goto end;
3080         }
3081
3082         type->alignment = alignment;
3083         ret = 0;
3084         BT_LOGV("Set field type's alignment: addr=%p, align=%u",
3085                 type, alignment);
3086 end:
3087         return ret;
3088 }
3089
3090 enum bt_byte_order bt_field_type_get_byte_order(
3091                 struct bt_field_type *type)
3092 {
3093         enum bt_byte_order ret = BT_BYTE_ORDER_UNKNOWN;
3094
3095         if (!type) {
3096                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
3097                 goto end;
3098         }
3099
3100         switch (type->id) {
3101         case BT_FIELD_TYPE_ID_INTEGER:
3102         {
3103                 struct bt_field_type_integer *integer = container_of(
3104                         type, struct bt_field_type_integer, parent);
3105                 ret = integer->user_byte_order;
3106                 break;
3107         }
3108         case BT_FIELD_TYPE_ID_ENUM:
3109         {
3110                 struct bt_field_type_enumeration *enum_ft = container_of(
3111                         type, struct bt_field_type_enumeration, parent);
3112                 ret = bt_field_type_get_byte_order(enum_ft->container);
3113                 break;
3114         }
3115         case BT_FIELD_TYPE_ID_FLOAT:
3116         {
3117                 struct bt_field_type_floating_point *floating_point =
3118                         container_of(type,
3119                                 struct bt_field_type_floating_point,
3120                                 parent);
3121                 ret = floating_point->user_byte_order;
3122                 break;
3123         }
3124         default:
3125                 BT_LOGW("Invalid parameter: cannot get the byte order of this field type: "
3126                         "addr=%p, ft-id=%s", type,
3127                         bt_field_type_id_string(type->id));
3128                 goto end;
3129         }
3130
3131         assert(ret == BT_BYTE_ORDER_NATIVE ||
3132                 ret == BT_BYTE_ORDER_LITTLE_ENDIAN ||
3133                 ret == BT_BYTE_ORDER_BIG_ENDIAN ||
3134                 ret == BT_BYTE_ORDER_NETWORK);
3135
3136 end:
3137         return ret;
3138 }
3139
3140 int bt_field_type_set_byte_order(struct bt_field_type *type,
3141                 enum bt_byte_order byte_order)
3142 {
3143         int ret = 0;
3144
3145         if (!type) {
3146                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
3147                 ret = -1;
3148                 goto end;
3149         }
3150
3151         if (type->frozen) {
3152                 BT_LOGW("Invalid parameter: field type is frozen: addr=%p",
3153                         type);
3154                 ret = -1;
3155                 goto end;
3156         }
3157
3158         if (byte_order != BT_BYTE_ORDER_NATIVE &&
3159                         byte_order != BT_BYTE_ORDER_LITTLE_ENDIAN &&
3160                         byte_order != BT_BYTE_ORDER_BIG_ENDIAN &&
3161                         byte_order != BT_BYTE_ORDER_NETWORK) {
3162                 BT_LOGW("Invalid parameter: invalid byte order: "
3163                         "addr=%p, bo=%s", type,
3164                         bt_byte_order_string(byte_order));
3165                 ret = -1;
3166                 goto end;
3167         }
3168
3169         if (set_byte_order_funcs[type->id]) {
3170                 set_byte_order_funcs[type->id](type, byte_order);
3171         }
3172
3173         BT_LOGV("Set field type's byte order: addr=%p, bo=%s",
3174                 type, bt_byte_order_string(byte_order));
3175
3176 end:
3177         return ret;
3178 }
3179
3180 enum bt_field_type_id bt_field_type_get_type_id(
3181                 struct bt_field_type *type)
3182 {
3183         if (!type) {
3184                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
3185                 return BT_FIELD_TYPE_ID_UNKNOWN;
3186         }
3187
3188         return type->id;
3189 }
3190
3191 int bt_field_type_is_integer(struct bt_field_type *type)
3192 {
3193         return bt_field_type_get_type_id(type) == BT_FIELD_TYPE_ID_INTEGER;
3194 }
3195
3196 int bt_field_type_is_floating_point(struct bt_field_type *type)
3197 {
3198         return bt_field_type_get_type_id(type) == BT_FIELD_TYPE_ID_FLOAT;
3199 }
3200
3201 int bt_field_type_is_enumeration(struct bt_field_type *type)
3202 {
3203         return bt_field_type_get_type_id(type) == BT_FIELD_TYPE_ID_ENUM;
3204 }
3205
3206 int bt_field_type_is_string(struct bt_field_type *type)
3207 {
3208         return bt_field_type_get_type_id(type) == BT_FIELD_TYPE_ID_STRING;
3209 }
3210
3211 int bt_field_type_is_structure(struct bt_field_type *type)
3212 {
3213         return bt_field_type_get_type_id(type) == BT_FIELD_TYPE_ID_STRUCT;
3214 }
3215
3216 int bt_field_type_is_array(struct bt_field_type *type)
3217 {
3218         return bt_field_type_get_type_id(type) == BT_FIELD_TYPE_ID_ARRAY;
3219 }
3220
3221 int bt_field_type_is_sequence(struct bt_field_type *type)
3222 {
3223         return bt_field_type_get_type_id(type) == BT_FIELD_TYPE_ID_SEQUENCE;
3224 }
3225
3226 int bt_field_type_is_variant(struct bt_field_type *type)
3227 {
3228         return bt_field_type_get_type_id(type) == BT_FIELD_TYPE_ID_VARIANT;
3229 }
3230
3231 /* Pre-2.0 CTF writer backward compatibility */
3232 void bt_ctf_field_type_get(struct bt_field_type *type)
3233 {
3234         bt_get(type);
3235 }
3236
3237 /* Pre-2.0 CTF writer backward compatibility */
3238 void bt_ctf_field_type_put(struct bt_field_type *type)
3239 {
3240         bt_put(type);
3241 }
3242
3243 BT_HIDDEN
3244 void bt_field_type_freeze(struct bt_field_type *type)
3245 {
3246         if (!type || type->frozen) {
3247                 return;
3248         }
3249
3250         type->freeze(type);
3251 }
3252
3253 BT_HIDDEN
3254 struct bt_field_type *bt_field_type_variant_get_field_type_signed(
3255                 struct bt_field_type_variant *variant,
3256                 int64_t tag_value)
3257 {
3258         struct bt_field_type *type = NULL;
3259         GQuark field_name_quark;
3260         gpointer index;
3261         struct structure_field *field_entry;
3262         struct range_overlap_query query = {
3263                 .range_start._signed = tag_value,
3264                 .range_end._signed = tag_value,
3265                 .mapping_name = 0,
3266                 .overlaps = 0,
3267         };
3268
3269         g_ptr_array_foreach(variant->tag->entries, check_ranges_overlap,
3270                 &query);
3271         if (!query.overlaps) {
3272                 goto end;
3273         }
3274
3275         field_name_quark = query.mapping_name;
3276         if (!g_hash_table_lookup_extended(variant->field_name_to_index,
3277                         GUINT_TO_POINTER(field_name_quark), NULL, &index)) {
3278                 goto end;
3279         }
3280
3281         field_entry = g_ptr_array_index(variant->fields, (size_t) index);
3282         type = field_entry->type;
3283 end:
3284         return type;
3285 }
3286
3287 BT_HIDDEN
3288 struct bt_field_type *bt_field_type_variant_get_field_type_unsigned(
3289                 struct bt_field_type_variant *variant,
3290                 uint64_t tag_value)
3291 {
3292         struct bt_field_type *type = NULL;
3293         GQuark field_name_quark;
3294         gpointer index;
3295         struct structure_field *field_entry;
3296         struct range_overlap_query query = {
3297                 .range_start._unsigned = tag_value,
3298                 .range_end._unsigned = tag_value,
3299                 .mapping_name = 0,
3300                 .overlaps = 0,
3301         };
3302
3303         g_ptr_array_foreach(variant->tag->entries,
3304                 check_ranges_overlap_unsigned,
3305                 &query);
3306         if (!query.overlaps) {
3307                 goto end;
3308         }
3309
3310         field_name_quark = query.mapping_name;
3311         if (!g_hash_table_lookup_extended(variant->field_name_to_index,
3312                 GUINT_TO_POINTER(field_name_quark), NULL, &index)) {
3313                 goto end;
3314         }
3315
3316         field_entry = g_ptr_array_index(variant->fields, (size_t)index);
3317         type = field_entry->type;
3318 end:
3319         return type;
3320 }
3321
3322 BT_HIDDEN
3323 int bt_field_type_serialize(struct bt_field_type *type,
3324                 struct metadata_context *context)
3325 {
3326         int ret;
3327
3328         assert(type);
3329         assert(context);
3330
3331         /* Make sure field type is valid before serializing it */
3332         ret = bt_field_type_validate(type);
3333         if (ret) {
3334                 BT_LOGW("Cannot serialize field type's metadata: field type is invalid: "
3335                         "addr=%p", type);
3336                 goto end;
3337         }
3338
3339         ret = type->serialize(type, context);
3340 end:
3341         return ret;
3342 }
3343
3344 struct bt_field_type *bt_field_type_copy(struct bt_field_type *type)
3345 {
3346         struct bt_field_type *copy = NULL;
3347
3348         if (!type) {
3349                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
3350                 goto end;
3351         }
3352
3353         copy = type_copy_funcs[type->id](type);
3354         if (!copy) {
3355                 BT_LOGE_STR("Cannot copy field type.");
3356                 goto end;
3357         }
3358
3359         copy->alignment = type->alignment;
3360 end:
3361         return copy;
3362 }
3363
3364 BT_HIDDEN
3365 int bt_field_type_structure_get_field_name_index(
3366                 struct bt_field_type *type, const char *name)
3367 {
3368         int ret;
3369         size_t index;
3370         GQuark name_quark;
3371         struct bt_field_type_structure *structure;
3372
3373         if (!type) {
3374                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
3375                 ret = -1;
3376                 goto end;
3377         }
3378
3379         if (!name) {
3380                 BT_LOGW_STR("Invalid parameter: field name is NULL.");
3381                 ret = -1;
3382                 goto end;
3383         }
3384
3385         if (bt_field_type_get_type_id(type) != BT_FIELD_TYPE_ID_STRUCT) {
3386                 BT_LOGW("Invalid parameter: field type is not a structure field type: "
3387                         "addr=%p, ft-id=%s", type,
3388                         bt_field_type_id_string(type->id));
3389                 ret = -1;
3390                 goto end;
3391         }
3392
3393         name_quark = g_quark_try_string(name);
3394         if (!name_quark) {
3395                 BT_LOGV("No such structure field type field name: "
3396                         "ft-addr=%p, field-name=\"%s\"",
3397                         type, name);
3398                 ret = -1;
3399                 goto end;
3400         }
3401
3402         structure = container_of(type, struct bt_field_type_structure,
3403                 parent);
3404         if (!g_hash_table_lookup_extended(structure->field_name_to_index,
3405                         GUINT_TO_POINTER(name_quark),
3406                         NULL, (gpointer *)&index)) {
3407                 BT_LOGV("No such structure field type field name: "
3408                         "ft-addr=%p, field-name=\"%s\"",
3409                         type, name);
3410                 ret = -1;
3411                 goto end;
3412         }
3413         ret = (int) index;
3414 end:
3415         return ret;
3416 }
3417
3418 BT_HIDDEN
3419 int bt_field_type_variant_get_field_name_index(
3420                 struct bt_field_type *type, const char *name)
3421 {
3422         int ret;
3423         size_t index;
3424         GQuark name_quark;
3425         struct bt_field_type_variant *variant;
3426
3427         if (!type) {
3428                 BT_LOGW_STR("Invalid parameter: variant field type is NULL.");
3429                 ret = -1;
3430                 goto end;
3431         }
3432
3433         if (!name) {
3434                 BT_LOGW_STR("Invalid parameter: field name is NULL.");
3435                 ret = -1;
3436                 goto end;
3437         }
3438
3439         if (bt_field_type_get_type_id(type) != BT_FIELD_TYPE_ID_VARIANT) {
3440                 BT_LOGW("Invalid parameter: field type is not a variant field type: "
3441                         "addr=%p, ft-id=%s", type,
3442                         bt_field_type_id_string(type->id));
3443                 ret = -1;
3444                 goto end;
3445         }
3446
3447         name_quark = g_quark_try_string(name);
3448         if (!name_quark) {
3449                 BT_LOGV("No such variant field type field name: "
3450                         "ft-addr=%p, field-name=\"%s\"",
3451                         type, name);
3452                 ret = -1;
3453                 goto end;
3454         }
3455
3456         variant = container_of(type, struct bt_field_type_variant,
3457                 parent);
3458         if (!g_hash_table_lookup_extended(variant->field_name_to_index,
3459                         GUINT_TO_POINTER(name_quark),
3460                         NULL, (gpointer *)&index)) {
3461                 BT_LOGV("No such variant field type field name: "
3462                         "ft-addr=%p, field-name=\"%s\"",
3463                         type, name);
3464                 ret = -1;
3465                 goto end;
3466         }
3467         ret = (int) index;
3468 end:
3469         return ret;
3470 }
3471
3472 BT_HIDDEN
3473 int bt_field_type_sequence_set_length_field_path(
3474                 struct bt_field_type *type,
3475                 struct bt_field_path *path)
3476 {
3477         int ret = 0;
3478         struct bt_field_type_sequence *sequence;
3479
3480         if (!type) {
3481                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
3482                 ret = -1;
3483                 goto end;
3484         }
3485
3486         if (bt_field_type_get_type_id(type) != BT_FIELD_TYPE_ID_SEQUENCE) {
3487                 BT_LOGW("Invalid parameter: field type is not a sequence field type: "
3488                         "addr=%p, ft-id=%s", type,
3489                         bt_field_type_id_string(type->id));
3490                 ret = -1;
3491                 goto end;
3492         }
3493
3494         sequence = container_of(type, struct bt_field_type_sequence,
3495                 parent);
3496         bt_get(path);
3497         BT_MOVE(sequence->length_field_path, path);
3498         BT_LOGV("Set sequence field type's length field path: ft-addr=%p, "
3499                 "field-path-addr=%p", type, path);
3500 end:
3501         return ret;
3502 }
3503
3504 BT_HIDDEN
3505 int bt_field_type_variant_set_tag_field_path(struct bt_field_type *type,
3506                 struct bt_field_path *path)
3507 {
3508         int ret = 0;
3509         struct bt_field_type_variant *variant;
3510
3511         if (!type) {
3512                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
3513                 ret = -1;
3514                 goto end;
3515         }
3516
3517         if (bt_field_type_get_type_id(type) != BT_FIELD_TYPE_ID_VARIANT) {
3518                 BT_LOGW("Invalid parameter: field type is not a variant field type: "
3519                         "addr=%p, ft-id=%s", type,
3520                         bt_field_type_id_string(type->id));
3521                 ret = -1;
3522                 goto end;
3523         }
3524
3525         variant = container_of(type, struct bt_field_type_variant,
3526                 parent);
3527         bt_get(path);
3528         BT_MOVE(variant->tag_field_path, path);
3529         BT_LOGV("Set variant field type's tag field path: ft-addr=%p, "
3530                 "field-path-addr=%p", type, path);
3531 end:
3532         return ret;
3533 }
3534
3535 BT_HIDDEN
3536 int bt_field_type_variant_set_tag_field_type(struct bt_field_type *type,
3537                 struct bt_field_type *tag)
3538 {
3539         int ret = 0;
3540         struct bt_field_type_variant *variant;
3541
3542         if (!type) {
3543                 BT_LOGW_STR("Invalid parameter: variant field type is NULL.");
3544                 ret = -1;
3545                 goto end;
3546         }
3547
3548         if (!tag) {
3549                 BT_LOGW_STR("Invalid parameter: tag field type is NULL.");
3550                 ret = -1;
3551                 goto end;
3552         }
3553
3554         if (bt_field_type_get_type_id(tag) != BT_FIELD_TYPE_ID_ENUM) {
3555                 BT_LOGW("Invalid parameter: field type is not an enumeration field type: "
3556                         "addr=%p, ft-id=%s", type,
3557                         bt_field_type_id_string(type->id));
3558                 ret = -1;
3559                 goto end;
3560         }
3561
3562         variant = container_of(type, struct bt_field_type_variant,
3563                 parent);
3564         bt_get(tag);
3565         if (variant->tag) {
3566                 bt_put(&variant->tag->parent);
3567         }
3568         variant->tag = container_of(tag, struct bt_field_type_enumeration,
3569                 parent);
3570         BT_LOGV("Set variant field type's tag field type: variant-ft-addr=%p, "
3571                 "tag-ft-addr=%p", type, tag);
3572 end:
3573         return ret;
3574 }
3575
3576 static
3577 void bt_field_type_integer_destroy(struct bt_field_type *type)
3578 {
3579         struct bt_field_type_integer *integer =
3580                 (struct bt_field_type_integer *) type;
3581
3582         if (!type) {
3583                 return;
3584         }
3585
3586         BT_LOGD("Destroying integer field type object: addr=%p", type);
3587         BT_LOGD_STR("Putting mapped clock class.");
3588         bt_put(integer->mapped_clock);
3589         g_free(integer);
3590 }
3591
3592 static
3593 void bt_field_type_enumeration_destroy(struct bt_field_type *type)
3594 {
3595         struct bt_field_type_enumeration *enumeration =
3596                 (struct bt_field_type_enumeration *) type;
3597
3598         if (!type) {
3599                 return;
3600         }
3601
3602         BT_LOGD("Destroying enumeration field type object: addr=%p", type);
3603         g_ptr_array_free(enumeration->entries, TRUE);
3604         BT_LOGD_STR("Putting container field type.");
3605         bt_put(enumeration->container);
3606         g_free(enumeration);
3607 }
3608
3609 static
3610 void bt_field_type_floating_point_destroy(struct bt_field_type *type)
3611 {
3612         struct bt_field_type_floating_point *floating_point =
3613                 (struct bt_field_type_floating_point *) type;
3614
3615         if (!type) {
3616                 return;
3617         }
3618
3619         BT_LOGD("Destroying floating point number field type object: addr=%p", type);
3620         g_free(floating_point);
3621 }
3622
3623 static
3624 void bt_field_type_structure_destroy(struct bt_field_type *type)
3625 {
3626         struct bt_field_type_structure *structure =
3627                 (struct bt_field_type_structure *) type;
3628
3629         if (!type) {
3630                 return;
3631         }
3632
3633         BT_LOGD("Destroying structure field type object: addr=%p", type);
3634         g_ptr_array_free(structure->fields, TRUE);
3635         g_hash_table_destroy(structure->field_name_to_index);
3636         g_free(structure);
3637 }
3638
3639 static
3640 void bt_field_type_variant_destroy(struct bt_field_type *type)
3641 {
3642         struct bt_field_type_variant *variant =
3643                 (struct bt_field_type_variant *) type;
3644
3645         if (!type) {
3646                 return;
3647         }
3648
3649         BT_LOGD("Destroying variant field type object: addr=%p", type);
3650         g_ptr_array_free(variant->fields, TRUE);
3651         g_hash_table_destroy(variant->field_name_to_index);
3652         g_string_free(variant->tag_name, TRUE);
3653         BT_LOGD_STR("Putting tag field type.");
3654         bt_put(&variant->tag->parent);
3655         BT_PUT(variant->tag_field_path);
3656         g_free(variant);
3657 }
3658
3659 static
3660 void bt_field_type_array_destroy(struct bt_field_type *type)
3661 {
3662         struct bt_field_type_array *array =
3663                 (struct bt_field_type_array *) type;
3664
3665         if (!type) {
3666                 return;
3667         }
3668
3669         BT_LOGD("Destroying array field type object: addr=%p", type);
3670         BT_LOGD_STR("Putting element field type.");
3671         bt_put(array->element_type);
3672         g_free(array);
3673 }
3674
3675 static
3676 void bt_field_type_sequence_destroy(struct bt_field_type *type)
3677 {
3678         struct bt_field_type_sequence *sequence =
3679                 (struct bt_field_type_sequence *) type;
3680
3681         if (!type) {
3682                 return;
3683         }
3684
3685         BT_LOGD("Destroying sequence field type object: addr=%p", type);
3686         BT_LOGD_STR("Putting element field type.");
3687         bt_put(sequence->element_type);
3688         g_string_free(sequence->length_field_name, TRUE);
3689         BT_LOGD_STR("Putting length field path.");
3690         BT_PUT(sequence->length_field_path);
3691         g_free(sequence);
3692 }
3693
3694 static
3695 void bt_field_type_string_destroy(struct bt_field_type *type)
3696 {
3697         struct bt_field_type_string *string =
3698                 (struct bt_field_type_string *) type;
3699
3700         if (!type) {
3701                 return;
3702         }
3703
3704         BT_LOGD("Destroying string field type object: addr=%p", type);
3705         g_free(string);
3706 }
3707
3708 static
3709 void generic_field_type_freeze(struct bt_field_type *type)
3710 {
3711         type->frozen = 1;
3712 }
3713
3714 static
3715 void bt_field_type_integer_freeze(struct bt_field_type *type)
3716 {
3717         struct bt_field_type_integer *integer_type = container_of(
3718                 type, struct bt_field_type_integer, parent);
3719
3720         BT_LOGD("Freezing integer field type object: addr=%p", type);
3721
3722         if (integer_type->mapped_clock) {
3723                 BT_LOGD_STR("Freezing integer field type's mapped clock class.");
3724                 bt_clock_class_freeze(integer_type->mapped_clock);
3725         }
3726
3727         generic_field_type_freeze(type);
3728 }
3729
3730 static
3731 void bt_field_type_enumeration_freeze(struct bt_field_type *type)
3732 {
3733         struct bt_field_type_enumeration *enumeration_type = container_of(
3734                 type, struct bt_field_type_enumeration, parent);
3735
3736         BT_LOGD("Freezing enumeration field type object: addr=%p", type);
3737         type->alignment = bt_field_type_get_alignment(type);
3738         set_enumeration_range_overlap(type);
3739         generic_field_type_freeze(type);
3740         BT_LOGD("Freezing enumeration field type object's container field type: int-ft-addr=%p",
3741                 enumeration_type->container);
3742         bt_field_type_freeze(enumeration_type->container);
3743 }
3744
3745 static
3746 void freeze_structure_field(struct structure_field *field)
3747 {
3748         BT_LOGD("Freezing structure/variant field type field: field-addr=%p, "
3749                 "field-ft-addr=%p, field-name=\"%s\"", field,
3750                 field->type, g_quark_to_string(field->name));
3751         bt_field_type_freeze(field->type);
3752 }
3753
3754 static
3755 void bt_field_type_structure_freeze(struct bt_field_type *type)
3756 {
3757         struct bt_field_type_structure *structure_type = container_of(
3758                 type, struct bt_field_type_structure, parent);
3759
3760         /* Cache the alignment */
3761         BT_LOGD("Freezing structure field type object: addr=%p", type);
3762         type->alignment = bt_field_type_get_alignment(type);
3763         generic_field_type_freeze(type);
3764         g_ptr_array_foreach(structure_type->fields,
3765                 (GFunc) freeze_structure_field, NULL);
3766 }
3767
3768 static
3769 void bt_field_type_variant_freeze(struct bt_field_type *type)
3770 {
3771         struct bt_field_type_variant *variant_type = container_of(
3772                 type, struct bt_field_type_variant, parent);
3773
3774         BT_LOGD("Freezing variant field type object: addr=%p", type);
3775         generic_field_type_freeze(type);
3776         g_ptr_array_foreach(variant_type->fields,
3777                 (GFunc) freeze_structure_field, NULL);
3778 }
3779
3780 static
3781 void bt_field_type_array_freeze(struct bt_field_type *type)
3782 {
3783         struct bt_field_type_array *array_type = container_of(
3784                 type, struct bt_field_type_array, parent);
3785
3786         /* Cache the alignment */
3787         BT_LOGD("Freezing array field type object: addr=%p", type);
3788         type->alignment = bt_field_type_get_alignment(type);
3789         generic_field_type_freeze(type);
3790         BT_LOGD("Freezing array field type object's element field type: element-ft-addr=%p",
3791                 array_type->element_type);
3792         bt_field_type_freeze(array_type->element_type);
3793 }
3794
3795 static
3796 void bt_field_type_sequence_freeze(struct bt_field_type *type)
3797 {
3798         struct bt_field_type_sequence *sequence_type = container_of(
3799                 type, struct bt_field_type_sequence, parent);
3800
3801         /* Cache the alignment */
3802         BT_LOGD("Freezing sequence field type object: addr=%p", type);
3803         type->alignment = bt_field_type_get_alignment(type);
3804         generic_field_type_freeze(type);
3805         BT_LOGD("Freezing sequence field type object's element field type: element-ft-addr=%p",
3806                 sequence_type->element_type);
3807         bt_field_type_freeze(sequence_type->element_type);
3808 }
3809
3810 static
3811 const char *get_encoding_string(enum bt_string_encoding encoding)
3812 {
3813         const char *encoding_string;
3814
3815         switch (encoding) {
3816         case BT_STRING_ENCODING_NONE:
3817                 encoding_string = "none";
3818                 break;
3819         case BT_STRING_ENCODING_ASCII:
3820                 encoding_string = "ASCII";
3821                 break;
3822         case BT_STRING_ENCODING_UTF8:
3823                 encoding_string = "UTF8";
3824                 break;
3825         default:
3826                 encoding_string = "unknown";
3827                 break;
3828         }
3829
3830         return encoding_string;
3831 }
3832
3833 static
3834 const char *get_integer_base_string(enum bt_integer_base base)
3835 {
3836         const char *base_string;
3837
3838         switch (base) {
3839         case BT_INTEGER_BASE_DECIMAL:
3840         case BT_INTEGER_BASE_UNSPECIFIED:
3841                 base_string = "decimal";
3842                 break;
3843         case BT_INTEGER_BASE_HEXADECIMAL:
3844                 base_string = "hexadecimal";
3845                 break;
3846         case BT_INTEGER_BASE_OCTAL:
3847                 base_string = "octal";
3848                 break;
3849         case BT_INTEGER_BASE_BINARY:
3850                 base_string = "binary";
3851                 break;
3852         default:
3853                 base_string = "unknown";
3854                 break;
3855         }
3856
3857         return base_string;
3858 }
3859
3860 static
3861 void append_field_name(struct metadata_context *context,
3862                 const char *name)
3863 {
3864         g_string_append_c(context->string, ' ');
3865
3866         if (!bt_identifier_is_valid(name) || *name == '_') {
3867                 g_string_append_c(context->string, '_');
3868         }
3869
3870         g_string_append(context->string, name);
3871 }
3872
3873 static
3874 int bt_field_type_integer_serialize(struct bt_field_type *type,
3875                 struct metadata_context *context)
3876 {
3877         struct bt_field_type_integer *integer = container_of(type,
3878                 struct bt_field_type_integer, parent);
3879         int ret = 0;
3880
3881         BT_LOGD("Serializing integer field type's metadata: "
3882                 "ft-addr=%p, metadata-context-addr=%p", type, context);
3883         g_string_append_printf(context->string,
3884                 "integer { size = %u; align = %u; signed = %s; encoding = %s; base = %s; byte_order = %s",
3885                 integer->size, type->alignment,
3886                 (integer->is_signed ? "true" : "false"),
3887                 get_encoding_string(integer->encoding),
3888                 get_integer_base_string(integer->base),
3889                 get_byte_order_string(integer->user_byte_order));
3890         if (integer->mapped_clock) {
3891                 const char *clock_name = bt_clock_class_get_name(
3892                         integer->mapped_clock);
3893
3894                 assert(clock_name);
3895                 g_string_append_printf(context->string,
3896                         "; map = clock.%s.value", clock_name);
3897         }
3898
3899         g_string_append(context->string, "; }");
3900         return ret;
3901 }
3902
3903 static
3904 int bt_field_type_enumeration_serialize(struct bt_field_type *type,
3905                 struct metadata_context *context)
3906 {
3907         size_t entry;
3908         int ret;
3909         struct bt_field_type_enumeration *enumeration = container_of(type,
3910                 struct bt_field_type_enumeration, parent);
3911         struct bt_field_type *container_type;
3912         int container_signed;
3913
3914         BT_LOGD("Serializing enumeration field type's metadata: "
3915                 "ft-addr=%p, metadata-context-addr=%p", type, context);
3916         container_type = bt_field_type_enumeration_get_container_type(type);
3917         assert(container_type);
3918         container_signed = bt_ctf_field_type_integer_get_signed(container_type);
3919         assert(container_signed >= 0);
3920         g_string_append(context->string, "enum : ");
3921         BT_LOGD_STR("Serializing enumeration field type's container field type's metadata.");
3922         ret = bt_field_type_serialize(enumeration->container, context);
3923         if (ret) {
3924                 BT_LOGW("Cannot serialize enumeration field type's container field type's metadata: "
3925                         "container-ft-addr=%p", enumeration->container);
3926                 goto end;
3927         }
3928
3929         g_string_append(context->string, " { ");
3930         for (entry = 0; entry < enumeration->entries->len; entry++) {
3931                 struct enumeration_mapping *mapping =
3932                         enumeration->entries->pdata[entry];
3933                 const char *label = g_quark_to_string(mapping->string);
3934
3935                 g_string_append(context->string, "\"");
3936
3937                 if (!bt_identifier_is_valid(label) || label[0] == '_') {
3938                         g_string_append(context->string, "_");
3939                 }
3940
3941                 g_string_append_printf(context->string, "%s\" = ", label);
3942
3943                 if (container_signed) {
3944                         if (mapping->range_start._signed ==
3945                                 mapping->range_end._signed) {
3946                                 g_string_append_printf(context->string,
3947                                         "%" PRId64,
3948                                         mapping->range_start._signed);
3949                         } else {
3950                                 g_string_append_printf(context->string,
3951                                         "%" PRId64 " ... %" PRId64,
3952                                         mapping->range_start._signed,
3953                                         mapping->range_end._signed);
3954                         }
3955                 } else {
3956                         if (mapping->range_start._unsigned ==
3957                                 mapping->range_end._unsigned) {
3958                                 g_string_append_printf(context->string,
3959                                         "%" PRIu64,
3960                                         mapping->range_start._unsigned);
3961                         } else {
3962                                 g_string_append_printf(context->string,
3963                                         "%" PRIu64 " ... %" PRIu64,
3964                                         mapping->range_start._unsigned,
3965                                         mapping->range_end._unsigned);
3966                         }
3967                 }
3968
3969                 g_string_append(context->string,
3970                         ((entry != (enumeration->entries->len - 1)) ?
3971                         ", " : " }"));
3972         }
3973
3974         if (context->field_name->len) {
3975                 append_field_name(context,
3976                         context->field_name->str);
3977                 g_string_assign(context->field_name, "");
3978         }
3979 end:
3980         bt_put(container_type);
3981         return ret;
3982 }
3983
3984 static
3985 int bt_field_type_floating_point_serialize(struct bt_field_type *type,
3986                 struct metadata_context *context)
3987 {
3988         struct bt_field_type_floating_point *floating_point = container_of(
3989                 type, struct bt_field_type_floating_point, parent);
3990
3991         BT_LOGD("Serializing floating point number field type's metadata: "
3992                 "ft-addr=%p, metadata-context-addr=%p", type, context);
3993         g_string_append_printf(context->string,
3994                 "floating_point { exp_dig = %u; mant_dig = %u; byte_order = %s; align = %u; }",
3995                 floating_point->exp_dig,
3996                 floating_point->mant_dig,
3997                 get_byte_order_string(floating_point->user_byte_order),
3998                 type->alignment);
3999         return 0;
4000 }
4001
4002 static
4003 int bt_field_type_structure_serialize(struct bt_field_type *type,
4004                 struct metadata_context *context)
4005 {
4006         size_t i;
4007         unsigned int indent;
4008         int ret = 0;
4009         struct bt_field_type_structure *structure = container_of(type,
4010                 struct bt_field_type_structure, parent);
4011         GString *structure_field_name = context->field_name;
4012
4013         BT_LOGD("Serializing structure field type's metadata: "
4014                 "ft-addr=%p, metadata-context-addr=%p", type, context);
4015         context->field_name = g_string_new("");
4016
4017         context->current_indentation_level++;
4018         g_string_append(context->string, "struct {\n");
4019
4020         for (i = 0; i < structure->fields->len; i++) {
4021                 struct structure_field *field = structure->fields->pdata[i];
4022
4023                 BT_LOGD("Serializing structure field type's field metadata: "
4024                         "index=%zu, "
4025                         "field-ft-addr=%p, field-name=\"%s\"",
4026                         i, field, g_quark_to_string(field->name));
4027
4028                 for (indent = 0; indent < context->current_indentation_level;
4029                         indent++) {
4030                         g_string_append_c(context->string, '\t');
4031                 }
4032
4033                 g_string_assign(context->field_name,
4034                         g_quark_to_string(field->name));
4035                 ret = bt_field_type_serialize(field->type, context);
4036                 if (ret) {
4037                         BT_LOGW("Cannot serialize structure field type's field's metadata: "
4038                                 "index=%zu, "
4039                                 "field-ft-addr=%p, field-name=\"%s\"",
4040                                 i, field->type,
4041                                 g_quark_to_string(field->name));
4042                         goto end;
4043                 }
4044
4045                 if (context->field_name->len) {
4046                         append_field_name(context,
4047                                 context->field_name->str);
4048                 }
4049                 g_string_append(context->string, ";\n");
4050         }
4051
4052         context->current_indentation_level--;
4053         for (indent = 0; indent < context->current_indentation_level;
4054                 indent++) {
4055                 g_string_append_c(context->string, '\t');
4056         }
4057
4058         g_string_append_printf(context->string, "} align(%u)",
4059                  type->alignment);
4060 end:
4061         g_string_free(context->field_name, TRUE);
4062         context->field_name = structure_field_name;
4063         return ret;
4064 }
4065
4066 static
4067 int bt_field_type_variant_serialize(struct bt_field_type *type,
4068                 struct metadata_context *context)
4069 {
4070         size_t i;
4071         unsigned int indent;
4072         int ret = 0;
4073         struct bt_field_type_variant *variant = container_of(
4074                 type, struct bt_field_type_variant, parent);
4075         GString *variant_field_name = context->field_name;
4076
4077         BT_LOGD("Serializing variant field type's metadata: "
4078                 "ft-addr=%p, metadata-context-addr=%p", type, context);
4079         context->field_name = g_string_new("");
4080         if (variant->tag_name->len > 0) {
4081                 g_string_append(context->string, "variant <");
4082                 append_field_name(context, variant->tag_name->str);
4083                 g_string_append(context->string, "> {\n");
4084         } else {
4085                 g_string_append(context->string, "variant {\n");
4086         }
4087
4088         context->current_indentation_level++;
4089         for (i = 0; i < variant->fields->len; i++) {
4090                 struct structure_field *field = variant->fields->pdata[i];
4091
4092                 BT_LOGD("Serializing variant field type's field metadata: "
4093                         "index=%zu, "
4094                         "field-ft-addr=%p, field-name=\"%s\"",
4095                         i, field, g_quark_to_string(field->name));
4096
4097                 g_string_assign(context->field_name,
4098                         g_quark_to_string(field->name));
4099                 for (indent = 0; indent < context->current_indentation_level;
4100                         indent++) {
4101                         g_string_append_c(context->string, '\t');
4102                 }
4103
4104                 g_string_assign(context->field_name,
4105                         g_quark_to_string(field->name));
4106                 ret = bt_field_type_serialize(field->type, context);
4107                 if (ret) {
4108                         BT_LOGW("Cannot serialize variant field type's field's metadata: "
4109                                 "index=%zu, "
4110                                 "field-ft-addr=%p, field-name=\"%s\"",
4111                                 i, field->type,
4112                                 g_quark_to_string(field->name));
4113                         goto end;
4114                 }
4115
4116                 if (context->field_name->len) {
4117                         append_field_name(context,
4118                                 context->field_name->str);
4119                         g_string_append_c(context->string, ';');
4120                 }
4121
4122                 g_string_append_c(context->string, '\n');
4123         }
4124
4125         context->current_indentation_level--;
4126         for (indent = 0; indent < context->current_indentation_level;
4127                 indent++) {
4128                 g_string_append_c(context->string, '\t');
4129         }
4130
4131         g_string_append(context->string, "}");
4132 end:
4133         g_string_free(context->field_name, TRUE);
4134         context->field_name = variant_field_name;
4135         return ret;
4136 }
4137
4138 static
4139 int bt_field_type_array_serialize(struct bt_field_type *type,
4140                 struct metadata_context *context)
4141 {
4142         int ret = 0;
4143         struct bt_field_type_array *array = container_of(type,
4144                 struct bt_field_type_array, parent);
4145
4146         BT_LOGD("Serializing array field type's metadata: "
4147                 "ft-addr=%p, metadata-context-addr=%p", type, context);
4148         BT_LOGD_STR("Serializing array field type's element field type's metadata.");
4149         ret = bt_field_type_serialize(array->element_type, context);
4150         if (ret) {
4151                 BT_LOGW("Cannot serialize array field type's element field type's metadata: "
4152                         "element-ft-addr=%p", array->element_type);
4153                 goto end;
4154         }
4155
4156         if (context->field_name->len) {
4157                 append_field_name(context,
4158                         context->field_name->str);
4159
4160                 g_string_append_printf(context->string, "[%u]", array->length);
4161                 g_string_assign(context->field_name, "");
4162         } else {
4163                 g_string_append_printf(context->string, "[%u]", array->length);
4164         }
4165 end:
4166         return ret;
4167 }
4168
4169 static
4170 int bt_field_type_sequence_serialize(struct bt_field_type *type,
4171                 struct metadata_context *context)
4172 {
4173         int ret = 0;
4174         struct bt_field_type_sequence *sequence = container_of(
4175                 type, struct bt_field_type_sequence, parent);
4176
4177         BT_LOGD("Serializing sequence field type's metadata: "
4178                 "ft-addr=%p, metadata-context-addr=%p", type, context);
4179         BT_LOGD_STR("Serializing sequence field type's element field type's metadata.");
4180         ret = bt_field_type_serialize(sequence->element_type, context);
4181         if (ret) {
4182                 BT_LOGW("Cannot serialize sequence field type's element field type's metadata: "
4183                         "element-ft-addr=%p", sequence->element_type);
4184                 goto end;
4185         }
4186
4187         if (context->field_name->len) {
4188                 append_field_name(context, context->field_name->str);
4189                 g_string_assign(context->field_name, "");
4190         }
4191         g_string_append(context->string, "[");
4192         append_field_name(context, sequence->length_field_name->str);
4193         g_string_append(context->string, "]");
4194 end:
4195         return ret;
4196 }
4197
4198 static
4199 int bt_field_type_string_serialize(struct bt_field_type *type,
4200                 struct metadata_context *context)
4201 {
4202         struct bt_field_type_string *string = container_of(
4203                 type, struct bt_field_type_string, parent);
4204
4205         BT_LOGD("Serializing string field type's metadata: "
4206                 "ft-addr=%p, metadata-context-addr=%p", type, context);
4207         g_string_append_printf(context->string,
4208                 "string { encoding = %s; }",
4209                 get_encoding_string(string->encoding));
4210         return 0;
4211 }
4212
4213 static
4214 void bt_field_type_integer_set_byte_order(struct bt_field_type *type,
4215                 enum bt_byte_order byte_order)
4216 {
4217         struct bt_field_type_integer *integer_type = container_of(type,
4218                 struct bt_field_type_integer, parent);
4219
4220         integer_type->user_byte_order = byte_order;
4221 }
4222
4223 static
4224 void bt_field_type_enumeration_set_byte_order(
4225                 struct bt_field_type *type, enum bt_byte_order byte_order)
4226 {
4227         struct bt_field_type_enumeration *enum_type = container_of(type,
4228                 struct bt_field_type_enumeration, parent);
4229
4230         /* Safe to assume that container is an integer */
4231         bt_field_type_integer_set_byte_order(enum_type->container,
4232                 byte_order);
4233 }
4234
4235 static
4236 void bt_field_type_floating_point_set_byte_order(
4237                 struct bt_field_type *type, enum bt_byte_order byte_order)
4238 {
4239         struct bt_field_type_floating_point *floating_point_type =
4240                 container_of(type, struct bt_field_type_floating_point,
4241                 parent);
4242
4243         floating_point_type->user_byte_order = byte_order;
4244 }
4245
4246 static
4247 void bt_field_type_structure_set_byte_order(struct bt_field_type *type,
4248                 enum bt_byte_order byte_order)
4249 {
4250         int i;
4251         struct bt_field_type_structure *structure_type =
4252                 container_of(type, struct bt_field_type_structure,
4253                 parent);
4254
4255         for (i = 0; i < structure_type->fields->len; i++) {
4256                 struct structure_field *field = g_ptr_array_index(
4257                         structure_type->fields, i);
4258                 struct bt_field_type *field_type = field->type;
4259
4260                 if (set_byte_order_funcs[field_type->id]) {
4261                         set_byte_order_funcs[field_type->id](
4262                                 field_type, byte_order);
4263                 }
4264         }
4265 }
4266
4267 static
4268 void bt_field_type_variant_set_byte_order(struct bt_field_type *type,
4269                 enum bt_byte_order byte_order)
4270 {
4271         int i;
4272         struct bt_field_type_variant *variant_type =
4273                 container_of(type, struct bt_field_type_variant,
4274                 parent);
4275
4276         for (i = 0; i < variant_type->fields->len; i++) {
4277                 struct structure_field *field = g_ptr_array_index(
4278                         variant_type->fields, i);
4279                 struct bt_field_type *field_type = field->type;
4280
4281                 if (set_byte_order_funcs[field_type->id]) {
4282                         set_byte_order_funcs[field_type->id](
4283                                 field_type, byte_order);
4284                 }
4285         }
4286 }
4287
4288 static
4289 void bt_field_type_array_set_byte_order(struct bt_field_type *type,
4290                 enum bt_byte_order byte_order)
4291 {
4292         struct bt_field_type_array *array_type =
4293                 container_of(type, struct bt_field_type_array,
4294                 parent);
4295
4296         if (set_byte_order_funcs[array_type->element_type->id]) {
4297                 set_byte_order_funcs[array_type->element_type->id](
4298                         array_type->element_type, byte_order);
4299         }
4300 }
4301
4302 static
4303 void bt_field_type_sequence_set_byte_order(struct bt_field_type *type,
4304                 enum bt_byte_order byte_order)
4305 {
4306         struct bt_field_type_sequence *sequence_type =
4307                 container_of(type, struct bt_field_type_sequence,
4308                 parent);
4309
4310         if (set_byte_order_funcs[
4311                 sequence_type->element_type->id]) {
4312                 set_byte_order_funcs[
4313                         sequence_type->element_type->id](
4314                         sequence_type->element_type, byte_order);
4315         }
4316 }
4317
4318 static
4319 struct bt_field_type *bt_field_type_integer_copy(
4320                 struct bt_field_type *type)
4321 {
4322         struct bt_field_type *copy;
4323         struct bt_field_type_integer *integer, *copy_integer;
4324
4325         BT_LOGD("Copying integer field type's: addr=%p", type);
4326         integer = container_of(type, struct bt_field_type_integer, parent);
4327         copy = bt_field_type_integer_create(integer->size);
4328         if (!copy) {
4329                 BT_LOGE_STR("Cannot create integer field type.");
4330                 goto end;
4331         }
4332
4333         copy_integer = container_of(copy, struct bt_field_type_integer,
4334                 parent);
4335         copy_integer->mapped_clock = bt_get(integer->mapped_clock);
4336         copy_integer->user_byte_order = integer->user_byte_order;
4337         copy_integer->is_signed = integer->is_signed;
4338         copy_integer->size = integer->size;
4339         copy_integer->base = integer->base;
4340         copy_integer->encoding = integer->encoding;
4341         BT_LOGD("Copied integer field type: original-ft-addr=%p, copy-ft-addr=%p",
4342                 type, copy);
4343
4344 end:
4345         return copy;
4346 }
4347
4348 static
4349 struct bt_field_type *bt_field_type_enumeration_copy(
4350                 struct bt_field_type *type)
4351 {
4352         size_t i;
4353         struct bt_field_type *copy = NULL, *copy_container;
4354         struct bt_field_type_enumeration *enumeration, *copy_enumeration;
4355
4356         BT_LOGD("Copying enumeration field type's: addr=%p", type);
4357         enumeration = container_of(type, struct bt_field_type_enumeration,
4358                 parent);
4359
4360         /* Copy the source enumeration's container */
4361         BT_LOGD_STR("Copying enumeration field type's container field type.");
4362         copy_container = bt_field_type_copy(enumeration->container);
4363         if (!copy_container) {
4364                 BT_LOGE_STR("Cannot copy enumeration field type's container field type.");
4365                 goto end;
4366         }
4367
4368         copy = bt_field_type_enumeration_create(copy_container);
4369         if (!copy) {
4370                 BT_LOGE_STR("Cannot create enumeration field type.");
4371                 goto end;
4372         }
4373         copy_enumeration = container_of(copy,
4374                 struct bt_field_type_enumeration, parent);
4375
4376         /* Copy all enumaration entries */
4377         for (i = 0; i < enumeration->entries->len; i++) {
4378                 struct enumeration_mapping *mapping = g_ptr_array_index(
4379                         enumeration->entries, i);
4380                 struct enumeration_mapping *copy_mapping = g_new0(
4381                         struct enumeration_mapping, 1);
4382
4383                 if (!copy_mapping) {
4384                         BT_LOGE_STR("Failed to allocate one enumeration mapping.");
4385                         goto error;
4386                 }
4387
4388                 *copy_mapping = *mapping;
4389                 g_ptr_array_add(copy_enumeration->entries, copy_mapping);
4390         }
4391
4392         BT_LOGD("Copied enumeration field type: original-ft-addr=%p, copy-ft-addr=%p",
4393                 type, copy);
4394
4395 end:
4396         bt_put(copy_container);
4397         return copy;
4398 error:
4399         bt_put(copy_container);
4400         BT_PUT(copy);
4401         return copy;
4402 }
4403
4404 static
4405 struct bt_field_type *bt_field_type_floating_point_copy(
4406                 struct bt_field_type *type)
4407 {
4408         struct bt_field_type *copy;
4409         struct bt_field_type_floating_point *floating_point, *copy_float;
4410
4411         BT_LOGD("Copying floating point number field type's: addr=%p", type);
4412         floating_point = container_of(type,
4413                 struct bt_field_type_floating_point, parent);
4414         copy = bt_field_type_floating_point_create();
4415         if (!copy) {
4416                 BT_LOGE_STR("Cannot create floating point number field type.");
4417                 goto end;
4418         }
4419
4420         copy_float = container_of(copy,
4421                 struct bt_field_type_floating_point, parent);
4422         copy_float->user_byte_order = floating_point->user_byte_order;
4423         copy_float->exp_dig = floating_point->exp_dig;
4424         copy_float->mant_dig = floating_point->mant_dig;
4425         BT_LOGD("Copied floating point number field type: original-ft-addr=%p, copy-ft-addr=%p",
4426                 type, copy);
4427 end:
4428         return copy;
4429 }
4430
4431 static
4432 struct bt_field_type *bt_field_type_structure_copy(
4433                 struct bt_field_type *type)
4434 {
4435         int64_t i;
4436         GHashTableIter iter;
4437         gpointer key, value;
4438         struct bt_field_type *copy;
4439         struct bt_field_type_structure *structure, *copy_structure;
4440
4441         BT_LOGD("Copying structure field type's: addr=%p", type);
4442         structure = container_of(type, struct bt_field_type_structure,
4443                 parent);
4444         copy = bt_field_type_structure_create();
4445         if (!copy) {
4446                 BT_LOGE_STR("Cannot create structure field type.");
4447                 goto end;
4448         }
4449
4450         copy_structure = container_of(copy,
4451                 struct bt_field_type_structure, parent);
4452
4453         /* Copy field_name_to_index */
4454         g_hash_table_iter_init(&iter, structure->field_name_to_index);
4455         while (g_hash_table_iter_next (&iter, &key, &value)) {
4456                 g_hash_table_insert(copy_structure->field_name_to_index,
4457                         key, value);
4458         }
4459
4460         for (i = 0; i < structure->fields->len; i++) {
4461                 struct structure_field *entry, *copy_entry;
4462                 struct bt_field_type *copy_field;
4463
4464                 entry = g_ptr_array_index(structure->fields, i);
4465                 BT_LOGD("Copying structure field type's field: "
4466                         "index=%" PRId64 ", "
4467                         "field-ft-addr=%p, field-name=\"%s\"",
4468                         i, entry, g_quark_to_string(entry->name));
4469                 copy_entry = g_new0(struct structure_field, 1);
4470                 if (!copy_entry) {
4471                         BT_LOGE_STR("Failed to allocate one structure field type field.");
4472                         goto error;
4473                 }
4474
4475                 copy_field = bt_field_type_copy(entry->type);
4476                 if (!copy_field) {
4477                         BT_LOGE("Cannot copy structure field type's field: "
4478                                 "index=%" PRId64 ", "
4479                                 "field-ft-addr=%p, field-name=\"%s\"",
4480                                 i, entry, g_quark_to_string(entry->name));
4481                         g_free(copy_entry);
4482                         goto error;
4483                 }
4484
4485                 copy_entry->name = entry->name;
4486                 copy_entry->type = copy_field;
4487                 g_ptr_array_add(copy_structure->fields, copy_entry);
4488         }
4489
4490         BT_LOGD("Copied structure field type: original-ft-addr=%p, copy-ft-addr=%p",
4491                 type, copy);
4492
4493 end:
4494         return copy;
4495 error:
4496         BT_PUT(copy);
4497         return copy;
4498 }
4499
4500 static
4501 struct bt_field_type *bt_field_type_variant_copy(
4502                 struct bt_field_type *type)
4503 {
4504         int64_t i;
4505         GHashTableIter iter;
4506         gpointer key, value;
4507         struct bt_field_type *copy = NULL, *copy_tag = NULL;
4508         struct bt_field_type_variant *variant, *copy_variant;
4509
4510         BT_LOGD("Copying variant field type's: addr=%p", type);
4511         variant = container_of(type, struct bt_field_type_variant,
4512                 parent);
4513         if (variant->tag) {
4514                 BT_LOGD_STR("Copying variant field type's tag field type.");
4515                 copy_tag = bt_field_type_copy(&variant->tag->parent);
4516                 if (!copy_tag) {
4517                         BT_LOGE_STR("Cannot copy variant field type's tag field type.");
4518                         goto end;
4519                 }
4520         }
4521
4522         copy = bt_field_type_variant_create(copy_tag,
4523                 variant->tag_name->len ? variant->tag_name->str : NULL);
4524         if (!copy) {
4525                 BT_LOGE_STR("Cannot create variant field type.");
4526                 goto end;
4527         }
4528
4529         copy_variant = container_of(copy, struct bt_field_type_variant,
4530                 parent);
4531
4532         /* Copy field_name_to_index */
4533         g_hash_table_iter_init(&iter, variant->field_name_to_index);
4534         while (g_hash_table_iter_next (&iter, &key, &value)) {
4535                 g_hash_table_insert(copy_variant->field_name_to_index,
4536                         key, value);
4537         }
4538
4539         for (i = 0; i < variant->fields->len; i++) {
4540                 struct structure_field *entry, *copy_entry;
4541                 struct bt_field_type *copy_field;
4542
4543                 entry = g_ptr_array_index(variant->fields, i);
4544                 BT_LOGD("Copying variant field type's field: "
4545                         "index=%" PRId64 ", "
4546                         "field-ft-addr=%p, field-name=\"%s\"",
4547                         i, entry, g_quark_to_string(entry->name));
4548                 copy_entry = g_new0(struct structure_field, 1);
4549                 if (!copy_entry) {
4550                         BT_LOGE_STR("Failed to allocate one variant field type field.");
4551                         goto error;
4552                 }
4553
4554                 copy_field = bt_field_type_copy(entry->type);
4555                 if (!copy_field) {
4556                         BT_LOGE("Cannot copy variant field type's field: "
4557                                 "index=%" PRId64 ", "
4558                                 "field-ft-addr=%p, field-name=\"%s\"",
4559                                 i, entry, g_quark_to_string(entry->name));
4560                         g_free(copy_entry);
4561                         goto error;
4562                 }
4563
4564                 copy_entry->name = entry->name;
4565                 copy_entry->type = copy_field;
4566                 g_ptr_array_add(copy_variant->fields, copy_entry);
4567         }
4568
4569         if (variant->tag_field_path) {
4570                 BT_LOGD_STR("Copying variant field type's tag field path.");
4571                 copy_variant->tag_field_path = bt_field_path_copy(
4572                         variant->tag_field_path);
4573                 if (!copy_variant->tag_field_path) {
4574                         BT_LOGE_STR("Cannot copy variant field type's tag field path.");
4575                         goto error;
4576                 }
4577         }
4578
4579         BT_LOGD("Copied variant field type: original-ft-addr=%p, copy-ft-addr=%p",
4580                 type, copy);
4581
4582 end:
4583         bt_put(copy_tag);
4584         return copy;
4585 error:
4586         bt_put(copy_tag);
4587         BT_PUT(copy);
4588         return copy;
4589 }
4590
4591 static
4592 struct bt_field_type *bt_field_type_array_copy(
4593                 struct bt_field_type *type)
4594 {
4595         struct bt_field_type *copy = NULL, *copy_element;
4596         struct bt_field_type_array *array;
4597
4598         BT_LOGD("Copying array field type's: addr=%p", type);
4599         array = container_of(type, struct bt_field_type_array,
4600                 parent);
4601         BT_LOGD_STR("Copying array field type's element field type.");
4602         copy_element = bt_field_type_copy(array->element_type);
4603         if (!copy_element) {
4604                 BT_LOGE_STR("Cannot copy array field type's element field type.");
4605                 goto end;
4606         }
4607
4608         copy = bt_field_type_array_create(copy_element, array->length);
4609         if (!copy) {
4610                 BT_LOGE_STR("Cannot create array field type.");
4611                 goto end;
4612         }
4613
4614         BT_LOGD("Copied array field type: original-ft-addr=%p, copy-ft-addr=%p",
4615                 type, copy);
4616
4617 end:
4618         bt_put(copy_element);
4619         return copy;
4620 }
4621
4622 static
4623 struct bt_field_type *bt_field_type_sequence_copy(
4624                 struct bt_field_type *type)
4625 {
4626         struct bt_field_type *copy = NULL, *copy_element;
4627         struct bt_field_type_sequence *sequence, *copy_sequence;
4628
4629         BT_LOGD("Copying sequence field type's: addr=%p", type);
4630         sequence = container_of(type, struct bt_field_type_sequence,
4631                 parent);
4632         BT_LOGD_STR("Copying sequence field type's element field type.");
4633         copy_element = bt_field_type_copy(sequence->element_type);
4634         if (!copy_element) {
4635                 BT_LOGE_STR("Cannot copy sequence field type's element field type.");
4636                 goto end;
4637         }
4638
4639         copy = bt_field_type_sequence_create(copy_element,
4640                 sequence->length_field_name->len ?
4641                         sequence->length_field_name->str : NULL);
4642         if (!copy) {
4643                 BT_LOGE_STR("Cannot create sequence field type.");
4644                 goto end;
4645         }
4646
4647         copy_sequence = container_of(copy, struct bt_field_type_sequence,
4648                 parent);
4649         if (sequence->length_field_path) {
4650                 BT_LOGD_STR("Copying sequence field type's length field path.");
4651                 copy_sequence->length_field_path = bt_field_path_copy(
4652                         sequence->length_field_path);
4653                 if (!copy_sequence->length_field_path) {
4654                         BT_LOGE_STR("Cannot copy sequence field type's length field path.");
4655                         goto error;
4656                 }
4657         }
4658
4659         BT_LOGD("Copied sequence field type: original-ft-addr=%p, copy-ft-addr=%p",
4660                 type, copy);
4661
4662 end:
4663         bt_put(copy_element);
4664         return copy;
4665 error:
4666         BT_PUT(copy);
4667         goto end;
4668 }
4669
4670 static
4671 struct bt_field_type *bt_field_type_string_copy(
4672                 struct bt_field_type *type)
4673 {
4674         struct bt_field_type *copy;
4675
4676         BT_LOGD("Copying string field type's: addr=%p", type);
4677         copy = bt_field_type_string_create();
4678         if (!copy) {
4679                 BT_LOGE_STR("Cannot create string field type.");
4680                 goto end;
4681         }
4682
4683         BT_LOGD("Copied string field type: original-ft-addr=%p, copy-ft-addr=%p",
4684                 type, copy);
4685 end:
4686         return copy;
4687 }
4688
4689 static
4690 int bt_field_type_integer_compare(struct bt_field_type *type_a,
4691                 struct bt_field_type *type_b)
4692 {
4693         int ret = 1;
4694         struct bt_field_type_integer *int_type_a;
4695         struct bt_field_type_integer *int_type_b;
4696
4697         int_type_a = container_of(type_a, struct bt_field_type_integer,
4698                 parent);
4699         int_type_b = container_of(type_b, struct bt_field_type_integer,
4700                 parent);
4701
4702         /* Length */
4703         if (int_type_a->size != int_type_b->size) {
4704                 BT_LOGV("Integer field types differ: different sizes: "
4705                         "ft-a-size=%u, ft-b-size=%u",
4706                         int_type_a->size, int_type_b->size);
4707                 goto end;
4708         }
4709
4710         /* Byte order */
4711         if (int_type_a->user_byte_order != int_type_b->user_byte_order) {
4712                 BT_LOGV("Integer field types differ: different byte orders: "
4713                         "ft-a-bo=%s, ft-b-bo=%s",
4714                         bt_byte_order_string(int_type_a->user_byte_order),
4715                         bt_byte_order_string(int_type_b->user_byte_order));
4716                 goto end;
4717         }
4718
4719         /* Signedness */
4720         if (int_type_a->is_signed != int_type_b->is_signed) {
4721                 BT_LOGV("Integer field types differ: different signedness: "
4722                         "ft-a-is-signed=%d, ft-b-is-signed=%d",
4723                         int_type_a->is_signed,
4724                         int_type_b->is_signed);
4725                 goto end;
4726         }
4727
4728         /* Base */
4729         if (int_type_a->base != int_type_b->base) {
4730                 BT_LOGV("Integer field types differ: different bases: "
4731                         "ft-a-base=%s, ft-b-base=%s",
4732                         bt_integer_base_string(int_type_a->base),
4733                         bt_integer_base_string(int_type_b->base));
4734                 goto end;
4735         }
4736
4737         /* Encoding */
4738         if (int_type_a->encoding != int_type_b->encoding) {
4739                 BT_LOGV("Integer field types differ: different encodings: "
4740                         "ft-a-encoding=%s, ft-b-encoding=%s",
4741                         bt_string_encoding_string(int_type_a->encoding),
4742                         bt_string_encoding_string(int_type_b->encoding));
4743                 goto end;
4744         }
4745
4746         /* Mapped clock */
4747         if (int_type_a->mapped_clock != int_type_b->mapped_clock) {
4748                 BT_LOGV("Integer field types differ: different mapped clock classes: "
4749                         "ft-a-mapped-clock-class-addr=%p, "
4750                         "ft-b-mapped-clock-class-addr=%p, "
4751                         "ft-a-mapped-clock-class-name=\"%s\", "
4752                         "ft-b-mapped-clock-class-name=\"%s\"",
4753                         int_type_a->mapped_clock, int_type_b->mapped_clock,
4754                         int_type_a->mapped_clock ? bt_clock_class_get_name(int_type_a->mapped_clock) : "",
4755                         int_type_b->mapped_clock ? bt_clock_class_get_name(int_type_b->mapped_clock) : "");
4756                 goto end;
4757         }
4758
4759         /* Equal */
4760         ret = 0;
4761
4762 end:
4763         return ret;
4764 }
4765
4766 static
4767 int bt_field_type_floating_point_compare(struct bt_field_type *type_a,
4768                 struct bt_field_type *type_b)
4769 {
4770         int ret = 1;
4771         struct bt_field_type_floating_point *float_a;
4772         struct bt_field_type_floating_point *float_b;
4773
4774         float_a = container_of(type_a,
4775                 struct bt_field_type_floating_point, parent);
4776         float_b = container_of(type_b,
4777                 struct bt_field_type_floating_point, parent);
4778
4779         /* Byte order */
4780         if (float_a->user_byte_order != float_b->user_byte_order) {
4781                 BT_LOGV("Floating point number field types differ: different byte orders: "
4782                         "ft-a-bo=%s, ft-b-bo=%s",
4783                         bt_byte_order_string(float_a->user_byte_order),
4784                         bt_byte_order_string(float_b->user_byte_order));
4785                 goto end;
4786         }
4787
4788         /* Exponent length */
4789         if (float_a->exp_dig != float_b->exp_dig) {
4790                 BT_LOGV("Floating point number field types differ: different exponent sizes: "
4791                         "ft-a-exp-size=%u, ft-b-exp-size=%u",
4792                         float_a->exp_dig, float_b->exp_dig);
4793                 goto end;
4794         }
4795
4796         /* Mantissa length */
4797         if (float_a->mant_dig != float_b->mant_dig) {
4798                 BT_LOGV("Floating point number field types differ: different mantissa sizes: "
4799                         "ft-a-mant-size=%u, ft-b-mant-size=%u",
4800                         float_a->mant_dig, float_b->mant_dig);
4801                 goto end;
4802         }
4803
4804         /* Equal */
4805         ret = 0;
4806
4807 end:
4808         return ret;
4809 }
4810
4811 static
4812 int compare_enumeration_mappings(struct enumeration_mapping *mapping_a,
4813                 struct enumeration_mapping *mapping_b)
4814 {
4815         int ret = 1;
4816
4817         /* Label */
4818         if (mapping_a->string != mapping_b->string) {
4819                 BT_LOGV("Enumeration field type mappings differ: different names: "
4820                         "mapping-a-name=\"%s\", mapping-b-name=\"%s\"",
4821                         g_quark_to_string(mapping_a->string),
4822                         g_quark_to_string(mapping_b->string));
4823                 goto end;
4824         }
4825
4826         /* Range start */
4827         if (mapping_a->range_start._unsigned !=
4828                         mapping_b->range_start._unsigned) {
4829                 BT_LOGV("Enumeration field type mappings differ: different starts of range: "
4830                         "mapping-a-range-start-unsigned=%" PRIu64 ", "
4831                         "mapping-b-range-start-unsigned=%" PRIu64,
4832                         mapping_a->range_start._unsigned,
4833                         mapping_b->range_start._unsigned);
4834                 goto end;
4835         }
4836
4837         /* Range end */
4838         if (mapping_a->range_end._unsigned !=
4839                         mapping_b->range_end._unsigned) {
4840                 BT_LOGV("Enumeration field type mappings differ: different ends of range: "
4841                         "mapping-a-range-end-unsigned=%" PRIu64 ", "
4842                         "mapping-b-range-end-unsigned=%" PRIu64,
4843                         mapping_a->range_end._unsigned,
4844                         mapping_b->range_end._unsigned);
4845                 goto end;
4846         }
4847
4848         /* Equal */
4849         ret = 0;
4850
4851 end:
4852         return ret;
4853 }
4854
4855 static
4856 int bt_field_type_enumeration_compare(struct bt_field_type *type_a,
4857                 struct bt_field_type *type_b)
4858 {
4859         int ret = 1;
4860         int i;
4861         struct bt_field_type_enumeration *enum_a;
4862         struct bt_field_type_enumeration *enum_b;
4863
4864         enum_a = container_of(type_a,
4865                 struct bt_field_type_enumeration, parent);
4866         enum_b = container_of(type_b,
4867                 struct bt_field_type_enumeration, parent);
4868
4869         /* Container field type */
4870         ret = bt_field_type_compare(enum_a->container, enum_b->container);
4871         if (ret) {
4872                 BT_LOGV("Enumeration field types differ: different container field types: "
4873                         "ft-a-container-ft-addr=%p, ft-b-container-ft-addr=%p",
4874                         enum_a->container, enum_b->container);
4875                 goto end;
4876         }
4877
4878         ret = 1;
4879
4880         /* Entries */
4881         if (enum_a->entries->len != enum_b->entries->len) {
4882                 goto end;
4883         }
4884
4885         for (i = 0; i < enum_a->entries->len; ++i) {
4886                 struct enumeration_mapping *mapping_a =
4887                         g_ptr_array_index(enum_a->entries, i);
4888                 struct enumeration_mapping *mapping_b =
4889                         g_ptr_array_index(enum_b->entries, i);
4890
4891                 if (compare_enumeration_mappings(mapping_a, mapping_b)) {
4892                         BT_LOGV("Enumeration field types differ: different mappings: "
4893                                 "ft-a-mapping-addr=%p, ft-b-mapping-addr=%p, "
4894                                 "ft-a-mapping-name=\"%s\", ft-b-mapping-name=\"%s\"",
4895                                 mapping_a, mapping_b,
4896                                 g_quark_to_string(mapping_a->string),
4897                                 g_quark_to_string(mapping_b->string));
4898                         goto end;
4899                 }
4900         }
4901
4902         /* Equal */
4903         ret = 0;
4904
4905 end:
4906         return ret;
4907 }
4908
4909 static
4910 int bt_field_type_string_compare(struct bt_field_type *type_a,
4911                 struct bt_field_type *type_b)
4912 {
4913         int ret = 1;
4914         struct bt_field_type_string *string_a;
4915         struct bt_field_type_string *string_b;
4916
4917         string_a = container_of(type_a,
4918                 struct bt_field_type_string, parent);
4919         string_b = container_of(type_b,
4920                 struct bt_field_type_string, parent);
4921
4922         /* Encoding */
4923         if (string_a->encoding != string_b->encoding) {
4924                 BT_LOGV("String field types differ: different encodings: "
4925                         "ft-a-encoding=%s, ft-b-encoding=%s",
4926                         bt_string_encoding_string(string_a->encoding),
4927                         bt_string_encoding_string(string_b->encoding));
4928                 goto end;
4929         }
4930
4931         /* Equal */
4932         ret = 0;
4933
4934 end:
4935         return ret;
4936 }
4937
4938 static
4939 int compare_structure_fields(struct structure_field *field_a,
4940                 struct structure_field *field_b)
4941 {
4942         int ret = 1;
4943
4944         /* Label */
4945         if (field_a->name != field_b->name) {
4946                 BT_LOGV("Structure/variant field type fields differ: different names: "
4947                         "field-a-name=%s, field-b-name=%s",
4948                         g_quark_to_string(field_a->name),
4949                         g_quark_to_string(field_b->name));
4950                 goto end;
4951         }
4952
4953         /* Type */
4954         ret = bt_field_type_compare(field_a->type, field_b->type);
4955         if (ret == 1) {
4956                 BT_LOGV("Structure/variant field type fields differ: different field types: "
4957                         "field-name=\"%s\", field-a-ft-addr=%p, field-b-ft-addr=%p",
4958                         g_quark_to_string(field_a->name),
4959                         field_a->type, field_b->type);
4960         }
4961
4962 end:
4963         return ret;
4964 }
4965
4966 static
4967 int bt_field_type_structure_compare(struct bt_field_type *type_a,
4968                 struct bt_field_type *type_b)
4969 {
4970         int ret = 1;
4971         int i;
4972         struct bt_field_type_structure *struct_a;
4973         struct bt_field_type_structure *struct_b;
4974
4975         struct_a = container_of(type_a,
4976                 struct bt_field_type_structure, parent);
4977         struct_b = container_of(type_b,
4978                 struct bt_field_type_structure, parent);
4979
4980         /* Alignment */
4981         if (bt_field_type_get_alignment(type_a) !=
4982                         bt_field_type_get_alignment(type_b)) {
4983                 BT_LOGV("Structure field types differ: different alignments: "
4984                         "ft-a-align=%u, ft-b-align=%u",
4985                         bt_field_type_get_alignment(type_a),
4986                         bt_field_type_get_alignment(type_b));
4987                 goto end;
4988         }
4989
4990         /* Fields */
4991         if (struct_a->fields->len != struct_b->fields->len) {
4992                 BT_LOGV("Structure field types differ: different field counts: "
4993                         "ft-a-field-count=%u, ft-b-field-count=%u",
4994                         struct_a->fields->len, struct_b->fields->len);
4995                 goto end;
4996         }
4997
4998         for (i = 0; i < struct_a->fields->len; ++i) {
4999                 struct structure_field *field_a =
5000                         g_ptr_array_index(struct_a->fields, i);
5001                 struct structure_field *field_b =
5002                         g_ptr_array_index(struct_b->fields, i);
5003
5004                 ret = compare_structure_fields(field_a, field_b);
5005                 if (ret) {
5006                         /* compare_structure_fields() logs what differs */
5007                         BT_LOGV_STR("Structure field types differ: different fields.");
5008                         goto end;
5009                 }
5010         }
5011
5012         /* Equal */
5013         ret = 0;
5014
5015 end:
5016         return ret;
5017 }
5018
5019 static
5020 int bt_field_type_variant_compare(struct bt_field_type *type_a,
5021                 struct bt_field_type *type_b)
5022 {
5023         int ret = 1;
5024         int i;
5025         struct bt_field_type_variant *variant_a;
5026         struct bt_field_type_variant *variant_b;
5027
5028         variant_a = container_of(type_a,
5029                 struct bt_field_type_variant, parent);
5030         variant_b = container_of(type_b,
5031                 struct bt_field_type_variant, parent);
5032
5033         /* Tag name */
5034         if (strcmp(variant_a->tag_name->str, variant_b->tag_name->str)) {
5035                 BT_LOGV("Variant field types differ: different tag field names: "
5036                         "ft-a-tag-field-name=\"%s\", ft-b-tag-field-name=\"%s\"",
5037                         variant_a->tag_name->str, variant_b->tag_name->str);
5038                 goto end;
5039         }
5040
5041         /* Tag type */
5042         ret = bt_field_type_compare(
5043                 (struct bt_field_type *) variant_a->tag,
5044                 (struct bt_field_type *) variant_b->tag);
5045         if (ret) {
5046                 BT_LOGV("Variant field types differ: different tag field types: "
5047                         "ft-a-tag-ft-addr=%p, ft-b-tag-ft-addr=%p",
5048                         variant_a->tag, variant_b->tag);
5049                 goto end;
5050         }
5051
5052         ret = 1;
5053
5054         /* Fields */
5055         if (variant_a->fields->len != variant_b->fields->len) {
5056                 BT_LOGV("Structure field types differ: different field counts: "
5057                         "ft-a-field-count=%u, ft-b-field-count=%u",
5058                         variant_a->fields->len, variant_b->fields->len);
5059                 goto end;
5060         }
5061
5062         for (i = 0; i < variant_a->fields->len; ++i) {
5063                 struct structure_field *field_a =
5064                         g_ptr_array_index(variant_a->fields, i);
5065                 struct structure_field *field_b =
5066                         g_ptr_array_index(variant_b->fields, i);
5067
5068                 ret = compare_structure_fields(field_a, field_b);
5069                 if (ret) {
5070                         /* compare_structure_fields() logs what differs */
5071                         BT_LOGV_STR("Variant field types differ: different fields.");
5072                         goto end;
5073                 }
5074         }
5075
5076         /* Equal */
5077         ret = 0;
5078
5079 end:
5080         return ret;
5081 }
5082
5083 static
5084 int bt_field_type_array_compare(struct bt_field_type *type_a,
5085                 struct bt_field_type *type_b)
5086 {
5087         int ret = 1;
5088         struct bt_field_type_array *array_a;
5089         struct bt_field_type_array *array_b;
5090
5091         array_a = container_of(type_a,
5092                 struct bt_field_type_array, parent);
5093         array_b = container_of(type_b,
5094                 struct bt_field_type_array, parent);
5095
5096         /* Length */
5097         if (array_a->length != array_b->length) {
5098                 BT_LOGV("Structure field types differ: different lengths: "
5099                         "ft-a-length=%u, ft-b-length=%u",
5100                         array_a->length, array_b->length);
5101                 goto end;
5102         }
5103
5104         /* Element type */
5105         ret = bt_field_type_compare(array_a->element_type,
5106                 array_b->element_type);
5107         if (ret == 1) {
5108                 BT_LOGV("Array field types differ: different element field types: "
5109                         "ft-a-element-ft-addr=%p, ft-b-element-ft-addr=%p",
5110                         array_a->element_type, array_b->element_type);
5111         }
5112
5113 end:
5114         return ret;
5115 }
5116
5117 static
5118 int bt_field_type_sequence_compare(struct bt_field_type *type_a,
5119                 struct bt_field_type *type_b)
5120 {
5121         int ret = -1;
5122         struct bt_field_type_sequence *sequence_a;
5123         struct bt_field_type_sequence *sequence_b;
5124
5125         sequence_a = container_of(type_a,
5126                 struct bt_field_type_sequence, parent);
5127         sequence_b = container_of(type_b,
5128                 struct bt_field_type_sequence, parent);
5129
5130         /* Length name */
5131         if (strcmp(sequence_a->length_field_name->str,
5132                         sequence_b->length_field_name->str)) {
5133                 BT_LOGV("Sequence field types differ: different length field names: "
5134                         "ft-a-length-field-name=\"%s\", "
5135                         "ft-b-length-field-name=\"%s\"",
5136                         sequence_a->length_field_name->str,
5137                         sequence_b->length_field_name->str);
5138                 goto end;
5139         }
5140
5141         /* Element type */
5142         ret = bt_field_type_compare(sequence_a->element_type,
5143                         sequence_b->element_type);
5144         if (ret == 1) {
5145                 BT_LOGV("Sequence field types differ: different element field types: "
5146                         "ft-a-element-ft-addr=%p, ft-b-element-ft-addr=%p",
5147                         sequence_a->element_type, sequence_b->element_type);
5148         }
5149
5150 end:
5151         return ret;
5152 }
5153
5154 int bt_field_type_compare(struct bt_field_type *type_a,
5155                 struct bt_field_type *type_b)
5156 {
5157         int ret = 1;
5158
5159         if (type_a == type_b) {
5160                 /* Same reference: equal (even if both are NULL) */
5161                 ret = 0;
5162                 goto end;
5163         }
5164
5165         if (!type_a) {
5166                 BT_LOGW_STR("Invalid parameter: field type A is NULL.");
5167                 ret = -1;
5168                 goto end;
5169         }
5170
5171         if (!type_b) {
5172                 BT_LOGW_STR("Invalid parameter: field type B is NULL.");
5173                 ret = -1;
5174                 goto end;
5175         }
5176
5177         if (type_a->id != type_b->id) {
5178                 /* Different type IDs */
5179                 BT_LOGV("Field types differ: different IDs: "
5180                         "ft-a-addr=%p, ft-b-addr=%p, "
5181                         "ft-a-id=%s, ft-b-id=%s",
5182                         type_a, type_b,
5183                         bt_field_type_id_string(type_a->id),
5184                         bt_field_type_id_string(type_b->id));
5185                 goto end;
5186         }
5187
5188         if (type_a->id == BT_FIELD_TYPE_ID_UNKNOWN) {
5189                 /* Both have unknown type IDs */
5190                 BT_LOGW_STR("Invalid parameter: field type IDs are unknown.");
5191                 goto end;
5192         }
5193
5194         ret = type_compare_funcs[type_a->id](type_a, type_b);
5195         if (ret == 1) {
5196                 BT_LOGV("Field types differ: ft-a-addr=%p, ft-b-addr=%p",
5197                         type_a, type_b);
5198         }
5199
5200 end:
5201         return ret;
5202 }
5203
5204 BT_HIDDEN
5205 int64_t bt_field_type_get_field_count(struct bt_field_type *field_type)
5206 {
5207         int64_t field_count = -1;
5208         enum bt_field_type_id type_id = bt_field_type_get_type_id(field_type);
5209
5210         switch (type_id) {
5211         case CTF_TYPE_STRUCT:
5212                 field_count =
5213                         bt_field_type_structure_get_field_count(field_type);
5214                 break;
5215         case CTF_TYPE_VARIANT:
5216                 field_count =
5217                         bt_field_type_variant_get_field_count(field_type);
5218                 break;
5219         case CTF_TYPE_ARRAY:
5220         case CTF_TYPE_SEQUENCE:
5221                 /*
5222                  * Array and sequence types always contain a single member
5223                  * (the element type).
5224                  */
5225                 field_count = 1;
5226                 break;
5227         default:
5228                 break;
5229         }
5230
5231         return field_count;
5232 }
5233
5234 BT_HIDDEN
5235 struct bt_field_type *bt_field_type_get_field_at_index(
5236                 struct bt_field_type *field_type, int index)
5237 {
5238         struct bt_field_type *field = NULL;
5239         enum bt_field_type_id type_id = bt_field_type_get_type_id(field_type);
5240
5241         switch (type_id) {
5242         case CTF_TYPE_STRUCT:
5243         {
5244                 int ret = bt_field_type_structure_get_field_by_index(
5245                         field_type, NULL, &field, index);
5246                 if (ret) {
5247                         field = NULL;
5248                         goto end;
5249                 }
5250                 break;
5251         }
5252         case CTF_TYPE_VARIANT:
5253         {
5254                 int ret = bt_field_type_variant_get_field_by_index(
5255                         field_type, NULL, &field, index);
5256                 if (ret) {
5257                         field = NULL;
5258                         goto end;
5259                 }
5260                 break;
5261         }
5262         case CTF_TYPE_ARRAY:
5263                 field = bt_field_type_array_get_element_type(field_type);
5264                 break;
5265         case CTF_TYPE_SEQUENCE:
5266                 field = bt_field_type_sequence_get_element_type(field_type);
5267                 break;
5268         default:
5269                 break;
5270         }
5271 end:
5272         return field;
5273 }
5274
5275 BT_HIDDEN
5276 int bt_field_type_get_field_index(struct bt_field_type *field_type,
5277                 const char *name)
5278 {
5279         int field_index = -1;
5280         enum bt_field_type_id type_id = bt_field_type_get_type_id(field_type);
5281
5282         switch (type_id) {
5283         case CTF_TYPE_STRUCT:
5284                 field_index = bt_field_type_structure_get_field_name_index(
5285                         field_type, name);
5286                 break;
5287         case CTF_TYPE_VARIANT:
5288                 field_index = bt_field_type_variant_get_field_name_index(
5289                         field_type, name);
5290                 break;
5291         default:
5292                 break;
5293         }
5294
5295         return field_index;
5296 }
5297
5298 struct bt_field_path *bt_field_type_variant_get_tag_field_path(
5299                 struct bt_field_type *type)
5300 {
5301         struct bt_field_path *field_path = NULL;
5302         struct bt_field_type_variant *variant;
5303
5304         if (!type) {
5305                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
5306                 goto end;
5307         }
5308
5309         if (!bt_field_type_is_variant(type)) {
5310                 BT_LOGW("Invalid parameter: field type is not a variant field type: "
5311                         "addr=%p, ft-id=%s", type,
5312                         bt_field_type_id_string(type->id));
5313                 goto end;
5314         }
5315
5316         variant = container_of(type, struct bt_field_type_variant,
5317                         parent);
5318         field_path = bt_get(variant->tag_field_path);
5319 end:
5320         return field_path;
5321 }
5322
5323 struct bt_field_path *bt_field_type_sequence_get_length_field_path(
5324                 struct bt_field_type *type)
5325 {
5326         struct bt_field_path *field_path = NULL;
5327         struct bt_field_type_sequence *sequence;
5328
5329         if (!type) {
5330                 BT_LOGW_STR("Invalid parameter: field type is NULL.");
5331                 goto end;
5332         }
5333
5334         if (!bt_field_type_is_sequence(type)) {
5335                 BT_LOGW("Invalid parameter: field type is not a sequence field type: "
5336                         "addr=%p, ft-id=%s", type,
5337                         bt_field_type_id_string(type->id));
5338                 goto end;
5339         }
5340
5341         sequence = container_of(type, struct bt_field_type_sequence,
5342                         parent);
5343         field_path = bt_get(sequence->length_field_path);
5344 end:
5345         return field_path;
5346 }