formats/ctf/metadata/ctf-visitor-generate-io-struct.c

   1 /*
   2  * ctf-visitor-generate-io-struct.c
   3  *
   4  * Common Trace Format Metadata Visitor (generate I/O structures).
   5  *
   6  * Copyright 2010 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a copy
   9  * of this software and associated documentation files (the "Software"), to deal
  10  * in the Software without restriction, including without limitation the rights
  11  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  12  * copies of the Software, and to permit persons to whom the Software is
  13  * furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included in
  16  * all copies or substantial portions of the Software.
  17  */
  18
  19 #include <stdio.h>
  20 #include <unistd.h>
  21 #include <string.h>
  22 #include <stdlib.h>
  23 #include <assert.h>
  24 #include <glib.h>
  25 #include <inttypes.h>
  26 #include <endian.h>
  27 #include <errno.h>
  28 #include <babeltrace/list.h>
  29 #include <babeltrace/types.h>
  30 #include <babeltrace/ctf/metadata.h>
  31 #include <uuid/uuid.h>
  32 #include "ctf-scanner.h"
  33 #include "ctf-parser.h"
  34 #include "ctf-ast.h"
  35
  36 #define fprintf_dbg(fd, fmt, args...)   fprintf(fd, "%s: " fmt, __func__, ## args)
  37
  38 #define _cds_list_first_entry(ptr, type, member)        \
  39         cds_list_entry((ptr)->next, type, member)
  40
  41 static
  42 struct declaration *ctf_type_specifier_list_visit(FILE *fd,
  43                 int depth, struct ctf_node *type_specifier_list,
  44                 struct declaration_scope *declaration_scope,
  45                 struct ctf_trace *trace);
  46
  47 /*
  48  * String returned must be freed by the caller using g_free.
  49  */
  50 static
  51 char *concatenate_unary_strings(struct cds_list_head *head)
  52 {
  53         struct ctf_node *node;
  54         GString *str;
  55         int i = 0;
  56
  57         str = g_string_new("");
  58         cds_list_for_each_entry(node, head, siblings) {
  59                 char *src_string;
  60
  61                 assert(node->type == NODE_UNARY_EXPRESSION);
  62                 assert(node->u.unary_expression.type == UNARY_STRING);
  63                 assert((node->u.unary_expression.link == UNARY_LINK_UNKNOWN)
  64                         ^ (i != 0));
  65                 switch (node->u.unary_expression.link) {
  66                 case UNARY_DOTLINK:
  67                         g_string_append(str, ".");
  68                         break;
  69                 case UNARY_ARROWLINK:
  70                         g_string_append(str, "->");
  71                         break;
  72                 case UNARY_DOTDOTDOT:
  73                         g_string_append(str, "...");
  74                         break;
  75                 default:
  76                         break;
  77                 }
  78                 src_string = node->u.unary_expression.u.string;
  79                 g_string_append(str, src_string);
  80                 i++;
  81         }
  82         return g_string_free(str, FALSE);
  83 }
  84
  85 static
  86 int get_unary_unsigned(struct cds_list_head *head, uint64_t *value)
  87 {
  88         struct ctf_node *node;
  89         int i = 0;
  90
  91         cds_list_for_each_entry(node, head, siblings) {
  92                 assert(node->type == NODE_UNARY_EXPRESSION);
  93                 assert(node->u.unary_expression.type == UNARY_UNSIGNED_CONSTANT);
  94                 assert(node->u.unary_expression.link == UNARY_LINK_UNKNOWN);
  95                 assert(i == 0);
  96                 *value = node->u.unary_expression.u.unsigned_constant;
  97                 i++;
  98         }
  99         return 0;
 100 }
 101
 102 static
 103 int get_unary_uuid(struct cds_list_head *head, uuid_t *uuid)
 104 {
 105         struct ctf_node *node;
 106         int i = 0;
 107         int ret = -1;
 108
 109         cds_list_for_each_entry(node, head, siblings) {
 110                 const char *src_string;
 111
 112                 assert(node->type == NODE_UNARY_EXPRESSION);
 113                 assert(node->u.unary_expression.type == UNARY_STRING);
 114                 assert(node->u.unary_expression.link == UNARY_LINK_UNKNOWN);
 115                 assert(i == 0);
 116                 src_string = node->u.unary_expression.u.string;
 117                 ret = uuid_parse(node->u.unary_expression.u.string, *uuid);
 118         }
 119         return ret;
 120 }
 121
 122 static
 123 struct ctf_stream *trace_stream_lookup(struct ctf_trace *trace, uint64_t stream_id)
 124 {
 125         if (trace->streams->len <= stream_id)
 126                 return NULL;
 127         return g_ptr_array_index(trace->streams, stream_id);
 128 }
 129
 130 static
 131 int visit_type_specifier(FILE *fd, struct ctf_node *type_specifier, GString *str)
 132 {
 133         assert(type_specifier->type == NODE_TYPE_SPECIFIER);
 134
 135         switch (type_specifier->u.type_specifier.type) {
 136         case TYPESPEC_VOID:
 137                 g_string_append(str, "void");
 138                 break;
 139         case TYPESPEC_CHAR:
 140                 g_string_append(str, "char");
 141                 break;
 142         case TYPESPEC_SHORT:
 143                 g_string_append(str, "short");
 144                 break;
 145         case TYPESPEC_INT:
 146                 g_string_append(str, "int");
 147                 break;
 148         case TYPESPEC_LONG:
 149                 g_string_append(str, "long");
 150                 break;
 151         case TYPESPEC_FLOAT:
 152                 g_string_append(str, "float");
 153                 break;
 154         case TYPESPEC_DOUBLE:
 155                 g_string_append(str, "double");
 156                 break;
 157         case TYPESPEC_SIGNED:
 158                 g_string_append(str, "signed");
 159                 break;
 160         case TYPESPEC_UNSIGNED:
 161                 g_string_append(str, "unsigned");
 162                 break;
 163         case TYPESPEC_BOOL:
 164                 g_string_append(str, "bool");
 165                 break;
 166         case TYPESPEC_COMPLEX:
 167                 g_string_append(str, "_Complex");
 168                 break;
 169         case TYPESPEC_IMAGINARY:
 170                 g_string_append(str, "_Imaginary");
 171                 break;
 172         case TYPESPEC_CONST:
 173                 g_string_append(str, "const");
 174                 break;
 175         case TYPESPEC_ID_TYPE:
 176                 if (type_specifier->u.type_specifier.id_type)
 177                         g_string_append(str, type_specifier->u.type_specifier.id_type);
 178                 break;
 179         case TYPESPEC_STRUCT:
 180         {
 181                 struct ctf_node *node = type_specifier->u.type_specifier.node;
 182
 183                 if (!node->u._struct.name) {
 184                         fprintf(fd, "[error] %s: unexpected empty variant name\n", __func__);
 185                         return -EINVAL;
 186                 }
 187                 g_string_append(str, "struct ");
 188                 g_string_append(str, node->u._struct.name);
 189                 break;
 190         }
 191         case TYPESPEC_VARIANT:
 192         {
 193                 struct ctf_node *node = type_specifier->u.type_specifier.node;
 194
 195                 if (!node->u.variant.name) {
 196                         fprintf(fd, "[error] %s: unexpected empty variant name\n", __func__);
 197                         return -EINVAL;
 198                 }
 199                 g_string_append(str, "variant ");
 200                 g_string_append(str, node->u.variant.name);
 201                 break;
 202         }
 203         case TYPESPEC_ENUM:
 204         {
 205                 struct ctf_node *node = type_specifier->u.type_specifier.node;
 206
 207                 if (!node->u._enum.enum_id) {
 208                         fprintf(fd, "[error] %s: unexpected empty enum ID\n", __func__);
 209                         return -EINVAL;
 210                 }
 211                 g_string_append(str, "enum ");
 212                 g_string_append(str, node->u._enum.enum_id);
 213                 break;
 214         }
 215         case TYPESPEC_FLOATING_POINT:
 216         case TYPESPEC_INTEGER:
 217         case TYPESPEC_STRING:
 218         default:
 219                 fprintf(fd, "[error] %s: unknown specifier\n", __func__);
 220                 return -EINVAL;
 221         }
 222         return 0;
 223 }
 224
 225 static
 226 int visit_type_specifier_list(FILE *fd, struct ctf_node *type_specifier_list, GString *str)
 227 {
 228         struct ctf_node *iter;
 229         int alias_item_nr = 0;
 230         int ret;
 231
 232         cds_list_for_each_entry(iter, &type_specifier_list->u.type_specifier_list.head, siblings) {
 233                 if (alias_item_nr != 0)
 234                         g_string_append(str, " ");
 235                 alias_item_nr++;
 236                 ret = visit_type_specifier(fd, iter, str);
 237                 if (ret)
 238                         return ret;
 239         }
 240         return 0;
 241 }
 242
 243 static
 244 GQuark create_typealias_identifier(FILE *fd, int depth,
 245         struct ctf_node *type_specifier_list,
 246         struct ctf_node *node_type_declarator)
 247 {
 248         struct ctf_node *iter;
 249         GString *str;
 250         char *str_c;
 251         GQuark alias_q;
 252         int ret;
 253
 254         str = g_string_new("");
 255         ret = visit_type_specifier_list(fd, type_specifier_list, str);
 256         if (ret) {
 257                 g_string_free(str, TRUE);
 258                 return 0;
 259         }
 260         cds_list_for_each_entry(iter, &node_type_declarator->u.type_declarator.pointers, siblings) {
 261                 g_string_append(str, " *");
 262                 if (iter->u.pointer.const_qualifier)
 263                         g_string_append(str, " const");
 264         }
 265         str_c = g_string_free(str, FALSE);
 266         alias_q = g_quark_from_string(str_c);
 267         g_free(str_c);
 268         return alias_q;
 269 }
 270
 271 static
 272 struct declaration *ctf_type_declarator_visit(FILE *fd, int depth,
 273         struct ctf_node *type_specifier_list,
 274         GQuark *field_name,
 275         struct ctf_node *node_type_declarator,
 276         struct declaration_scope *declaration_scope,
 277         struct declaration *nested_declaration,
 278         struct ctf_trace *trace)
 279 {
 280         /*
 281          * Visit type declarator by first taking care of sequence/array
 282          * (recursively). Then, when we get to the identifier, take care
 283          * of pointers.
 284          */
 285
 286         if (node_type_declarator) {
 287                 assert(node_type_declarator->u.type_declarator.type != TYPEDEC_UNKNOWN);
 288
 289                 /* TODO: gcc bitfields not supported yet. */
 290                 if (node_type_declarator->u.type_declarator.bitfield_len != NULL) {
 291                         fprintf(fd, "[error] %s: gcc bitfields are not supported yet.\n", __func__);
 292                         return NULL;
 293                 }
 294         }
 295
 296         if (!nested_declaration) {
 297                 if (node_type_declarator && !cds_list_empty(&node_type_declarator->u.type_declarator.pointers)) {
 298                         GQuark alias_q;
 299
 300                         /*
 301                          * If we have a pointer declarator, it _has_ to be present in
 302                          * the typealiases (else fail).
 303                          */
 304                         alias_q = create_typealias_identifier(fd, depth,
 305                                 type_specifier_list, node_type_declarator);
 306                         nested_declaration = lookup_declaration(alias_q, declaration_scope);
 307                         if (!nested_declaration) {
 308                                 fprintf(fd, "[error] %s: cannot find typealias \"%s\".\n", __func__, g_quark_to_string(alias_q));
 309                                 return NULL;
 310                         }
 311                 } else {
 312                         nested_declaration = ctf_type_specifier_list_visit(fd, depth,
 313                                 type_specifier_list, declaration_scope, trace);
 314                 }
 315         }
 316
 317         if (!node_type_declarator)
 318                 return nested_declaration;
 319
 320         if (node_type_declarator->u.type_declarator.type == TYPEDEC_ID) {
 321                 if (node_type_declarator->u.type_declarator.u.id)
 322                         *field_name = g_quark_from_string(node_type_declarator->u.type_declarator.u.id);
 323                 else
 324                         *field_name = 0;
 325                 return nested_declaration;
 326         } else {
 327                 struct declaration *declaration;
 328                 struct ctf_node *length;
 329
 330                 /* TYPEDEC_NESTED */
 331
 332                 /* create array/sequence, pass nested_declaration as child. */
 333                 length = node_type_declarator->u.type_declarator.u.nested.length;
 334                 if (!length) {
 335                         fprintf(fd, "[error] %s: expecting length type or value.\n", __func__);
 336                         return NULL;
 337                 }
 338                 switch (length->type) {
 339                 case NODE_UNARY_EXPRESSION:
 340                 {
 341                         struct declaration_array *array_declaration;
 342                         size_t len;
 343
 344                         if (length->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT) {
 345                                 fprintf(fd, "[error] %s: array: unexpected unary expression.\n", __func__);
 346                                 return NULL;
 347                         }
 348                         len = length->u.unary_expression.u.unsigned_constant;
 349                         array_declaration = array_declaration_new(len, nested_declaration,
 350                                                 declaration_scope);
 351                         declaration = &array_declaration->p;
 352                         break;
 353                 }
 354                 case NODE_INTEGER:
 355                 case NODE_TYPE_SPECIFIER:
 356                 {
 357                         struct declaration_sequence *sequence_declaration;
 358                         struct declaration_integer *integer_declaration;
 359                         GQuark dummy_id;
 360
 361                         declaration = ctf_type_declarator_visit(fd, depth,
 362                                                 length,
 363                                                 &dummy_id, NULL,
 364                                                 declaration_scope,
 365                                                 NULL, trace);
 366                         assert(declaration->id == CTF_TYPE_INTEGER);
 367                         integer_declaration = container_of(declaration, struct declaration_integer, p);
 368                         sequence_declaration = sequence_declaration_new(integer_declaration,
 369                                         nested_declaration, declaration_scope);
 370                         declaration = &sequence_declaration->p;
 371                         break;
 372                 }
 373                 default:
 374                         assert(0);
 375                 }
 376
 377                 /* Pass it as content of outer container */
 378                 declaration = ctf_type_declarator_visit(fd, depth,
 379                                 type_specifier_list, field_name,
 380                                 node_type_declarator->u.type_declarator.u.nested.type_declarator,
 381                                 declaration_scope, declaration, trace);
 382                 return declaration;
 383         }
 384 }
 385
 386 static
 387 int ctf_struct_type_declarators_visit(FILE *fd, int depth,
 388         struct declaration_struct *struct_declaration,
 389         struct ctf_node *type_specifier_list,
 390         struct cds_list_head *type_declarators,
 391         struct declaration_scope *declaration_scope,
 392         struct ctf_trace *trace)
 393 {
 394         struct ctf_node *iter;
 395         GQuark field_name;
 396
 397         cds_list_for_each_entry(iter, type_declarators, siblings) {
 398                 struct declaration *field_declaration;
 399
 400                 field_declaration = ctf_type_declarator_visit(fd, depth,
 401                                                 type_specifier_list,
 402                                                 &field_name, iter,
 403                                                 struct_declaration->scope,
 404                                                 NULL, trace);
 405                 struct_declaration_add_field(struct_declaration,
 406                                              g_quark_to_string(field_name),
 407                                              field_declaration);
 408         }
 409         return 0;
 410 }
 411
 412 static
 413 int ctf_variant_type_declarators_visit(FILE *fd, int depth,
 414         struct declaration_untagged_variant *untagged_variant_declaration,
 415         struct ctf_node *type_specifier_list,
 416         struct cds_list_head *type_declarators,
 417         struct declaration_scope *declaration_scope,
 418         struct ctf_trace *trace)
 419 {
 420         struct ctf_node *iter;
 421         GQuark field_name;
 422
 423         cds_list_for_each_entry(iter, type_declarators, siblings) {
 424                 struct declaration *field_declaration;
 425
 426                 field_declaration = ctf_type_declarator_visit(fd, depth,
 427                                                 type_specifier_list,
 428                                                 &field_name, iter,
 429                                                 untagged_variant_declaration->scope,
 430                                                 NULL, trace);
 431                 untagged_variant_declaration_add_field(untagged_variant_declaration,
 432                                               g_quark_to_string(field_name),
 433                                               field_declaration);
 434         }
 435         return 0;
 436 }
 437
 438 static
 439 int ctf_typedef_visit(FILE *fd, int depth, struct declaration_scope *scope,
 440                 struct ctf_node *type_specifier_list,
 441                 struct cds_list_head *type_declarators,
 442                 struct ctf_trace *trace)
 443 {
 444         struct ctf_node *iter;
 445         GQuark identifier;
 446
 447         cds_list_for_each_entry(iter, type_declarators, siblings) {
 448                 struct declaration *type_declaration;
 449                 int ret;
 450
 451                 type_declaration = ctf_type_declarator_visit(fd, depth,
 452                                         type_specifier_list,
 453                                         &identifier, iter,
 454                                         scope, NULL, trace);
 455                 ret = register_declaration(identifier, type_declaration, scope);
 456                 if (ret) {
 457                         type_declaration->declaration_free(type_declaration);
 458                         return ret;
 459                 }
 460         }
 461         return 0;
 462 }
 463
 464 static
 465 int ctf_typealias_visit(FILE *fd, int depth, struct declaration_scope *scope,
 466                 struct ctf_node *target, struct ctf_node *alias,
 467                 struct ctf_trace *trace)
 468 {
 469         struct declaration *type_declaration;
 470         struct ctf_node *node;
 471         GQuark dummy_id;
 472         GQuark alias_q;
 473         int err;
 474
 475         /* See ctf_visitor_type_declarator() in the semantic validator. */
 476
 477         /*
 478          * Create target type declaration.
 479          */
 480
 481         if (cds_list_empty(&alias->u.typealias_target.type_declarators))
 482                 node = NULL;
 483         else
 484                 node = _cds_list_first_entry(&alias->u.typealias_target.type_declarators,
 485                                 struct ctf_node, siblings);
 486         type_declaration = ctf_type_declarator_visit(fd, depth,
 487                 target->u.typealias_target.type_specifier_list,
 488                 &dummy_id, node,
 489                 scope, NULL, trace);
 490         if (!type_declaration) {
 491                 fprintf(fd, "[error] %s: problem creating type declaration\n", __func__);
 492                 err = -EINVAL;
 493                 goto error;
 494         }
 495         /*
 496          * The semantic validator does not check whether the target is
 497          * abstract or not (if it has an identifier). Check it here.
 498          */
 499         if (dummy_id != 0) {
 500                 fprintf(fd, "[error] %s: expecting empty identifier\n", __func__);
 501                 err = -EINVAL;
 502                 goto error;
 503         }
 504         /*
 505          * Create alias identifier.
 506          */
 507
 508         node = _cds_list_first_entry(&alias->u.typealias_alias.type_declarators,
 509                                 struct ctf_node, siblings);
 510         alias_q = create_typealias_identifier(fd, depth,
 511                         alias->u.typealias_alias.type_specifier_list, node);
 512         err = register_declaration(alias_q, type_declaration, scope);
 513         if (err)
 514                 goto error;
 515         return 0;
 516
 517 error:
 518         type_declaration->declaration_free(type_declaration);
 519         return err;
 520 }
 521
 522 static
 523 int ctf_struct_declaration_list_visit(FILE *fd, int depth,
 524         struct ctf_node *iter, struct declaration_struct *struct_declaration,
 525         struct ctf_trace *trace)
 526 {
 527         int ret;
 528
 529         switch (iter->type) {
 530         case NODE_TYPEDEF:
 531                 /* For each declarator, declare type and add type to struct declaration scope */
 532                 ret = ctf_typedef_visit(fd, depth,
 533                         struct_declaration->scope,
 534                         iter->u._typedef.type_specifier_list,
 535                         &iter->u._typedef.type_declarators, trace);
 536                 if (ret)
 537                         return ret;
 538                 break;
 539         case NODE_TYPEALIAS:
 540                 /* Declare type with declarator and add type to struct declaration scope */
 541                 ret = ctf_typealias_visit(fd, depth,
 542                         struct_declaration->scope,
 543                         iter->u.typealias.target,
 544                         iter->u.typealias.alias, trace);
 545                 if (ret)
 546                         return ret;
 547                 break;
 548         case NODE_STRUCT_OR_VARIANT_DECLARATION:
 549                 /* Add field to structure declaration */
 550                 ret = ctf_struct_type_declarators_visit(fd, depth,
 551                                 struct_declaration,
 552                                 iter->u.struct_or_variant_declaration.type_specifier_list,
 553                                 &iter->u.struct_or_variant_declaration.type_declarators,
 554                                 struct_declaration->scope, trace);
 555                 if (ret)
 556                         return ret;
 557                 break;
 558         default:
 559                 fprintf(fd, "[error] %s: unexpected node type %d\n", __func__, (int) iter->type);
 560                 assert(0);
 561         }
 562         return 0;
 563 }
 564
 565 static
 566 int ctf_variant_declaration_list_visit(FILE *fd, int depth,
 567         struct ctf_node *iter,
 568         struct declaration_untagged_variant *untagged_variant_declaration,
 569         struct ctf_trace *trace)
 570 {
 571         int ret;
 572
 573         switch (iter->type) {
 574         case NODE_TYPEDEF:
 575                 /* For each declarator, declare type and add type to variant declaration scope */
 576                 ret = ctf_typedef_visit(fd, depth,
 577                         untagged_variant_declaration->scope,
 578                         iter->u._typedef.type_specifier_list,
 579                         &iter->u._typedef.type_declarators, trace);
 580                 if (ret)
 581                         return ret;
 582                 break;
 583         case NODE_TYPEALIAS:
 584                 /* Declare type with declarator and add type to variant declaration scope */
 585                 ret = ctf_typealias_visit(fd, depth,
 586                         untagged_variant_declaration->scope,
 587                         iter->u.typealias.target,
 588                         iter->u.typealias.alias, trace);
 589                 if (ret)
 590                         return ret;
 591                 break;
 592         case NODE_STRUCT_OR_VARIANT_DECLARATION:
 593                 /* Add field to structure declaration */
 594                 ret = ctf_variant_type_declarators_visit(fd, depth,
 595                                 untagged_variant_declaration,
 596                                 iter->u.struct_or_variant_declaration.type_specifier_list,
 597                                 &iter->u.struct_or_variant_declaration.type_declarators,
 598                                 untagged_variant_declaration->scope, trace);
 599                 if (ret)
 600                         return ret;
 601                 break;
 602         default:
 603                 fprintf(fd, "[error] %s: unexpected node type %d\n", __func__, (int) iter->type);
 604                 assert(0);
 605         }
 606         return 0;
 607 }
 608
 609 static
 610 struct declaration *ctf_declaration_struct_visit(FILE *fd,
 611         int depth, const char *name, struct cds_list_head *declaration_list,
 612         int has_body, struct declaration_scope *declaration_scope,
 613         struct ctf_trace *trace)
 614 {
 615         struct declaration_struct *struct_declaration;
 616         struct ctf_node *iter;
 617         int ret;
 618
 619         /*
 620          * For named struct (without body), lookup in
 621          * declaration scope. Don't take reference on struct
 622          * declaration: ref is only taken upon definition.
 623          */
 624         if (!has_body) {
 625                 assert(name);
 626                 struct_declaration =
 627                         lookup_struct_declaration(g_quark_from_string(name),
 628                                                   declaration_scope);
 629                 return &struct_declaration->p;
 630         } else {
 631                 /* For unnamed struct, create type */
 632                 /* For named struct (with body), create type and add to declaration scope */
 633                 if (name) {
 634                         if (lookup_struct_declaration(g_quark_from_string(name),
 635                                                       declaration_scope)) {
 636
 637                                 fprintf(fd, "[error] %s: struct %s already declared in scope\n", __func__, name);
 638                                 return NULL;
 639                         }
 640                 }
 641                 struct_declaration = struct_declaration_new(declaration_scope);
 642                 cds_list_for_each_entry(iter, declaration_list, siblings) {
 643                         ret = ctf_struct_declaration_list_visit(fd, depth + 1, iter,
 644                                 struct_declaration, trace);
 645                         if (ret)
 646                                 goto error;
 647                 }
 648                 if (name) {
 649                         ret = register_struct_declaration(g_quark_from_string(name),
 650                                         struct_declaration,
 651                                         declaration_scope);
 652                         assert(!ret);
 653                 }
 654                 return &struct_declaration->p;
 655         }
 656 error:
 657         struct_declaration->p.declaration_free(&struct_declaration->p);
 658         return NULL;
 659 }
 660
 661 static
 662 struct declaration *ctf_declaration_variant_visit(FILE *fd,
 663         int depth, const char *name, const char *choice,
 664         struct cds_list_head *declaration_list,
 665         int has_body, struct declaration_scope *declaration_scope,
 666         struct ctf_trace *trace)
 667 {
 668         struct declaration_untagged_variant *untagged_variant_declaration;
 669         struct declaration_variant *variant_declaration;
 670         struct ctf_node *iter;
 671         int ret;
 672
 673         /*
 674          * For named variant (without body), lookup in
 675          * declaration scope. Don't take reference on variant
 676          * declaration: ref is only taken upon definition.
 677          */
 678         if (!has_body) {
 679                 assert(name);
 680                 untagged_variant_declaration =
 681                         lookup_variant_declaration(g_quark_from_string(name),
 682                                                    declaration_scope);
 683         } else {
 684                 /* For unnamed variant, create type */
 685                 /* For named variant (with body), create type and add to declaration scope */
 686                 if (name) {
 687                         if (lookup_variant_declaration(g_quark_from_string(name),
 688                                                        declaration_scope)) {
 689
 690                                 fprintf(fd, "[error] %s: variant %s already declared in scope\n", __func__, name);
 691                                 return NULL;
 692                         }
 693                 }
 694                 untagged_variant_declaration = untagged_variant_declaration_new(declaration_scope);
 695                 cds_list_for_each_entry(iter, declaration_list, siblings) {
 696                         ret = ctf_variant_declaration_list_visit(fd, depth + 1, iter,
 697                                 untagged_variant_declaration, trace);
 698                         if (ret)
 699                                 goto error;
 700                 }
 701                 if (name) {
 702                         ret = register_variant_declaration(g_quark_from_string(name),
 703                                         untagged_variant_declaration,
 704                                         declaration_scope);
 705                         assert(!ret);
 706                 }
 707         }
 708         /*
 709          * if tagged, create tagged variant and return. else return
 710          * untagged variant.
 711          */
 712         if (!choice) {
 713                 return &untagged_variant_declaration->p;
 714         } else {
 715                 variant_declaration = variant_declaration_new(untagged_variant_declaration, choice);
 716                 if (!variant_declaration)
 717                         goto error;
 718                 declaration_unref(&untagged_variant_declaration->p);
 719                 return &variant_declaration->p;
 720         }
 721 error:
 722         untagged_variant_declaration->p.declaration_free(&variant_declaration->p);
 723         return NULL;
 724 }
 725
 726 static
 727 int ctf_enumerator_list_visit(FILE *fd, int depth,
 728                 struct ctf_node *enumerator,
 729                 struct declaration_enum *enum_declaration)
 730 {
 731         GQuark q;
 732         struct ctf_node *iter;
 733
 734         q = g_quark_from_string(enumerator->u.enumerator.id);
 735         if (enum_declaration->integer_declaration->signedness) {
 736                 int64_t start, end;
 737                 int nr_vals = 0;
 738
 739                 cds_list_for_each_entry(iter, &enumerator->u.enumerator.values, siblings) {
 740                         int64_t *target;
 741
 742                         assert(iter->type == NODE_UNARY_EXPRESSION);
 743                         if (nr_vals == 0)
 744                                 target = &start;
 745                         else
 746                                 target = &end;
 747
 748                         switch (iter->u.unary_expression.type) {
 749                         case UNARY_SIGNED_CONSTANT:
 750                                 *target = iter->u.unary_expression.u.signed_constant;
 751                                 break;
 752                         case UNARY_UNSIGNED_CONSTANT:
 753                                 *target = iter->u.unary_expression.u.unsigned_constant;
 754                                 break;
 755                         default:
 756                                 fprintf(fd, "[error] %s: invalid enumerator\n", __func__);
 757                                 return -EINVAL;
 758                         }
 759                         if (nr_vals > 1) {
 760                                 fprintf(fd, "[error] %s: invalid enumerator\n", __func__);
 761                                 return -EINVAL;
 762                         }
 763                         nr_vals++;
 764                 }
 765                 if (nr_vals == 1)
 766                         end = start;
 767                 enum_signed_insert(enum_declaration, start, end, q);
 768         } else {
 769                 uint64_t start, end;
 770                 int nr_vals = 0;
 771
 772                 cds_list_for_each_entry(iter, &enumerator->u.enumerator.values, siblings) {
 773                         uint64_t *target;
 774
 775                         assert(iter->type == NODE_UNARY_EXPRESSION);
 776                         if (nr_vals == 0)
 777                                 target = &start;
 778                         else
 779                                 target = &end;
 780
 781                         switch (iter->u.unary_expression.type) {
 782                         case UNARY_UNSIGNED_CONSTANT:
 783                                 *target = iter->u.unary_expression.u.unsigned_constant;
 784                                 break;
 785                         case UNARY_SIGNED_CONSTANT:
 786                                 /*
 787                                  * We don't accept signed constants for enums with unsigned
 788                                  * container type.
 789                                  */
 790                                 fprintf(fd, "[error] %s: invalid enumerator (signed constant encountered, but enum container type is unsigned)\n", __func__);
 791                                 return -EINVAL;
 792                         default:
 793                                 fprintf(fd, "[error] %s: invalid enumerator\n", __func__);
 794                                 return -EINVAL;
 795                         }
 796                         if (nr_vals > 1) {
 797                                 fprintf(fd, "[error] %s: invalid enumerator\n", __func__);
 798                                 return -EINVAL;
 799                         }
 800                         nr_vals++;
 801                 }
 802                 if (nr_vals == 1)
 803                         end = start;
 804                 enum_unsigned_insert(enum_declaration, start, end, q);
 805         }
 806         return 0;
 807 }
 808
 809 static
 810 struct declaration *ctf_declaration_enum_visit(FILE *fd, int depth,
 811                         const char *name,
 812                         struct ctf_node *container_type,
 813                         struct cds_list_head *enumerator_list,
 814                         int has_body,
 815                         struct declaration_scope *declaration_scope,
 816                         struct ctf_trace *trace)
 817 {
 818         struct declaration *declaration;
 819         struct declaration_enum *enum_declaration;
 820         struct declaration_integer *integer_declaration;
 821         struct ctf_node *iter;
 822         GQuark dummy_id;
 823         int ret;
 824
 825         /*
 826          * For named enum (without body), lookup in
 827          * declaration scope. Don't take reference on enum
 828          * declaration: ref is only taken upon definition.
 829          */
 830         if (!has_body) {
 831                 assert(name);
 832                 enum_declaration =
 833                         lookup_enum_declaration(g_quark_from_string(name),
 834                                                 declaration_scope);
 835                 return &enum_declaration->p;
 836         } else {
 837                 /* For unnamed enum, create type */
 838                 /* For named enum (with body), create type and add to declaration scope */
 839                 if (name) {
 840                         if (lookup_enum_declaration(g_quark_from_string(name),
 841                                                     declaration_scope)) {
 842
 843                                 fprintf(fd, "[error] %s: enum %s already declared in scope\n", __func__, name);
 844                                 return NULL;
 845                         }
 846                 }
 847                 if (!container_type) {
 848                                 fprintf(fd, "[error] %s: missing container type for enumeration\n", __func__);
 849                                 return NULL;
 850
 851                 }
 852                 switch (container_type->type) {
 853                 case NODE_INTEGER:
 854                 case NODE_TYPE_SPECIFIER:
 855                         declaration = ctf_type_declarator_visit(fd, depth,
 856                                                 container_type,
 857                                                 &dummy_id, NULL,
 858                                                 declaration_scope,
 859                                                 NULL, trace);
 860                         assert(declaration->id == CTF_TYPE_INTEGER);
 861                         integer_declaration = container_of(declaration, struct declaration_integer, p);
 862                         break;
 863                 default:
 864                         assert(0);
 865                 }
 866                 enum_declaration = enum_declaration_new(integer_declaration);
 867                 declaration_unref(&integer_declaration->p);     /* leave ref to enum */
 868                 cds_list_for_each_entry(iter, enumerator_list, siblings) {
 869                         ret = ctf_enumerator_list_visit(fd, depth + 1, iter, enum_declaration);
 870                         if (ret)
 871                                 goto error;
 872                 }
 873                 if (name) {
 874                         ret = register_enum_declaration(g_quark_from_string(name),
 875                                         enum_declaration,
 876                                         declaration_scope);
 877                         assert(!ret);
 878                 }
 879                 return &enum_declaration->p;
 880         }
 881 error:
 882         enum_declaration->p.declaration_free(&enum_declaration->p);
 883         return NULL;
 884 }
 885
 886 static
 887 struct declaration *ctf_declaration_type_specifier_visit(FILE *fd, int depth,
 888                 struct ctf_node *type_specifier_list,
 889                 struct declaration_scope *declaration_scope)
 890 {
 891         GString *str;
 892         struct declaration *declaration;
 893         char *str_c;
 894         int ret;
 895         GQuark id_q;
 896
 897         str = g_string_new("");
 898         ret = visit_type_specifier_list(fd, type_specifier_list, str);
 899         if (ret)
 900                 return NULL;
 901         str_c = g_string_free(str, FALSE);
 902         id_q = g_quark_from_string(str_c);
 903         g_free(str_c);
 904         declaration = lookup_declaration(id_q, declaration_scope);
 905         return declaration;
 906 }
 907
 908 /*
 909  * Returns 0/1 boolean, or < 0 on error.
 910  */
 911 static
 912 int get_boolean(FILE *fd, int depth, struct ctf_node *unary_expression)
 913 {
 914         if (unary_expression->type != NODE_UNARY_EXPRESSION) {
 915                 fprintf(fd, "[error] %s: expecting unary expression\n",
 916                         __func__);
 917                 return -EINVAL;
 918         }
 919         switch (unary_expression->u.unary_expression.type) {
 920         case UNARY_UNSIGNED_CONSTANT:
 921                 if (unary_expression->u.unary_expression.u.unsigned_constant == 0)
 922                         return 0;
 923                 else
 924                         return 1;
 925         case UNARY_SIGNED_CONSTANT:
 926                 if (unary_expression->u.unary_expression.u.signed_constant == 0)
 927                         return 0;
 928                 else
 929                         return 1;
 930         case UNARY_STRING:
 931                 if (!strcmp(unary_expression->u.unary_expression.u.string, "true"))
 932                         return 1;
 933                 else if (!strcmp(unary_expression->u.unary_expression.u.string, "TRUE"))
 934                         return 1;
 935                 else if (!strcmp(unary_expression->u.unary_expression.u.string, "false"))
 936                         return 0;
 937                 else if (!strcmp(unary_expression->u.unary_expression.u.string, "FALSE"))
 938                         return 0;
 939                 else {
 940                         fprintf(fd, "[error] %s: unexpected string \"%s\"\n",
 941                                 __func__, unary_expression->u.unary_expression.u.string);
 942                         return -EINVAL;
 943                 }
 944                 break;
 945         default:
 946                 fprintf(fd, "[error] %s: unexpected unary expression type\n",
 947                         __func__);
 948                 return -EINVAL;
 949         }
 950
 951 }
 952
 953 static
 954 int get_byte_order(FILE *fd, int depth, struct ctf_node *unary_expression,
 955                 struct ctf_trace *trace)
 956 {
 957         int byte_order;
 958
 959         if (unary_expression->u.unary_expression.type != UNARY_STRING) {
 960                 fprintf(fd, "[error] %s: byte_order: expecting string\n",
 961                         __func__);
 962                 return -EINVAL;
 963         }
 964         if (!strcmp(unary_expression->u.unary_expression.u.string, "native"))
 965                 byte_order = trace->byte_order;
 966         else if (!strcmp(unary_expression->u.unary_expression.u.string, "network"))
 967                 byte_order = BIG_ENDIAN;
 968         else if (!strcmp(unary_expression->u.unary_expression.u.string, "be"))
 969                 byte_order = BIG_ENDIAN;
 970         else if (!strcmp(unary_expression->u.unary_expression.u.string, "le"))
 971                 byte_order = LITTLE_ENDIAN;
 972         else {
 973                 fprintf(fd, "[error] %s: unexpected string \"%s\". Should be \"native\", \"network\", \"be\" or \"le\".\n",
 974                         __func__, unary_expression->u.unary_expression.u.string);
 975                 return -EINVAL;
 976         }
 977         return byte_order;
 978 }
 979
 980 static
 981 struct declaration *ctf_declaration_integer_visit(FILE *fd, int depth,
 982                 struct cds_list_head *expressions,
 983                 struct ctf_trace *trace)
 984 {
 985         struct ctf_node *expression;
 986         uint64_t alignment, size;
 987         int byte_order = trace->byte_order;
 988         int signedness = 0;
 989         int has_alignment = 0, has_size = 0;
 990         struct declaration_integer *integer_declaration;
 991
 992         cds_list_for_each_entry(expression, expressions, siblings) {
 993                 struct ctf_node *left, *right;
 994
 995                 left = _cds_list_first_entry(&expression->u.ctf_expression.left, struct ctf_node, siblings);
 996                 right = _cds_list_first_entry(&expression->u.ctf_expression.right, struct ctf_node, siblings);
 997                 assert(left->u.unary_expression.type == UNARY_STRING);
 998                 if (!strcmp(left->u.unary_expression.u.string, "signed")) {
 999                         signedness = get_boolean(fd, depth, right);
1000                         if (signedness < 0)
1001                                 return NULL;
1002                 } else if (!strcmp(left->u.unary_expression.u.string, "byte_order")) {
1003                         byte_order = get_byte_order(fd, depth, right, trace);
1004                         if (byte_order < 0)
1005                                 return NULL;
1006                 } else if (!strcmp(left->u.unary_expression.u.string, "size")) {
1007                         if (right->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT) {
1008                                 fprintf(fd, "[error] %s: size: expecting unsigned constant\n",
1009                                         __func__);
1010                                 return NULL;
1011                         }
1012                         size = right->u.unary_expression.u.unsigned_constant;
1013                         has_size = 1;
1014                 } else if (!strcmp(left->u.unary_expression.u.string, "align")) {
1015                         if (right->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT) {
1016                                 fprintf(fd, "[error] %s: align: expecting unsigned constant\n",
1017                                         __func__);
1018                                 return NULL;
1019                         }
1020                         alignment = right->u.unary_expression.u.unsigned_constant;
1021                         has_alignment = 1;
1022                 } else {
1023                         fprintf(fd, "[error] %s: unknown attribute name %s\n",
1024                                 __func__, left->u.unary_expression.u.string);
1025                         return NULL;
1026                 }
1027         }
1028         if (!has_size) {
1029                 fprintf(fd, "[error] %s: missing size attribute\n", __func__);
1030                 return NULL;
1031         }
1032         if (!has_alignment) {
1033                 if (size % CHAR_BIT) {
1034                         /* bit-packed alignment */
1035                         alignment = 1;
1036                 } else {
1037                         /* byte-packed alignment */
1038                         alignment = CHAR_BIT;
1039                 }
1040         }
1041         integer_declaration = integer_declaration_new(size,
1042                                 byte_order, signedness, alignment);
1043         return &integer_declaration->p;
1044 }
1045
1046 static
1047 struct declaration *ctf_declaration_floating_point_visit(FILE *fd, int depth,
1048                 struct cds_list_head *expressions,
1049                 struct ctf_trace *trace)
1050 {
1051         struct ctf_node *expression;
1052         uint64_t alignment, exp_dig, mant_dig, byte_order = trace->byte_order;
1053         int has_alignment = 0, has_exp_dig = 0, has_mant_dig = 0;
1054         struct declaration_float *float_declaration;
1055
1056         cds_list_for_each_entry(expression, expressions, siblings) {
1057                 struct ctf_node *left, *right;
1058
1059                 left = _cds_list_first_entry(&expression->u.ctf_expression.left, struct ctf_node, siblings);
1060                 right = _cds_list_first_entry(&expression->u.ctf_expression.right, struct ctf_node, siblings);
1061                 assert(left->u.unary_expression.type == UNARY_STRING);
1062                 if (!strcmp(left->u.unary_expression.u.string, "byte_order")) {
1063                         byte_order = get_byte_order(fd, depth, right, trace);
1064                         if (byte_order < 0)
1065                                 return NULL;
1066                 } else if (!strcmp(left->u.unary_expression.u.string, "exp_dig")) {
1067                         if (right->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT) {
1068                                 fprintf(fd, "[error] %s: exp_dig: expecting unsigned constant\n",
1069                                         __func__);
1070                                 return NULL;
1071                         }
1072                         exp_dig = right->u.unary_expression.u.unsigned_constant;
1073                         has_exp_dig = 1;
1074                 } else if (!strcmp(left->u.unary_expression.u.string, "mant_dig")) {
1075                         if (right->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT) {
1076                                 fprintf(fd, "[error] %s: mant_dig: expecting unsigned constant\n",
1077                                         __func__);
1078                                 return NULL;
1079                         }
1080                         mant_dig = right->u.unary_expression.u.unsigned_constant;
1081                         has_mant_dig = 1;
1082                 } else if (!strcmp(left->u.unary_expression.u.string, "align")) {
1083                         if (right->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT) {
1084                                 fprintf(fd, "[error] %s: align: expecting unsigned constant\n",
1085                                         __func__);
1086                                 return NULL;
1087                         }
1088                         alignment = right->u.unary_expression.u.unsigned_constant;
1089                         has_alignment = 1;
1090                 } else {
1091                         fprintf(fd, "[error] %s: unknown attribute name %s\n",
1092                                 __func__, left->u.unary_expression.u.string);
1093                         return NULL;
1094                 }
1095         }
1096         if (!has_mant_dig) {
1097                 fprintf(fd, "[error] %s: missing mant_dig attribute\n", __func__);
1098                 return NULL;
1099         }
1100         if (!has_exp_dig) {
1101                 fprintf(fd, "[error] %s: missing exp_dig attribute\n", __func__);
1102                 return NULL;
1103         }
1104         if (!has_alignment) {
1105                 if ((mant_dig + exp_dig) % CHAR_BIT) {
1106                         /* bit-packed alignment */
1107                         alignment = 1;
1108                 } else {
1109                         /* byte-packed alignment */
1110                         alignment = CHAR_BIT;
1111                 }
1112         }
1113         float_declaration = float_declaration_new(mant_dig, exp_dig,
1114                                 byte_order, alignment);
1115         return &float_declaration->p;
1116 }
1117
1118 static
1119 struct declaration *ctf_declaration_string_visit(FILE *fd, int depth,
1120                 struct cds_list_head *expressions,
1121                 struct ctf_trace *trace)
1122 {
1123         struct ctf_node *expression;
1124         const char *encoding_c = NULL;
1125         enum ctf_string_encoding encoding = CTF_STRING_UTF8;
1126         struct declaration_string *string_declaration;
1127
1128         cds_list_for_each_entry(expression, expressions, siblings) {
1129                 struct ctf_node *left, *right;
1130
1131                 left = _cds_list_first_entry(&expression->u.ctf_expression.left, struct ctf_node, siblings);
1132                 right = _cds_list_first_entry(&expression->u.ctf_expression.right, struct ctf_node, siblings);
1133                 assert(left->u.unary_expression.type == UNARY_STRING);
1134                 if (!strcmp(left->u.unary_expression.u.string, "encoding")) {
1135                         if (right->u.unary_expression.type != UNARY_STRING) {
1136                                 fprintf(fd, "[error] %s: encoding: expecting string\n",
1137                                         __func__);
1138                                 return NULL;
1139                         }
1140                         encoding_c = right->u.unary_expression.u.string;
1141                 } else {
1142                         fprintf(fd, "[error] %s: unknown attribute name %s\n",
1143                                 __func__, left->u.unary_expression.u.string);
1144                         return NULL;
1145                 }
1146         }
1147         if (encoding_c && !strcmp(encoding_c, "ASCII"))
1148                 encoding = CTF_STRING_ASCII;
1149         string_declaration = string_declaration_new(encoding);
1150         return &string_declaration->p;
1151 }
1152
1153
1154 static
1155 struct declaration *ctf_type_specifier_list_visit(FILE *fd,
1156                 int depth, struct ctf_node *type_specifier_list,
1157                 struct declaration_scope *declaration_scope,
1158                 struct ctf_trace *trace)
1159 {
1160         struct ctf_node *first;
1161         struct ctf_node *node;
1162
1163         first = _cds_list_first_entry(&type_specifier_list->u.type_specifier_list.head, struct ctf_node, siblings);
1164
1165         assert(first->type == NODE_TYPE_SPECIFIER);
1166
1167         node = first->u.type_specifier.node;
1168
1169         switch (first->u.type_specifier.type) {
1170         case TYPESPEC_FLOATING_POINT:
1171                 return ctf_declaration_floating_point_visit(fd, depth,
1172                         &node->u.floating_point.expressions, trace);
1173         case TYPESPEC_INTEGER:
1174                 return ctf_declaration_integer_visit(fd, depth,
1175                         &node->u.integer.expressions, trace);
1176         case TYPESPEC_STRING:
1177                 return ctf_declaration_string_visit(fd, depth,
1178                         &first->u.string.expressions, trace);
1179         case TYPESPEC_STRUCT:
1180                 return ctf_declaration_struct_visit(fd, depth,
1181                         node->u._struct.name,
1182                         &node->u._struct.declaration_list,
1183                         node->u._struct.has_body,
1184                         declaration_scope,
1185                         trace);
1186         case TYPESPEC_VARIANT:
1187                 return ctf_declaration_variant_visit(fd, depth,
1188                         node->u.variant.name,
1189                         node->u.variant.choice,
1190                         &node->u.variant.declaration_list,
1191                         node->u.variant.has_body,
1192                         declaration_scope,
1193                         trace);
1194         case TYPESPEC_ENUM:
1195                 return ctf_declaration_enum_visit(fd, depth,
1196                         node->u._enum.enum_id,
1197                         node->u._enum.container_type,
1198                         &node->u._enum.enumerator_list,
1199                         node->u._enum.has_body,
1200                         declaration_scope,
1201                         trace);
1202
1203         case TYPESPEC_VOID:
1204         case TYPESPEC_CHAR:
1205         case TYPESPEC_SHORT:
1206         case TYPESPEC_INT:
1207         case TYPESPEC_LONG:
1208         case TYPESPEC_FLOAT:
1209         case TYPESPEC_DOUBLE:
1210         case TYPESPEC_SIGNED:
1211         case TYPESPEC_UNSIGNED:
1212         case TYPESPEC_BOOL:
1213         case TYPESPEC_COMPLEX:
1214         case TYPESPEC_IMAGINARY:
1215         case TYPESPEC_CONST:
1216         case TYPESPEC_ID_TYPE:
1217                 return ctf_declaration_type_specifier_visit(fd, depth,
1218                         type_specifier_list, declaration_scope);
1219         default:
1220                 fprintf(fd, "[error] %s: unexpected node type %d\n", __func__, (int) first->u.type_specifier.type);
1221                 return NULL;
1222         }
1223 }
1224
1225 static
1226 int ctf_event_declaration_visit(FILE *fd, int depth, struct ctf_node *node, struct ctf_event *event, struct ctf_trace *trace)
1227 {
1228         int ret = 0;
1229
1230         switch (node->type) {
1231         case NODE_TYPEDEF:
1232                 ret = ctf_typedef_visit(fd, depth + 1,
1233                                         event->declaration_scope,
1234                                         node->u._typedef.type_specifier_list,
1235                                         &node->u._typedef.type_declarators,
1236                                         trace);
1237                 if (ret)
1238                         return ret;
1239                 break;
1240         case NODE_TYPEALIAS:
1241                 ret = ctf_typealias_visit(fd, depth + 1,
1242                                 event->declaration_scope,
1243                                 node->u.typealias.target, node->u.typealias.alias,
1244                                 trace);
1245                 if (ret)
1246                         return ret;
1247                 break;
1248         case NODE_CTF_EXPRESSION:
1249         {
1250                 char *left;
1251
1252                 left = concatenate_unary_strings(&node->u.ctf_expression.left);
1253                 if (!strcmp(left, "name")) {
1254                         char *right;
1255
1256                         if (CTF_EVENT_FIELD_IS_SET(event, name))
1257                                 return -EPERM;
1258                         right = concatenate_unary_strings(&node->u.ctf_expression.right);
1259                         if (!right) {
1260                                 fprintf(fd, "[error] %s: unexpected unary expression for event name\n", __func__);
1261                                 return -EINVAL;
1262                         }
1263                         event->name = g_quark_from_string(right);
1264                         g_free(right);
1265                         CTF_EVENT_SET_FIELD(event, name);
1266                 } else if (!strcmp(left, "id")) {
1267                         if (CTF_EVENT_FIELD_IS_SET(event, id))
1268                                 return -EPERM;
1269                         ret = get_unary_unsigned(&node->u.ctf_expression.right, &event->id);
1270                         if (ret) {
1271                                 fprintf(fd, "[error] %s: unexpected unary expression for event id\n", __func__);
1272                                 return -EINVAL;
1273                         }
1274                         CTF_EVENT_SET_FIELD(event, id);
1275                 } else if (!strcmp(left, "stream_id")) {
1276                         if (CTF_EVENT_FIELD_IS_SET(event, stream_id))
1277                                 return -EPERM;
1278                         ret = get_unary_unsigned(&node->u.ctf_expression.right, &event->stream_id);
1279                         if (ret) {
1280                                 fprintf(fd, "[error] %s: unexpected unary expression for event stream_id\n", __func__);
1281                                 return -EINVAL;
1282                         }
1283                         event->stream = trace_stream_lookup(trace, event->stream_id);
1284                         if (!event->stream) {
1285                                 fprintf(fd, "[error] %s: stream id %" PRIu64 " cannot be found\n", __func__, event->stream_id);
1286                                 return -EINVAL;
1287                         }
1288                         CTF_EVENT_SET_FIELD(event, stream_id);
1289                 } else if (!strcmp(left, "context")) {
1290                         struct declaration *declaration;
1291
1292                         declaration = ctf_type_specifier_list_visit(fd, depth,
1293                                         _cds_list_first_entry(&node->u.ctf_expression.right,
1294                                                 struct ctf_node, siblings),
1295                                         event->declaration_scope, trace);
1296                         if (!declaration)
1297                                 return -EPERM;
1298                         if (declaration->id != CTF_TYPE_STRUCT)
1299                                 return -EPERM;
1300                         event->context_decl = container_of(declaration, struct declaration_struct, p);
1301                 } else if (!strcmp(left, "fields")) {
1302                         struct declaration *declaration;
1303
1304                         declaration = ctf_type_specifier_list_visit(fd, depth,
1305                                         _cds_list_first_entry(&node->u.ctf_expression.right,
1306                                                 struct ctf_node, siblings),
1307                                         event->declaration_scope, trace);
1308                         if (!declaration)
1309                                 return -EPERM;
1310                         if (declaration->id != CTF_TYPE_STRUCT)
1311                                 return -EPERM;
1312                         event->fields_decl = container_of(declaration, struct declaration_struct, p);
1313                 }
1314                 g_free(left);
1315                 break;
1316         }
1317         default:
1318                 return -EPERM;
1319         /* TODO: declaration specifier should be added. */
1320         }
1321
1322         return 0;
1323 }
1324
1325 static
1326 int ctf_event_visit(FILE *fd, int depth, struct ctf_node *node,
1327                     struct declaration_scope *parent_declaration_scope, struct ctf_trace *trace)
1328 {
1329         int ret = 0;
1330         struct ctf_node *iter;
1331         struct ctf_event *event;
1332         struct definition_scope *parent_def_scope;
1333
1334         event = g_new0(struct ctf_event, 1);
1335         event->declaration_scope = new_declaration_scope(parent_declaration_scope);
1336         cds_list_for_each_entry(iter, &node->u.event.declaration_list, siblings) {
1337                 ret = ctf_event_declaration_visit(fd, depth + 1, iter, event, trace);
1338                 if (ret)
1339                         goto error;
1340         }
1341         if (!CTF_EVENT_FIELD_IS_SET(event, name)) {
1342                 ret = -EPERM;
1343                 goto error;
1344         }
1345         if (!CTF_EVENT_FIELD_IS_SET(event, id)) {
1346                 ret = -EPERM;
1347                 goto error;
1348         }
1349         if (!CTF_EVENT_FIELD_IS_SET(event, stream_id)) {
1350                 ret = -EPERM;
1351                 goto error;
1352         }
1353         if (event->stream->events_by_id->len <= event->id)
1354                 g_ptr_array_set_size(event->stream->events_by_id, event->id + 1);
1355         g_ptr_array_index(event->stream->events_by_id, event->id) = event;
1356         g_hash_table_insert(event->stream->event_quark_to_id,
1357                             (gpointer)(unsigned long) event->name,
1358                             &event->id);
1359         parent_def_scope = event->stream->definition_scope;
1360         if (event->context_decl) {
1361                 event->context =
1362                         container_of(
1363                         event->context_decl->p.definition_new(&event->context_decl->p,
1364                                 parent_def_scope, 0, 0),
1365                         struct definition_struct, p);
1366                 set_dynamic_definition_scope(&event->context->p,
1367                                              event->context->scope,
1368                                              "event.context");
1369                 parent_def_scope = event->context->scope;
1370                 declaration_unref(&event->context_decl->p);
1371         }
1372         if (event->fields_decl) {
1373                 event->fields =
1374                         container_of(
1375                         event->fields_decl->p.definition_new(&event->fields_decl->p,
1376                                 parent_def_scope, 0, 0),
1377                         struct definition_struct, p);
1378                 set_dynamic_definition_scope(&event->fields->p,
1379                                              event->fields->scope,
1380                                              "event.fields");
1381                 parent_def_scope = event->fields->scope;
1382                 declaration_unref(&event->fields_decl->p);
1383         }
1384         return 0;
1385
1386 error:
1387         declaration_unref(&event->fields_decl->p);
1388         declaration_unref(&event->context_decl->p);
1389         free_declaration_scope(event->declaration_scope);
1390         g_free(event);
1391         return ret;
1392 }
1393
1394
1395 static
1396 int ctf_stream_declaration_visit(FILE *fd, int depth, struct ctf_node *node, struct ctf_stream *stream, struct ctf_trace *trace)
1397 {
1398         int ret = 0;
1399
1400         switch (node->type) {
1401         case NODE_TYPEDEF:
1402                 ret = ctf_typedef_visit(fd, depth + 1,
1403                                         stream->declaration_scope,
1404                                         node->u._typedef.type_specifier_list,
1405                                         &node->u._typedef.type_declarators,
1406                                         trace);
1407                 if (ret)
1408                         return ret;
1409                 break;
1410         case NODE_TYPEALIAS:
1411                 ret = ctf_typealias_visit(fd, depth + 1,
1412                                 stream->declaration_scope,
1413                                 node->u.typealias.target, node->u.typealias.alias,
1414                                 trace);
1415                 if (ret)
1416                         return ret;
1417                 break;
1418         case NODE_CTF_EXPRESSION:
1419         {
1420                 char *left;
1421
1422                 left = concatenate_unary_strings(&node->u.ctf_expression.left);
1423                 if (!strcmp(left, "stream_id")) {
1424                         if (CTF_STREAM_FIELD_IS_SET(stream, stream_id))
1425                                 return -EPERM;
1426                         ret = get_unary_unsigned(&node->u.ctf_expression.right, &stream->stream_id);
1427                         if (ret) {
1428                                 fprintf(fd, "[error] %s: unexpected unary expression for event stream_id\n", __func__);
1429                                 return -EINVAL;
1430                         }
1431                         CTF_STREAM_SET_FIELD(stream, stream_id);
1432                 } else if (!strcmp(left, "event.header")) {
1433                         struct declaration *declaration;
1434
1435                         declaration = ctf_type_specifier_list_visit(fd, depth,
1436                                         _cds_list_first_entry(&node->u.ctf_expression.right,
1437                                                 struct ctf_node, siblings),
1438                                         stream->declaration_scope, trace);
1439                         if (!declaration)
1440                                 return -EPERM;
1441                         if (declaration->id != CTF_TYPE_STRUCT)
1442                                 return -EPERM;
1443                         stream->event_header_decl = container_of(declaration, struct declaration_struct, p);
1444                 } else if (!strcmp(left, "event.context")) {
1445                         struct declaration *declaration;
1446
1447                         declaration = ctf_type_specifier_list_visit(fd, depth,
1448                                         _cds_list_first_entry(&node->u.ctf_expression.right,
1449                                                 struct ctf_node, siblings),
1450                                         stream->declaration_scope, trace);
1451                         if (!declaration)
1452                                 return -EPERM;
1453                         if (declaration->id != CTF_TYPE_STRUCT)
1454                                 return -EPERM;
1455                         stream->event_context_decl = container_of(declaration, struct declaration_struct, p);
1456                 } else if (!strcmp(left, "packet.context")) {
1457                         struct declaration *declaration;
1458
1459                         declaration = ctf_type_specifier_list_visit(fd, depth,
1460                                         _cds_list_first_entry(&node->u.ctf_expression.right,
1461                                                 struct ctf_node, siblings),
1462                                         stream->declaration_scope, trace);
1463                         if (!declaration)
1464                                 return -EPERM;
1465                         if (declaration->id != CTF_TYPE_STRUCT)
1466                                 return -EPERM;
1467                         stream->packet_context_decl = container_of(declaration, struct declaration_struct, p);
1468                 }
1469                 g_free(left);
1470                 break;
1471         }
1472         default:
1473                 return -EPERM;
1474         /* TODO: declaration specifier should be added. */
1475         }
1476
1477         return 0;
1478 }
1479
1480 static
1481 int ctf_stream_visit(FILE *fd, int depth, struct ctf_node *node,
1482                      struct declaration_scope *parent_declaration_scope, struct ctf_trace *trace)
1483 {
1484         int ret = 0;
1485         struct ctf_node *iter;
1486         struct ctf_stream *stream;
1487         struct definition_scope *parent_def_scope;
1488
1489         stream = g_new0(struct ctf_stream, 1);
1490         stream->declaration_scope = new_declaration_scope(parent_declaration_scope);
1491         stream->events_by_id = g_ptr_array_new();
1492         stream->event_quark_to_id = g_hash_table_new(g_int_hash, g_int_equal);
1493         cds_list_for_each_entry(iter, &node->u.stream.declaration_list, siblings) {
1494                 ret = ctf_stream_declaration_visit(fd, depth + 1, iter, stream, trace);
1495                 if (ret)
1496                         goto error;
1497         }
1498         if (!CTF_STREAM_FIELD_IS_SET(stream, stream_id)) {
1499                 ret = -EPERM;
1500                 goto error;
1501         }
1502         if (trace->streams->len <= stream->stream_id)
1503                 g_ptr_array_set_size(trace->streams, stream->stream_id + 1);
1504         g_ptr_array_index(trace->streams, stream->stream_id) = stream;
1505
1506         parent_def_scope = NULL;
1507         if (stream->packet_context_decl) {
1508                 stream->packet_context =
1509                         container_of(
1510                         stream->packet_context_decl->p.definition_new(&stream->packet_context_decl->p,
1511                                 parent_def_scope, 0, 0),
1512                         struct definition_struct, p);
1513                 set_dynamic_definition_scope(&stream->packet_context->p,
1514                                              stream->packet_context->scope,
1515                                              "stream.packet.context");
1516                 parent_def_scope = stream->packet_context->scope;
1517                 declaration_unref(&stream->packet_context_decl->p);
1518         }
1519         if (stream->event_header_decl) {
1520                 stream->event_header =
1521                         container_of(
1522                         stream->event_header_decl->p.definition_new(&stream->event_header_decl->p,
1523                                 parent_def_scope, 0, 0),
1524                         struct definition_struct, p);
1525                 set_dynamic_definition_scope(&stream->event_header->p,
1526                                              stream->event_header->scope,
1527                                              "stream.event.header");
1528                 parent_def_scope = stream->event_header->scope;
1529                 declaration_unref(&stream->event_header_decl->p);
1530         }
1531         if (stream->event_context_decl) {
1532                 stream->event_context =
1533                         container_of(
1534                         stream->event_context_decl->p.definition_new(&stream->event_context_decl->p,
1535                                 parent_def_scope, 0, 0),
1536                         struct definition_struct, p);
1537                 set_dynamic_definition_scope(&stream->event_context->p,
1538                                              stream->event_context->scope,
1539                                              "stream.event.context");
1540                 parent_def_scope = stream->event_context->scope;
1541                 declaration_unref(&stream->event_context_decl->p);
1542         }
1543         stream->definition_scope = parent_def_scope;
1544
1545         return 0;
1546
1547 error:
1548         declaration_unref(&stream->event_header_decl->p);
1549         declaration_unref(&stream->event_context_decl->p);
1550         declaration_unref(&stream->packet_context_decl->p);
1551         g_ptr_array_free(stream->events_by_id, TRUE);
1552         g_hash_table_destroy(stream->event_quark_to_id);
1553         free_declaration_scope(stream->declaration_scope);
1554         g_free(stream);
1555         return ret;
1556 }
1557
1558 static
1559 int ctf_trace_declaration_visit(FILE *fd, int depth, struct ctf_node *node, struct ctf_trace *trace)
1560 {
1561         int ret = 0;
1562
1563         switch (node->type) {
1564         case NODE_TYPEDEF:
1565                 ret = ctf_typedef_visit(fd, depth + 1,
1566                                         trace->declaration_scope,
1567                                         node->u._typedef.type_specifier_list,
1568                                         &node->u._typedef.type_declarators,
1569                                         trace);
1570                 if (ret)
1571                         return ret;
1572                 break;
1573         case NODE_TYPEALIAS:
1574                 ret = ctf_typealias_visit(fd, depth + 1,
1575                                 trace->declaration_scope,
1576                                 node->u.typealias.target, node->u.typealias.alias,
1577                                 trace);
1578                 if (ret)
1579                         return ret;
1580                 break;
1581         case NODE_CTF_EXPRESSION:
1582         {
1583                 char *left;
1584
1585                 left = concatenate_unary_strings(&node->u.ctf_expression.left);
1586                 if (!strcmp(left, "major")) {
1587                         if (CTF_TRACE_FIELD_IS_SET(trace, major))
1588                                 return -EPERM;
1589                         ret = get_unary_unsigned(&node->u.ctf_expression.right, &trace->major);
1590                         if (ret) {
1591                                 fprintf(fd, "[error] %s: unexpected unary expression for trace major number\n", __func__);
1592                                 return -EINVAL;
1593                         }
1594                         CTF_TRACE_SET_FIELD(trace, major);
1595                 } else if (!strcmp(left, "minor")) {
1596                         if (CTF_TRACE_FIELD_IS_SET(trace, minor))
1597                                 return -EPERM;
1598                         ret = get_unary_unsigned(&node->u.ctf_expression.right, &trace->minor);
1599                         if (ret) {
1600                                 fprintf(fd, "[error] %s: unexpected unary expression for trace minor number\n", __func__);
1601                                 return -EINVAL;
1602                         }
1603                         CTF_TRACE_SET_FIELD(trace, minor);
1604                 } else if (!strcmp(left, "word_size")) {
1605                         if (CTF_TRACE_FIELD_IS_SET(trace, word_size))
1606                                 return -EPERM;
1607                         ret = get_unary_unsigned(&node->u.ctf_expression.right, &trace->word_size);
1608                         if (ret) {
1609                                 fprintf(fd, "[error] %s: unexpected unary expression for trace word_size\n", __func__);
1610                                 return -EINVAL;
1611                         }
1612                         CTF_TRACE_SET_FIELD(trace, word_size);
1613                 } else if (!strcmp(left, "uuid")) {
1614                         if (CTF_TRACE_FIELD_IS_SET(trace, uuid))
1615                                 return -EPERM;
1616                         ret = get_unary_uuid(&node->u.ctf_expression.right, &trace->uuid);
1617                         if (ret) {
1618                                 fprintf(fd, "[error] %s: unexpected unary expression for trace uuid\n", __func__);
1619                                 return -EINVAL;
1620                         }
1621                         CTF_TRACE_SET_FIELD(trace, uuid);
1622                 }
1623                 g_free(left);
1624                 break;
1625         }
1626         default:
1627                 return -EPERM;
1628         /* TODO: declaration specifier should be added. */
1629         }
1630
1631         return 0;
1632 }
1633
1634 static
1635 int ctf_trace_visit(FILE *fd, int depth, struct ctf_node *node, struct ctf_trace *trace)
1636 {
1637         int ret = 0;
1638         struct ctf_node *iter;
1639
1640         if (trace->declaration_scope)
1641                 return -EEXIST;
1642         trace->declaration_scope = new_declaration_scope(trace->root_declaration_scope);
1643         trace->streams = g_ptr_array_new();
1644         cds_list_for_each_entry(iter, &node->u.trace.declaration_list, siblings) {
1645                 ret = ctf_trace_declaration_visit(fd, depth + 1, iter, trace);
1646                 if (ret)
1647                         goto error;
1648         }
1649         if (!CTF_TRACE_FIELD_IS_SET(trace, major)) {
1650                 ret = -EPERM;
1651                 goto error;
1652         }
1653         if (!CTF_TRACE_FIELD_IS_SET(trace, minor)) {
1654                 ret = -EPERM;
1655                 goto error;
1656         }
1657         if (!CTF_TRACE_FIELD_IS_SET(trace, uuid)) {
1658                 ret = -EPERM;
1659                 goto error;
1660         }
1661         if (!CTF_TRACE_FIELD_IS_SET(trace, word_size)) {
1662                 ret = -EPERM;
1663                 goto error;
1664         }
1665         return 0;
1666
1667 error:
1668         g_ptr_array_free(trace->streams, TRUE);
1669         free_declaration_scope(trace->declaration_scope);
1670         return ret;
1671 }
1672
1673 static
1674 int ctf_root_declaration_visit(FILE *fd, int depth, struct ctf_node *node, struct ctf_trace *trace)
1675 {
1676         int ret = 0;
1677
1678         switch (node->type) {
1679         case NODE_TYPEDEF:
1680                 ret = ctf_typedef_visit(fd, depth + 1,
1681                                         trace->root_declaration_scope,
1682                                         node->u._typedef.type_specifier_list,
1683                                         &node->u._typedef.type_declarators,
1684                                         trace);
1685                 if (ret)
1686                         return ret;
1687                 break;
1688         case NODE_TYPEALIAS:
1689                 ret = ctf_typealias_visit(fd, depth + 1,
1690                                 trace->root_declaration_scope,
1691                                 node->u.typealias.target, node->u.typealias.alias,
1692                                 trace);
1693                 if (ret)
1694                         return ret;
1695                 break;
1696         case NODE_TYPE_SPECIFIER_LIST:
1697         {
1698                 struct declaration *declaration;
1699
1700                 /*
1701                  * Just add the type specifier to the root scope
1702                  * declaration scope. Release local reference.
1703                  */
1704                 declaration = ctf_type_specifier_list_visit(fd, depth + 1,
1705                         node, trace->root_declaration_scope, trace);
1706                 if (!declaration)
1707                         return -ENOMEM;
1708                 declaration_unref(declaration);
1709                 break;
1710         }
1711         default:
1712                 return -EPERM;
1713         }
1714
1715         return 0;
1716 }
1717
1718 int ctf_visitor_construct_metadata(FILE *fd, int depth, struct ctf_node *node,
1719                 struct ctf_trace *trace, int byte_order)
1720 {
1721         int ret = 0;
1722         struct ctf_node *iter;
1723
1724         fprintf(fd, "CTF visitor: metadata construction... ");
1725         trace->root_declaration_scope = new_declaration_scope(NULL);
1726         trace->byte_order = byte_order;
1727
1728         switch (node->type) {
1729         case NODE_ROOT:
1730                 cds_list_for_each_entry(iter, &node->u.root.declaration_list,
1731                                         siblings) {
1732                         ret = ctf_root_declaration_visit(fd, depth + 1, iter, trace);
1733                         if (ret)
1734                                 return ret;
1735                 }
1736                 cds_list_for_each_entry(iter, &node->u.root.trace, siblings) {
1737                         ret = ctf_trace_visit(fd, depth + 1, iter, trace);
1738                         if (ret)
1739                                 return ret;
1740                 }
1741                 cds_list_for_each_entry(iter, &node->u.root.stream, siblings) {
1742                         ret = ctf_stream_visit(fd, depth + 1, iter,
1743                                                trace->root_declaration_scope, trace);
1744                         if (ret)
1745                                 return ret;
1746                 }
1747                 cds_list_for_each_entry(iter, &node->u.root.event, siblings) {
1748                         ret = ctf_event_visit(fd, depth + 1, iter,
1749                                               trace->root_declaration_scope, trace);
1750                         if (ret)
1751                                 return ret;
1752                 }
1753                 break;
1754         case NODE_UNKNOWN:
1755         default:
1756                 fprintf(fd, "[error] %s: unknown node type %d\n", __func__,
1757                         (int) node->type);
1758                 return -EINVAL;
1759         }
1760         fprintf(fd, "done.\n");
1761         return ret;
1762 }