projects / babeltrace.git / blob
? search:


970b838cf43ac352a765295a972822d0d3b3f2ce
[babeltrace.git] / src / plugins / ctf / common / metadata / visitor-generate-ir.cpp
1 /*
2 * SPDX-License-Identifier: MIT
3 *
4 * Copyright 2010 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
5 * Copyright 2015-2018 Philippe Proulx <philippe.proulx@efficios.com>
6 *
7 * Common Trace Format metadata visitor (generates CTF IR objects).
8 */
9
10 #define BT_COMP_LOG_SELF_COMP (ctx->log_cfg.self_comp)
11 #define BT_COMP_LOG_SELF_COMP_CLASS (ctx->log_cfg.self_comp_class)
12 #define BT_LOG_OUTPUT_LEVEL (ctx->log_cfg.log_level)
13 #define BT_LOG_TAG "PLUGIN/CTF/META/IR-VISITOR"
14 #include "logging/comp-logging.h"
15
16 #include <stdio.h>
17 #include <unistd.h>
18 #include <string.h>
19 #include <stdbool.h>
20 #include <stdlib.h>
21 #include <ctype.h>
22 #include "common/assert.h"
23 #include <glib.h>
24 #include <inttypes.h>
25 #include <errno.h>
26 #include "common/common.h"
27 #include "common/uuid.h"
28 #include "compat/endian.h"
29 #include <babeltrace2/babeltrace.h>
30
31 #include "logging.hpp"
32 #include "scanner.hpp"
33 #include "ast.hpp"
34 #include "decoder.hpp"
35 #include "ctf-meta.hpp"
36 #include "ctf-meta-visitors.hpp"
37
38 /* Bit value (left shift) */
39 #define _BV(_val) (1 << (_val))
40
41 /* Bit is set in a set of bits */
42 #define _IS_SET(_set, _mask) (*(_set) & (_mask))
43
44 /* Set bit in a set of bits */
45 #define _SET(_set, _mask) (*(_set) |= (_mask))
46
47 /* Try to push scope, or go to the `error` label */
48 #define _TRY_PUSH_SCOPE_OR_GOTO_ERROR() \
49 do { \
50 ret = ctx_push_scope(ctx); \
51 if (ret) { \
52 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot push scope."); \
53 goto error; \
54 } \
55 } while (0)
56
57 /* Bits for verifying existing attributes in various declarations */
58 enum {
59 _CLOCK_NAME_SET = _BV(0),
60 _CLOCK_UUID_SET = _BV(1),
61 _CLOCK_FREQ_SET = _BV(2),
62 _CLOCK_PRECISION_SET = _BV(3),
63 _CLOCK_OFFSET_S_SET = _BV(4),
64 _CLOCK_OFFSET_SET = _BV(5),
65 _CLOCK_ABSOLUTE_SET = _BV(6),
66 _CLOCK_DESCRIPTION_SET = _BV(7),
67 };
68
69 enum {
70 _INTEGER_ALIGN_SET = _BV(0),
71 _INTEGER_SIZE_SET = _BV(1),
72 _INTEGER_BASE_SET = _BV(2),
73 _INTEGER_ENCODING_SET = _BV(3),
74 _INTEGER_BYTE_ORDER_SET = _BV(4),
75 _INTEGER_SIGNED_SET = _BV(5),
76 _INTEGER_MAP_SET = _BV(6),
77 };
78
79 enum {
80 _FLOAT_ALIGN_SET = _BV(0),
81 _FLOAT_MANT_DIG_SET = _BV(1),
82 _FLOAT_EXP_DIG_SET = _BV(2),
83 _FLOAT_BYTE_ORDER_SET = _BV(3),
84 };
85
86 enum {
87 _STRING_ENCODING_SET = _BV(0),
88 };
89
90 enum {
91 _TRACE_MINOR_SET = _BV(0),
92 _TRACE_MAJOR_SET = _BV(1),
93 _TRACE_BYTE_ORDER_SET = _BV(2),
94 _TRACE_UUID_SET = _BV(3),
95 _TRACE_PACKET_HEADER_SET = _BV(4),
96 };
97
98 enum {
99 _STREAM_ID_SET = _BV(0),
100 _STREAM_PACKET_CONTEXT_SET = _BV(1),
101 _STREAM_EVENT_HEADER_SET = _BV(2),
102 _STREAM_EVENT_CONTEXT_SET = _BV(3),
103 };
104
105 enum {
106 _EVENT_NAME_SET = _BV(0),
107 _EVENT_ID_SET = _BV(1),
108 _EVENT_MODEL_EMF_URI_SET = _BV(2),
109 _EVENT_STREAM_ID_SET = _BV(3),
110 _EVENT_LOG_LEVEL_SET = _BV(4),
111 _EVENT_CONTEXT_SET = _BV(5),
112 _EVENT_FIELDS_SET = _BV(6),
113 };
114
115 enum loglevel {
116 LOG_LEVEL_EMERG = 0,
117 LOG_LEVEL_ALERT = 1,
118 LOG_LEVEL_CRIT = 2,
119 LOG_LEVEL_ERR = 3,
120 LOG_LEVEL_WARNING = 4,
121 LOG_LEVEL_NOTICE = 5,
122 LOG_LEVEL_INFO = 6,
123 LOG_LEVEL_DEBUG_SYSTEM = 7,
124 LOG_LEVEL_DEBUG_PROGRAM = 8,
125 LOG_LEVEL_DEBUG_PROCESS = 9,
126 LOG_LEVEL_DEBUG_MODULE = 10,
127 LOG_LEVEL_DEBUG_UNIT = 11,
128 LOG_LEVEL_DEBUG_FUNCTION = 12,
129 LOG_LEVEL_DEBUG_LINE = 13,
130 LOG_LEVEL_DEBUG = 14,
131 _NR_LOGLEVELS = 15,
132 };
133
134 /* Prefixes of class aliases */
135 #define _PREFIX_ALIAS 'a'
136 #define _PREFIX_ENUM 'e'
137 #define _PREFIX_STRUCT 's'
138 #define _PREFIX_VARIANT 'v'
139
140 /* First entry in a BT list */
141 #define _BT_LIST_FIRST_ENTRY(_ptr, _class, _member) \
142 bt_list_entry((_ptr)->next, _class, _member)
143
144 #define _BT_COMP_LOGE_APPEND_CAUSE_DUP_ATTR(_node, _attr, _entity) \
145 _BT_COMP_LOGE_APPEND_CAUSE_LINENO((_node)->lineno, \
146 "Duplicate attribute in %s: attr-name=\"%s\"", \
147 _entity, _attr)
148
149 #define _BT_COMP_LOGE_NODE(_node, _msg, args...) \
150 _BT_COMP_LOGE_LINENO((_node)->lineno, _msg, ## args)
151
152 #define _BT_COMP_LOGE_APPEND_CAUSE_NODE(_node, _msg, args...) \
153 _BT_COMP_LOGE_APPEND_CAUSE_LINENO((_node)->lineno, _msg, ## args)
154
155 #define _BT_COMP_LOGW_NODE(_node, _msg, args...) \
156 _BT_COMP_LOGW_LINENO((_node)->lineno, _msg, ## args)
157
158 #define _BT_COMP_LOGT_NODE(_node, _msg, args...) \
159 _BT_COMP_LOGT_LINENO((_node)->lineno, _msg, ## args)
160
161 /*
162 * Declaration scope of a visitor context. This represents a TSDL
163 * lexical scope, so that aliases and named structures, variants,
164 * and enumerations may be registered and looked up hierarchically.
165 */
166 struct ctx_decl_scope {
167 /*
168 * Alias name to field class.
169 *
170 * GQuark -> struct ctf_field_class * (owned by this)
171 */
172 GHashTable *decl_map;
173
174 /* Parent scope; NULL if this is the root declaration scope */
175 struct ctx_decl_scope *parent_scope;
176 };
177
178 /*
179 * Visitor context (private).
180 */
181 struct ctf_visitor_generate_ir {
182 struct meta_log_config log_cfg;
183
184 /* Trace IR trace class being filled (owned by this) */
185 bt_trace_class *trace_class;
186
187 /* CTF meta trace being filled (owned by this) */
188 struct ctf_trace_class *ctf_tc;
189
190 /* Current declaration scope (top of the stack) (owned by this) */
191 struct ctx_decl_scope *current_scope;
192
193 /* True if trace declaration is visited */
194 bool is_trace_visited;
195
196 /* True if this is an LTTng trace */
197 bool is_lttng;
198
199 /* Config passed by the user */
200 struct ctf_metadata_decoder_config decoder_config;
201 };
202
203 /*
204 * Visitor (public).
205 */
206 struct ctf_visitor_generate_ir;
207
208 /**
209 * Creates a new declaration scope.
210 *
211 * @param par_scope Parent scope (NULL if creating a root scope)
212 * @returns New declaration scope, or NULL on error
213 */
214 static
215 struct ctx_decl_scope *ctx_decl_scope_create(struct ctf_visitor_generate_ir *ctx,
216 struct ctx_decl_scope *par_scope)
217 {
218 struct ctx_decl_scope *scope;
219
220 scope = g_new(struct ctx_decl_scope, 1);
221 if (!scope) {
222 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Failed to allocate one declaration scope.");
223 goto end;
224 }
225
226 scope->decl_map = g_hash_table_new_full(g_direct_hash, g_direct_equal,
227 NULL, (GDestroyNotify) ctf_field_class_destroy);
228 scope->parent_scope = par_scope;
229
230 end:
231 return scope;
232 }
233
234 /**
235 * Destroys a declaration scope.
236 *
237 * This function does not destroy the parent scope.
238 *
239 * @param scope Scope to destroy
240 */
241 static
242 void ctx_decl_scope_destroy(struct ctx_decl_scope *scope)
243 {
244 if (!scope) {
245 goto end;
246 }
247
248 g_hash_table_destroy(scope->decl_map);
249 g_free(scope);
250
251 end:
252 return;
253 }
254
255 /**
256 * Returns the GQuark of a prefixed alias.
257 *
258 * @param prefix Prefix character
259 * @param name Name
260 * @returns Associated GQuark, or 0 on error
261 */
262 static
263 GQuark get_prefixed_named_quark(struct ctf_visitor_generate_ir *ctx, char prefix,
264 const char *name)
265 {
266 GQuark qname = 0;
267
268 BT_ASSERT(name);
269
270 /* Prefix character + original string + '\0' */
271 char *prname = g_new(char, strlen(name) + 2);
272 if (!prname) {
273 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Failed to allocate a string.");
274 goto end;
275 }
276
277 sprintf(prname, "%c%s", prefix, name);
278 qname = g_quark_from_string(prname);
279 g_free(prname);
280
281 end:
282 return qname;
283 }
284
285 /**
286 * Looks up a prefixed class alias within a declaration scope.
287 *
288 * @param scope Declaration scope
289 * @param prefix Prefix character
290 * @param name Alias name
291 * @param levels Number of levels to dig into (-1 means infinite)
292 * @param copy True to return a copy
293 * @returns Declaration (owned by caller if \p copy is true),
294 * or NULL if not found
295 */
296 static
297 struct ctf_field_class *ctx_decl_scope_lookup_prefix_alias(
298 struct ctf_visitor_generate_ir *ctx, struct ctx_decl_scope *scope, char prefix,
299 const char *name, int levels, bool copy)
300 {
301 GQuark qname = 0;
302 int cur_levels = 0;
303 struct ctf_field_class *decl = NULL;
304 struct ctx_decl_scope *cur_scope = scope;
305
306 BT_ASSERT(scope);
307 BT_ASSERT(name);
308 qname = get_prefixed_named_quark(ctx, prefix, name);
309 if (!qname) {
310 goto end;
311 }
312
313 if (levels < 0) {
314 levels = INT_MAX;
315 }
316
317 while (cur_scope && cur_levels < levels) {
318 decl = (ctf_field_class *) g_hash_table_lookup(cur_scope->decl_map,
319 (gconstpointer) GUINT_TO_POINTER(qname));
320 if (decl) {
321 /* Caller's reference */
322 if (copy) {
323 decl = ctf_field_class_copy(decl);
324 BT_ASSERT(decl);
325 }
326
327 goto end;
328 }
329
330 cur_scope = cur_scope->parent_scope;
331 cur_levels++;
332 }
333
334 end:
335 return decl;
336 }
337
338 /**
339 * Looks up a class alias within a declaration scope.
340 *
341 * @param scope Declaration scope
342 * @param name Alias name
343 * @param levels Number of levels to dig into (-1 means infinite)
344 * @param copy True to return a copy
345 * @returns Declaration (owned by caller if \p copy is true),
346 * or NULL if not found
347 */
348 static
349 struct ctf_field_class *ctx_decl_scope_lookup_alias(struct ctf_visitor_generate_ir *ctx,
350 struct ctx_decl_scope *scope, const char *name, int levels,
351 bool copy)
352 {
353 return ctx_decl_scope_lookup_prefix_alias(ctx, scope, _PREFIX_ALIAS,
354 name, levels, copy);
355 }
356
357 /**
358 * Looks up an enumeration within a declaration scope.
359 *
360 * @param scope Declaration scope
361 * @param name Enumeration name
362 * @param levels Number of levels to dig into (-1 means infinite)
363 * @param copy True to return a copy
364 * @returns Declaration (owned by caller if \p copy is true),
365 * or NULL if not found
366 */
367 static
368 struct ctf_field_class_enum *ctx_decl_scope_lookup_enum(struct ctf_visitor_generate_ir *ctx,
369 struct ctx_decl_scope *scope, const char *name, int levels,
370 bool copy)
371 {
372 return ctf_field_class_as_enum(ctx_decl_scope_lookup_prefix_alias(ctx, scope,
373 _PREFIX_ENUM, name, levels, copy));
374 }
375
376 /**
377 * Looks up a structure within a declaration scope.
378 *
379 * @param scope Declaration scope
380 * @param name Structure name
381 * @param levels Number of levels to dig into (-1 means infinite)
382 * @param copy True to return a copy
383 * @returns Declaration (owned by caller if \p copy is true),
384 * or NULL if not found
385 */
386 static
387 struct ctf_field_class_struct *ctx_decl_scope_lookup_struct(struct ctf_visitor_generate_ir *ctx,
388 struct ctx_decl_scope *scope, const char *name, int levels,
389 bool copy)
390 {
391 return ctf_field_class_as_struct(ctx_decl_scope_lookup_prefix_alias(ctx, scope,
392 _PREFIX_STRUCT, name, levels, copy));
393 }
394
395 /**
396 * Looks up a variant within a declaration scope.
397 *
398 * @param scope Declaration scope
399 * @param name Variant name
400 * @param levels Number of levels to dig into (-1 means infinite)
401 * @param copy True to return a copy
402 * @returns Declaration (owned by caller if \p copy is true),
403 * or NULL if not found
404 */
405 static
406 struct ctf_field_class_variant *ctx_decl_scope_lookup_variant(struct ctf_visitor_generate_ir *ctx,
407 struct ctx_decl_scope *scope, const char *name, int levels,
408 bool copy)
409 {
410 return ctf_field_class_as_variant(ctx_decl_scope_lookup_prefix_alias(ctx, scope,
411 _PREFIX_VARIANT, name, levels, copy));
412 }
413
414 /**
415 * Registers a prefixed class alias within a declaration scope.
416 *
417 * @param scope Declaration scope
418 * @param prefix Prefix character
419 * @param name Alias name (non-NULL)
420 * @param decl Field class to register (copied)
421 * @returns 0 if registration went okay, negative value otherwise
422 */
423 static
424 int ctx_decl_scope_register_prefix_alias(struct ctf_visitor_generate_ir *ctx,
425 struct ctx_decl_scope *scope, char prefix, const char *name,
426 struct ctf_field_class *decl)
427 {
428 int ret = 0;
429 GQuark qname = 0;
430
431 BT_ASSERT(scope);
432 BT_ASSERT(name);
433 BT_ASSERT(decl);
434 qname = get_prefixed_named_quark(ctx, prefix, name);
435 if (!qname) {
436 ret = -ENOMEM;
437 goto end;
438 }
439
440 /* Make sure alias does not exist in local scope */
441 if (ctx_decl_scope_lookup_prefix_alias(ctx, scope, prefix, name, 1,
442 false)) {
443 ret = -EEXIST;
444 goto end;
445 }
446
447 decl = ctf_field_class_copy(decl);
448 BT_ASSERT(decl);
449 g_hash_table_insert(scope->decl_map, GUINT_TO_POINTER(qname), decl);
450
451 end:
452 return ret;
453 }
454
455 /**
456 * Registers a class alias within a declaration scope.
457 *
458 * @param scope Declaration scope
459 * @param name Alias name (non-NULL)
460 * @param decl Field class to register (copied)
461 * @returns 0 if registration went okay, negative value otherwise
462 */
463 static
464 int ctx_decl_scope_register_alias(struct ctf_visitor_generate_ir *ctx,
465 struct ctx_decl_scope *scope, const char *name, struct ctf_field_class *decl)
466 {
467 return ctx_decl_scope_register_prefix_alias(ctx, scope, _PREFIX_ALIAS,
468 name, decl);
469 }
470
471 /**
472 * Registers an enumeration declaration within a declaration scope.
473 *
474 * @param scope Declaration scope
475 * @param name Enumeration name (non-NULL)
476 * @param decl Enumeration field class to register (copied)
477 * @returns 0 if registration went okay, negative value otherwise
478 */
479 static
480 int ctx_decl_scope_register_enum(struct ctf_visitor_generate_ir *ctx,
481 struct ctx_decl_scope *scope, const char *name,
482 struct ctf_field_class_enum *decl)
483 {
484 return ctx_decl_scope_register_prefix_alias(ctx, scope, _PREFIX_ENUM,
485 name, &decl->base.base.base);
486 }
487
488 /**
489 * Registers a structure declaration within a declaration scope.
490 *
491 * @param scope Declaration scope
492 * @param name Structure name (non-NULL)
493 * @param decl Structure field class to register (copied)
494 * @returns 0 if registration went okay, negative value otherwise
495 */
496 static
497 int ctx_decl_scope_register_struct(struct ctf_visitor_generate_ir *ctx,
498 struct ctx_decl_scope *scope, const char *name,
499 struct ctf_field_class_struct *decl)
500 {
501 return ctx_decl_scope_register_prefix_alias(ctx, scope, _PREFIX_STRUCT,
502 name, &decl->base);
503 }
504
505 /**
506 * Registers a variant declaration within a declaration scope.
507 *
508 * @param scope Declaration scope
509 * @param name Variant name (non-NULL)
510 * @param decl Variant field class to register
511 * @returns 0 if registration went okay, negative value otherwise
512 */
513 static
514 int ctx_decl_scope_register_variant(struct ctf_visitor_generate_ir *ctx,
515 struct ctx_decl_scope *scope, const char *name,
516 struct ctf_field_class_variant *decl)
517 {
518 return ctx_decl_scope_register_prefix_alias(ctx, scope, _PREFIX_VARIANT,
519 name, &decl->base);
520 }
521
522 /**
523 * Destroys a visitor context.
524 *
525 * @param ctx Visitor context to destroy
526 */
527 static
528 void ctx_destroy(struct ctf_visitor_generate_ir *ctx)
529 {
530 struct ctx_decl_scope *scope;
531
532 if (!ctx) {
533 goto end;
534 }
535
536 scope = ctx->current_scope;
537
538 /*
539 * Destroy all scopes, from current one to the root scope.
540 */
541 while (scope) {
542 struct ctx_decl_scope *parent_scope = scope->parent_scope;
543
544 ctx_decl_scope_destroy(scope);
545 scope = parent_scope;
546 }
547
548 bt_trace_class_put_ref(ctx->trace_class);
549
550 if (ctx->ctf_tc) {
551 ctf_trace_class_destroy(ctx->ctf_tc);
552 }
553
554 g_free(ctx);
555
556 end:
557 return;
558 }
559
560 /**
561 * Creates a new visitor context.
562 *
563 * @param trace Associated trace
564 * @returns New visitor context, or NULL on error
565 */
566 static
567 struct ctf_visitor_generate_ir *ctx_create(
568 const struct ctf_metadata_decoder_config *decoder_config)
569 {
570 struct ctf_visitor_generate_ir *ctx = NULL;
571
572 BT_ASSERT(decoder_config);
573
574 ctx = g_new0(struct ctf_visitor_generate_ir, 1);
575 if (!ctx) {
576 BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, decoder_config->log_level,
577 decoder_config->self_comp,
578 "Failed to allocate one visitor context.");
579 goto error;
580 }
581
582 ctx->log_cfg.log_level = decoder_config->log_level;
583 ctx->log_cfg.self_comp = decoder_config->self_comp;
584 ctx->log_cfg.self_comp_class = decoder_config->self_comp_class;
585
586 if (decoder_config->self_comp) {
587 ctx->trace_class = bt_trace_class_create(
588 decoder_config->self_comp);
589 if (!ctx->trace_class) {
590 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot create empty trace class.");
591 goto error;
592 }
593 }
594
595 ctx->ctf_tc = ctf_trace_class_create();
596 if (!ctx->ctf_tc) {
597 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot create CTF trace class.");
598 goto error;
599 }
600
601 /* Root declaration scope */
602 ctx->current_scope = ctx_decl_scope_create(ctx, NULL);
603 if (!ctx->current_scope) {
604 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot create declaration scope.");
605 goto error;
606 }
607
608 ctx->decoder_config = *decoder_config;
609 goto end;
610
611 error:
612 ctx_destroy(ctx);
613 ctx = NULL;
614
615 end:
616 return ctx;
617 }
618
619 /**
620 * Pushes a new declaration scope on top of a visitor context's
621 * declaration scope stack.
622 *
623 * @param ctx Visitor context
624 * @returns 0 on success, or a negative value on error
625 */
626 static
627 int ctx_push_scope(struct ctf_visitor_generate_ir *ctx)
628 {
629 int ret = 0;
630 struct ctx_decl_scope *new_scope;
631
632 BT_ASSERT(ctx);
633 new_scope = ctx_decl_scope_create(ctx, ctx->current_scope);
634 if (!new_scope) {
635 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot create declaration scope.");
636 ret = -ENOMEM;
637 goto end;
638 }
639
640 ctx->current_scope = new_scope;
641
642 end:
643 return ret;
644 }
645
646 static
647 void ctx_pop_scope(struct ctf_visitor_generate_ir *ctx)
648 {
649 struct ctx_decl_scope *parent_scope = NULL;
650
651 BT_ASSERT(ctx);
652
653 if (!ctx->current_scope) {
654 goto end;
655 }
656
657 parent_scope = ctx->current_scope->parent_scope;
658 ctx_decl_scope_destroy(ctx->current_scope);
659 ctx->current_scope = parent_scope;
660
661 end:
662 return;
663 }
664
665 static
666 int visit_field_class_specifier_list(struct ctf_visitor_generate_ir *ctx,
667 struct ctf_node *ts_list, struct ctf_field_class **decl);
668
669 static
670 int is_unary_string(struct bt_list_head *head)
671 {
672 int ret = TRUE;
673 struct ctf_node *node;
674
675 bt_list_for_each_entry(node, head, siblings) {
676 if (node->type != NODE_UNARY_EXPRESSION) {
677 ret = FALSE;
678 }
679
680 if (node->u.unary_expression.type != UNARY_STRING) {
681 ret = FALSE;
682 }
683 }
684
685 return ret;
686 }
687
688 static
689 const char *get_map_clock_name_value(struct bt_list_head *head)
690 {
691 int i = 0;
692 struct ctf_node *node;
693 const char *name = NULL;
694
695 bt_list_for_each_entry(node, head, siblings) {
696 char *src_string;
697 int uexpr_type = node->u.unary_expression.type;
698 int uexpr_link = node->u.unary_expression.link;
699 int cond = node->type != NODE_UNARY_EXPRESSION ||
700 uexpr_type != UNARY_STRING ||
701 !((uexpr_link != UNARY_LINK_UNKNOWN) ^ (i == 0));
702 if (cond) {
703 goto error;
704 }
705
706 /* Needs to be chained with . */
707 switch (node->u.unary_expression.link) {
708 case UNARY_DOTLINK:
709 break;
710 case UNARY_ARROWLINK:
711 case UNARY_DOTDOTDOT:
712 goto error;
713 default:
714 break;
715 }
716
717 src_string = node->u.unary_expression.u.string;
718
719 switch (i) {
720 case 0:
721 if (strcmp("clock", src_string)) {
722 goto error;
723 }
724 break;
725 case 1:
726 name = src_string;
727 break;
728 case 2:
729 if (strcmp("value", src_string)) {
730 goto error;
731 }
732 break;
733 default:
734 /* Extra identifier, unknown */
735 goto error;
736 }
737
738 i++;
739 }
740
741 return name;
742
743 error:
744 return NULL;
745 }
746
747 static
748 int is_unary_unsigned(struct bt_list_head *head)
749 {
750 int ret = TRUE;
751 struct ctf_node *node;
752
753 bt_list_for_each_entry(node, head, siblings) {
754 if (node->type != NODE_UNARY_EXPRESSION) {
755 ret = FALSE;
756 }
757
758 if (node->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT) {
759 ret = FALSE;
760 }
761 }
762
763 return ret;
764 }
765
766 static
767 int get_unary_unsigned(struct ctf_visitor_generate_ir *ctx, struct bt_list_head *head,
768 uint64_t *value)
769 {
770 int i = 0;
771 int ret = 0;
772 struct ctf_node *node;
773
774 *value = 0;
775
776 if (bt_list_empty(head)) {
777 ret = -1;
778 goto end;
779 }
780
781 bt_list_for_each_entry(node, head, siblings) {
782 int uexpr_type = node->u.unary_expression.type;
783 int uexpr_link = node->u.unary_expression.link;
784 int cond = node->type != NODE_UNARY_EXPRESSION ||
785 uexpr_type != UNARY_UNSIGNED_CONSTANT ||
786 uexpr_link != UNARY_LINK_UNKNOWN || i != 0;
787 if (cond) {
788 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node, "Invalid constant unsigned integer.");
789 ret = -EINVAL;
790 goto end;
791 }
792
793 *value = node->u.unary_expression.u.unsigned_constant;
794 i++;
795 }
796
797 end:
798 return ret;
799 }
800
801 static
802 int is_unary_signed(struct bt_list_head *head)
803 {
804 int ret = TRUE;
805 struct ctf_node *node;
806
807 bt_list_for_each_entry(node, head, siblings) {
808 if (node->type != NODE_UNARY_EXPRESSION) {
809 ret = FALSE;
810 }
811
812 if (node->u.unary_expression.type != UNARY_SIGNED_CONSTANT) {
813 ret = FALSE;
814 }
815 }
816
817 return ret;
818 }
819
820 static
821 int get_unary_signed(struct bt_list_head *head, int64_t *value)
822 {
823 int i = 0;
824 int ret = 0;
825 struct ctf_node *node;
826
827 bt_list_for_each_entry(node, head, siblings) {
828 int uexpr_type = node->u.unary_expression.type;
829 int uexpr_link = node->u.unary_expression.link;
830 int cond = node->type != NODE_UNARY_EXPRESSION ||
831 (uexpr_type != UNARY_UNSIGNED_CONSTANT &&
832 uexpr_type != UNARY_SIGNED_CONSTANT) ||
833 uexpr_link != UNARY_LINK_UNKNOWN || i != 0;
834 if (cond) {
835 ret = -EINVAL;
836 goto end;
837 }
838
839 switch (uexpr_type) {
840 case UNARY_UNSIGNED_CONSTANT:
841 *value = (int64_t)
842 node->u.unary_expression.u.unsigned_constant;
843 break;
844 case UNARY_SIGNED_CONSTANT:
845 *value = node->u.unary_expression.u.signed_constant;
846 break;
847 default:
848 ret = -EINVAL;
849 goto end;
850 }
851
852 i++;
853 }
854
855 end:
856 return ret;
857 }
858
859 static
860 int get_unary_uuid(struct ctf_visitor_generate_ir *ctx, struct bt_list_head *head,
861 bt_uuid_t uuid)
862 {
863 return ctf_ast_get_unary_uuid(head, uuid, ctx->log_cfg.log_level,
864 ctx->log_cfg.self_comp);
865 }
866
867 static
868 int get_boolean(struct ctf_visitor_generate_ir *ctx, struct ctf_node *unary_expr)
869 {
870 int ret = 0;
871
872 if (unary_expr->type != NODE_UNARY_EXPRESSION) {
873 _BT_COMP_LOGE_APPEND_CAUSE_NODE(unary_expr,
874 "Expecting unary expression: node-type=%d",
875 unary_expr->type);
876 ret = -EINVAL;
877 goto end;
878 }
879
880 switch (unary_expr->u.unary_expression.type) {
881 case UNARY_UNSIGNED_CONSTANT:
882 ret = (unary_expr->u.unary_expression.u.unsigned_constant != 0);
883 break;
884 case UNARY_SIGNED_CONSTANT:
885 ret = (unary_expr->u.unary_expression.u.signed_constant != 0);
886 break;
887 case UNARY_STRING:
888 {
889 const char *str = unary_expr->u.unary_expression.u.string;
890
891 if (strcmp(str, "true") == 0 || strcmp(str, "TRUE") == 0) {
892 ret = TRUE;
893 } else if (strcmp(str, "false") == 0 || strcmp(str, "FALSE") == 0) {
894 ret = FALSE;
895 } else {
896 _BT_COMP_LOGE_APPEND_CAUSE_NODE(unary_expr,
897 "Unexpected boolean value: value=\"%s\"", str);
898 ret = -EINVAL;
899 goto end;
900 }
901 break;
902 }
903 default:
904 _BT_COMP_LOGE_APPEND_CAUSE_NODE(unary_expr,
905 "Unexpected unary expression type: node-type=%d",
906 unary_expr->u.unary_expression.type);
907 ret = -EINVAL;
908 goto end;
909 }
910
911 end:
912 return ret;
913 }
914
915 static
916 enum ctf_byte_order byte_order_from_unary_expr(struct ctf_visitor_generate_ir *ctx,
917 struct ctf_node *unary_expr)
918 {
919 const char *str;
920 enum ctf_byte_order bo = CTF_BYTE_ORDER_UNKNOWN;
921
922 if (unary_expr->u.unary_expression.type != UNARY_STRING) {
923 _BT_COMP_LOGE_APPEND_CAUSE_NODE(unary_expr,
924 "\"byte_order\" attribute: expecting `be`, `le`, `network`, or `native`.");
925 goto end;
926 }
927
928 str = unary_expr->u.unary_expression.u.string;
929
930 if (strcmp(str, "be") == 0 || strcmp(str, "network") == 0) {
931 bo = CTF_BYTE_ORDER_BIG;
932 } else if (strcmp(str, "le") == 0) {
933 bo = CTF_BYTE_ORDER_LITTLE;
934 } else if (strcmp(str, "native") == 0) {
935 bo = CTF_BYTE_ORDER_DEFAULT;
936 } else {
937 _BT_COMP_LOGE_APPEND_CAUSE_NODE(unary_expr,
938 "Unexpected \"byte_order\" attribute value: "
939 "expecting `be`, `le`, `network`, or `native`: value=\"%s\"",
940 str);
941 goto end;
942 }
943
944 end:
945 return bo;
946 }
947
948 static
949 enum ctf_byte_order get_real_byte_order(struct ctf_visitor_generate_ir *ctx,
950 struct ctf_node *uexpr)
951 {
952 enum ctf_byte_order bo = byte_order_from_unary_expr(ctx, uexpr);
953
954 if (bo == CTF_BYTE_ORDER_DEFAULT) {
955 bo = ctx->ctf_tc->default_byte_order;
956 }
957
958 return bo;
959 }
960
961 static
962 int is_align_valid(uint64_t align)
963 {
964 return (align != 0) && !(align & (align - UINT64_C(1)));
965 }
966
967 static
968 int get_class_specifier_name(struct ctf_visitor_generate_ir *ctx,
969 struct ctf_node *cls_specifier, GString *str)
970 {
971 int ret = 0;
972
973 if (cls_specifier->type != NODE_TYPE_SPECIFIER) {
974 _BT_COMP_LOGE_APPEND_CAUSE_NODE(cls_specifier,
975 "Unexpected node type: node-type=%d",
976 cls_specifier->type);
977 ret = -EINVAL;
978 goto end;
979 }
980
981 switch (cls_specifier->u.field_class_specifier.type) {
982 case TYPESPEC_VOID:
983 g_string_append(str, "void");
984 break;
985 case TYPESPEC_CHAR:
986 g_string_append(str, "char");
987 break;
988 case TYPESPEC_SHORT:
989 g_string_append(str, "short");
990 break;
991 case TYPESPEC_INT:
992 g_string_append(str, "int");
993 break;
994 case TYPESPEC_LONG:
995 g_string_append(str, "long");
996 break;
997 case TYPESPEC_FLOAT:
998 g_string_append(str, "float");
999 break;
1000 case TYPESPEC_DOUBLE:
1001 g_string_append(str, "double");
1002 break;
1003 case TYPESPEC_SIGNED:
1004 g_string_append(str, "signed");
1005 break;
1006 case TYPESPEC_UNSIGNED:
1007 g_string_append(str, "unsigned");
1008 break;
1009 case TYPESPEC_BOOL:
1010 g_string_append(str, "bool");
1011 break;
1012 case TYPESPEC_COMPLEX:
1013 g_string_append(str, "_Complex");
1014 break;
1015 case TYPESPEC_IMAGINARY:
1016 g_string_append(str, "_Imaginary");
1017 break;
1018 case TYPESPEC_CONST:
1019 g_string_append(str, "const");
1020 break;
1021 case TYPESPEC_ID_TYPE:
1022 if (cls_specifier->u.field_class_specifier.id_type) {
1023 g_string_append(str,
1024 cls_specifier->u.field_class_specifier.id_type);
1025 }
1026 break;
1027 case TYPESPEC_STRUCT:
1028 {
1029 struct ctf_node *node = cls_specifier->u.field_class_specifier.node;
1030
1031 if (!node->u._struct.name) {
1032 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node, "Unexpected empty structure field class name.");
1033 ret = -EINVAL;
1034 goto end;
1035 }
1036
1037 g_string_append(str, "struct ");
1038 g_string_append(str, node->u._struct.name);
1039 break;
1040 }
1041 case TYPESPEC_VARIANT:
1042 {
1043 struct ctf_node *node = cls_specifier->u.field_class_specifier.node;
1044
1045 if (!node->u.variant.name) {
1046 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node, "Unexpected empty variant field class name.");
1047 ret = -EINVAL;
1048 goto end;
1049 }
1050
1051 g_string_append(str, "variant ");
1052 g_string_append(str, node->u.variant.name);
1053 break;
1054 }
1055 case TYPESPEC_ENUM:
1056 {
1057 struct ctf_node *node = cls_specifier->u.field_class_specifier.node;
1058
1059 if (!node->u._enum.enum_id) {
1060 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
1061 "Unexpected empty enumeration field class (`enum`) name.");
1062 ret = -EINVAL;
1063 goto end;
1064 }
1065
1066 g_string_append(str, "enum ");
1067 g_string_append(str, node->u._enum.enum_id);
1068 break;
1069 }
1070 case TYPESPEC_FLOATING_POINT:
1071 case TYPESPEC_INTEGER:
1072 case TYPESPEC_STRING:
1073 default:
1074 _BT_COMP_LOGE_APPEND_CAUSE_NODE(cls_specifier->u.field_class_specifier.node,
1075 "Unexpected field class specifier type: %d",
1076 cls_specifier->u.field_class_specifier.type);
1077 ret = -EINVAL;
1078 goto end;
1079 }
1080
1081 end:
1082 return ret;
1083 }
1084
1085 static
1086 int get_class_specifier_list_name(struct ctf_visitor_generate_ir *ctx,
1087 struct ctf_node *cls_specifier_list, GString *str)
1088 {
1089 int ret = 0;
1090 struct ctf_node *iter;
1091 int alias_item_nr = 0;
1092 struct bt_list_head *head =
1093 &cls_specifier_list->u.field_class_specifier_list.head;
1094
1095 bt_list_for_each_entry(iter, head, siblings) {
1096 if (alias_item_nr != 0) {
1097 g_string_append(str, " ");
1098 }
1099
1100 alias_item_nr++;
1101 ret = get_class_specifier_name(ctx, iter, str);
1102 if (ret) {
1103 goto end;
1104 }
1105 }
1106
1107 end:
1108 return ret;
1109 }
1110
1111 static
1112 GQuark create_class_alias_identifier(struct ctf_visitor_generate_ir *ctx,
1113 struct ctf_node *cls_specifier_list,
1114 struct ctf_node *node_field_class_declarator)
1115 {
1116 int ret;
1117 char *str_c;
1118 GString *str;
1119 GQuark qalias = 0;
1120 struct ctf_node *iter;
1121 struct bt_list_head *pointers =
1122 &node_field_class_declarator->u.field_class_declarator.pointers;
1123
1124 str = g_string_new("");
1125 ret = get_class_specifier_list_name(ctx, cls_specifier_list, str);
1126 if (ret) {
1127 g_string_free(str, TRUE);
1128 goto end;
1129 }
1130
1131 bt_list_for_each_entry(iter, pointers, siblings) {
1132 g_string_append(str, " *");
1133
1134 if (iter->u.pointer.const_qualifier) {
1135 g_string_append(str, " const");
1136 }
1137 }
1138
1139 str_c = g_string_free(str, FALSE);
1140 qalias = g_quark_from_string(str_c);
1141 g_free(str_c);
1142
1143 end:
1144 return qalias;
1145 }
1146
1147 static
1148 int visit_field_class_declarator(struct ctf_visitor_generate_ir *ctx,
1149 struct ctf_node *cls_specifier_list,
1150 GQuark *field_name, struct ctf_node *node_field_class_declarator,
1151 struct ctf_field_class **field_decl,
1152 struct ctf_field_class *nested_decl)
1153 {
1154 /*
1155 * During this whole function, nested_decl is always OURS,
1156 * whereas field_decl is an output which we create, but
1157 * belongs to the caller (it is moved).
1158 */
1159 int ret = 0;
1160 *field_decl = NULL;
1161
1162 /* Validate field class declarator node */
1163 if (node_field_class_declarator) {
1164 if (node_field_class_declarator->u.field_class_declarator.type ==
1165 TYPEDEC_UNKNOWN) {
1166 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node_field_class_declarator,
1167 "Unexpected field class declarator type: type=%d",
1168 node_field_class_declarator->u.field_class_declarator.type);
1169 ret = -EINVAL;
1170 goto error;
1171 }
1172
1173 /* TODO: GCC bitfields not supported yet */
1174 if (node_field_class_declarator->u.field_class_declarator.bitfield_len !=
1175 NULL) {
1176 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node_field_class_declarator,
1177 "GCC bitfields are not supported as of this version.");
1178 ret = -EPERM;
1179 goto error;
1180 }
1181 }
1182
1183 /* Find the right nested declaration if not provided */
1184 if (!nested_decl) {
1185 struct bt_list_head *pointers =
1186 &node_field_class_declarator->u.field_class_declarator.pointers;
1187
1188 if (node_field_class_declarator && !bt_list_empty(pointers)) {
1189 GQuark qalias;
1190
1191 /*
1192 * If we have a pointer declarator, it HAS to
1193 * be present in the field class aliases (else
1194 * fail).
1195 */
1196 qalias = create_class_alias_identifier(ctx,
1197 cls_specifier_list, node_field_class_declarator);
1198 nested_decl =
1199 ctx_decl_scope_lookup_alias(ctx,
1200 ctx->current_scope,
1201 g_quark_to_string(qalias), -1, true);
1202 if (!nested_decl) {
1203 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node_field_class_declarator,
1204 "Cannot find class alias: name=\"%s\"",
1205 g_quark_to_string(qalias));
1206 ret = -EINVAL;
1207 goto error;
1208 }
1209
1210 if (nested_decl->type == CTF_FIELD_CLASS_TYPE_INT) {
1211 /* Pointer: force integer's base to 16 */
1212 struct ctf_field_class_int *int_fc =
1213 ctf_field_class_as_int(nested_decl);
1214
1215 int_fc->disp_base =
1216 BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_HEXADECIMAL;
1217 }
1218 } else {
1219 ret = visit_field_class_specifier_list(ctx,
1220 cls_specifier_list, &nested_decl);
1221 if (ret) {
1222 BT_ASSERT(!nested_decl);
1223 goto error;
1224 }
1225 }
1226 }
1227
1228 BT_ASSERT(nested_decl);
1229
1230 if (!node_field_class_declarator) {
1231 *field_decl = nested_decl;
1232 nested_decl = NULL;
1233 goto end;
1234 }
1235
1236 if (node_field_class_declarator->u.field_class_declarator.type == TYPEDEC_ID) {
1237 if (node_field_class_declarator->u.field_class_declarator.u.id) {
1238 const char *id =
1239 node_field_class_declarator->u.field_class_declarator.u.id;
1240
1241 *field_name = g_quark_from_string(id);
1242 } else {
1243 *field_name = 0;
1244 }
1245
1246 *field_decl = nested_decl;
1247 nested_decl = NULL;
1248 goto end;
1249 } else {
1250 struct ctf_node *first;
1251 struct ctf_field_class *decl = NULL;
1252 struct ctf_field_class *outer_field_decl = NULL;
1253 struct bt_list_head *length =
1254 &node_field_class_declarator->
1255 u.field_class_declarator.u.nested.length;
1256
1257 /* Create array/sequence, pass nested_decl as child */
1258 if (bt_list_empty(length)) {
1259 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node_field_class_declarator,
1260 "Expecting length field reference or value.");
1261 ret = -EINVAL;
1262 goto error;
1263 }
1264
1265 first = _BT_LIST_FIRST_ENTRY(length, struct ctf_node, siblings);
1266 if (first->type != NODE_UNARY_EXPRESSION) {
1267 _BT_COMP_LOGE_APPEND_CAUSE_NODE(first,
1268 "Unexpected node type: node-type=%d",
1269 first->type);
1270 ret = -EINVAL;
1271 goto error;
1272 }
1273
1274 switch (first->u.unary_expression.type) {
1275 case UNARY_UNSIGNED_CONSTANT:
1276 {
1277 struct ctf_field_class_array *array_decl = NULL;
1278
1279 array_decl = ctf_field_class_array_create();
1280 BT_ASSERT(array_decl);
1281 array_decl->length =
1282 first->u.unary_expression.u.unsigned_constant;
1283 array_decl->base.elem_fc = nested_decl;
1284 nested_decl = NULL;
1285 decl = &array_decl->base.base;
1286 break;
1287 }
1288 case UNARY_STRING:
1289 {
1290 /* Lookup unsigned integer definition, create seq. */
1291 struct ctf_field_class_sequence *seq_decl = NULL;
1292 char *length_name = ctf_ast_concatenate_unary_strings(length);
1293
1294 if (!length_name) {
1295 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node_field_class_declarator,
1296 "Cannot concatenate unary strings.");
1297 ret = -EINVAL;
1298 goto error;
1299 }
1300
1301 if (strncmp(length_name, "env.", 4) == 0) {
1302 /* This is, in fact, an array */
1303 const char *env_entry_name = &length_name[4];
1304 struct ctf_trace_class_env_entry *env_entry =
1305 ctf_trace_class_borrow_env_entry_by_name(
1306 ctx->ctf_tc, env_entry_name);
1307 struct ctf_field_class_array *array_decl;
1308
1309 if (!env_entry) {
1310 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node_field_class_declarator,
1311 "Cannot find environment entry: "
1312 "name=\"%s\"", env_entry_name);
1313 ret = -EINVAL;
1314 goto error;
1315 }
1316
1317 if (env_entry->type != CTF_TRACE_CLASS_ENV_ENTRY_TYPE_INT) {
1318 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node_field_class_declarator,
1319 "Wrong environment entry type "
1320 "(expecting integer): "
1321 "name=\"%s\"", env_entry_name);
1322 ret = -EINVAL;
1323 goto error;
1324 }
1325
1326 if (env_entry->value.i < 0) {
1327 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node_field_class_declarator,
1328 "Invalid, negative array length: "
1329 "env-entry-name=\"%s\", "
1330 "value=%" PRId64,
1331 env_entry_name,
1332 env_entry->value.i);
1333 ret = -EINVAL;
1334 goto error;
1335 }
1336
1337 array_decl = ctf_field_class_array_create();
1338 BT_ASSERT(array_decl);
1339 array_decl->length =
1340 (uint64_t) env_entry->value.i;
1341 array_decl->base.elem_fc = nested_decl;
1342 nested_decl = NULL;
1343 decl = &array_decl->base.base;
1344 } else {
1345 seq_decl = ctf_field_class_sequence_create();
1346 BT_ASSERT(seq_decl);
1347 seq_decl->base.elem_fc = nested_decl;
1348 nested_decl = NULL;
1349 g_string_assign(seq_decl->length_ref,
1350 length_name);
1351 decl = &seq_decl->base.base;
1352 }
1353
1354 g_free(length_name);
1355 break;
1356 }
1357 default:
1358 ret = -EINVAL;
1359 goto error;
1360 }
1361
1362 BT_ASSERT(!nested_decl);
1363 BT_ASSERT(decl);
1364 BT_ASSERT(!*field_decl);
1365
1366 /*
1367 * At this point, we found the next nested declaration.
1368 * We currently own this (and lost the ownership of
1369 * nested_decl in the meantime). Pass this next
1370 * nested declaration as the content of the outer
1371 * container, MOVING its ownership.
1372 */
1373 ret = visit_field_class_declarator(ctx, cls_specifier_list,
1374 field_name,
1375 node_field_class_declarator->
1376 u.field_class_declarator.u.nested.field_class_declarator,
1377 &outer_field_decl, decl);
1378 decl = NULL;
1379 if (ret) {
1380 BT_ASSERT(!outer_field_decl);
1381 ret = -EINVAL;
1382 goto error;
1383 }
1384
1385 BT_ASSERT(outer_field_decl);
1386 *field_decl = outer_field_decl;
1387 outer_field_decl = NULL;
1388 }
1389
1390 BT_ASSERT(*field_decl);
1391 goto end;
1392
1393 error:
1394 ctf_field_class_destroy(*field_decl);
1395 *field_decl = NULL;
1396
1397 if (ret >= 0) {
1398 ret = -1;
1399 }
1400
1401 end:
1402 ctf_field_class_destroy(nested_decl);
1403 nested_decl = NULL;
1404 return ret;
1405 }
1406
1407 static
1408 int visit_struct_decl_field(struct ctf_visitor_generate_ir *ctx,
1409 struct ctf_field_class_struct *struct_decl,
1410 struct ctf_node *cls_specifier_list,
1411 struct bt_list_head *field_class_declarators)
1412 {
1413 int ret = 0;
1414 struct ctf_node *iter;
1415 struct ctf_field_class *field_decl = NULL;
1416
1417 bt_list_for_each_entry(iter, field_class_declarators, siblings) {
1418 field_decl = NULL;
1419 GQuark qfield_name;
1420 const char *field_name;
1421
1422 ret = visit_field_class_declarator(ctx, cls_specifier_list,
1423 &qfield_name, iter, &field_decl, NULL);
1424 if (ret) {
1425 BT_ASSERT(!field_decl);
1426 _BT_COMP_LOGE_APPEND_CAUSE_NODE(cls_specifier_list,
1427 "Cannot visit field class declarator: ret=%d", ret);
1428 goto error;
1429 }
1430
1431 BT_ASSERT(field_decl);
1432 field_name = g_quark_to_string(qfield_name);
1433
1434 /* Check if field with same name already exists */
1435 if (ctf_field_class_struct_borrow_member_by_name(
1436 struct_decl, field_name)) {
1437 _BT_COMP_LOGE_APPEND_CAUSE_NODE(cls_specifier_list,
1438 "Duplicate field in structure field class: "
1439 "field-name=\"%s\"", field_name);
1440 ret = -EINVAL;
1441 goto error;
1442 }
1443
1444 /* Add field to structure */
1445 ctf_field_class_struct_append_member(struct_decl,
1446 field_name, field_decl);
1447 field_decl = NULL;
1448 }
1449
1450 return 0;
1451
1452 error:
1453 ctf_field_class_destroy(field_decl);
1454 field_decl = NULL;
1455 return ret;
1456 }
1457
1458 static
1459 int visit_variant_decl_field(struct ctf_visitor_generate_ir *ctx,
1460 struct ctf_field_class_variant *variant_decl,
1461 struct ctf_node *cls_specifier_list,
1462 struct bt_list_head *field_class_declarators)
1463 {
1464 int ret = 0;
1465 struct ctf_node *iter;
1466 struct ctf_field_class *field_decl = NULL;
1467
1468 bt_list_for_each_entry(iter, field_class_declarators, siblings) {
1469 field_decl = NULL;
1470 GQuark qfield_name;
1471 const char *field_name;
1472
1473 ret = visit_field_class_declarator(ctx, cls_specifier_list,
1474 &qfield_name, iter, &field_decl, NULL);
1475 if (ret) {
1476 BT_ASSERT(!field_decl);
1477 _BT_COMP_LOGE_APPEND_CAUSE_NODE(cls_specifier_list,
1478 "Cannot visit field class declarator: ret=%d", ret);
1479 goto error;
1480 }
1481
1482 BT_ASSERT(field_decl);
1483 field_name = g_quark_to_string(qfield_name);
1484
1485 /* Check if field with same name already exists */
1486 if (ctf_field_class_variant_borrow_option_by_name(
1487 variant_decl, field_name)) {
1488 _BT_COMP_LOGE_APPEND_CAUSE_NODE(cls_specifier_list,
1489 "Duplicate field in variant field class: "
1490 "field-name=\"%s\"", field_name);
1491 ret = -EINVAL;
1492 goto error;
1493 }
1494
1495 /* Add field to structure */
1496 ctf_field_class_variant_append_option(variant_decl,
1497 field_name, field_decl);
1498 field_decl = NULL;
1499 }
1500
1501 return 0;
1502
1503 error:
1504 ctf_field_class_destroy(field_decl);
1505 field_decl = NULL;
1506 return ret;
1507 }
1508
1509 static
1510 int visit_field_class_def(struct ctf_visitor_generate_ir *ctx,
1511 struct ctf_node *cls_specifier_list,
1512 struct bt_list_head *field_class_declarators)
1513 {
1514 int ret = 0;
1515 GQuark qidentifier;
1516 struct ctf_node *iter;
1517 struct ctf_field_class *class_decl = NULL;
1518
1519 bt_list_for_each_entry(iter, field_class_declarators, siblings) {
1520 ret = visit_field_class_declarator(ctx, cls_specifier_list,
1521 &qidentifier, iter, &class_decl, NULL);
1522 if (ret) {
1523 _BT_COMP_LOGE_APPEND_CAUSE_NODE(iter,
1524 "Cannot visit field class declarator: ret=%d", ret);
1525 ret = -EINVAL;
1526 goto end;
1527 }
1528
1529 /* Do not allow field class def and alias of untagged variants */
1530 if (class_decl->type == CTF_FIELD_CLASS_TYPE_VARIANT) {
1531 struct ctf_field_class_variant *var_fc =
1532 ctf_field_class_as_variant(class_decl);
1533
1534 if (var_fc->tag_path.path->len == 0) {
1535 _BT_COMP_LOGE_APPEND_CAUSE_NODE(iter,
1536 "Type definition of untagged variant field class is not allowed.");
1537 ret = -EPERM;
1538 goto end;
1539 }
1540 }
1541
1542 ret = ctx_decl_scope_register_alias(ctx, ctx->current_scope,
1543 g_quark_to_string(qidentifier), class_decl);
1544 if (ret) {
1545 _BT_COMP_LOGE_APPEND_CAUSE_NODE(iter,
1546 "Cannot register field class alias: name=\"%s\"",
1547 g_quark_to_string(qidentifier));
1548 goto end;
1549 }
1550 }
1551
1552 end:
1553 ctf_field_class_destroy(class_decl);
1554 class_decl = NULL;
1555 return ret;
1556 }
1557
1558 static
1559 int visit_field_class_alias(struct ctf_visitor_generate_ir *ctx, struct ctf_node *target,
1560 struct ctf_node *alias)
1561 {
1562 int ret = 0;
1563 GQuark qalias;
1564 struct ctf_node *node;
1565 GQuark qdummy_field_name;
1566 struct ctf_field_class *class_decl = NULL;
1567
1568 /* Create target field class */
1569 if (bt_list_empty(&target->u.field_class_alias_target.field_class_declarators)) {
1570 node = NULL;
1571 } else {
1572 node = _BT_LIST_FIRST_ENTRY(
1573 &target->u.field_class_alias_target.field_class_declarators,
1574 struct ctf_node, siblings);
1575 }
1576
1577 ret = visit_field_class_declarator(ctx,
1578 target->u.field_class_alias_target.field_class_specifier_list,
1579 &qdummy_field_name, node, &class_decl, NULL);
1580 if (ret) {
1581 BT_ASSERT(!class_decl);
1582 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
1583 "Cannot visit field class declarator: ret=%d", ret);
1584 goto end;
1585 }
1586
1587 /* Do not allow field class def and alias of untagged variants */
1588 if (class_decl->type == CTF_FIELD_CLASS_TYPE_VARIANT) {
1589 struct ctf_field_class_variant *var_fc =
1590 ctf_field_class_as_variant(class_decl);
1591
1592 if (var_fc->tag_path.path->len == 0) {
1593 _BT_COMP_LOGE_APPEND_CAUSE_NODE(target,
1594 "Type definition of untagged variant field class is not allowed.");
1595 ret = -EPERM;
1596 goto end;
1597 }
1598 }
1599
1600 /*
1601 * The semantic validator does not check whether the target is
1602 * abstract or not (if it has an identifier). Check it here.
1603 */
1604 if (qdummy_field_name != 0) {
1605 _BT_COMP_LOGE_APPEND_CAUSE_NODE(target,
1606 "Expecting empty identifier: id=\"%s\"",
1607 g_quark_to_string(qdummy_field_name));
1608 ret = -EINVAL;
1609 goto end;
1610 }
1611
1612 /* Create alias identifier */
1613 node = _BT_LIST_FIRST_ENTRY(&alias->u.field_class_alias_name.field_class_declarators,
1614 struct ctf_node, siblings);
1615 qalias = create_class_alias_identifier(ctx,
1616 alias->u.field_class_alias_name.field_class_specifier_list, node);
1617 ret = ctx_decl_scope_register_alias(ctx, ctx->current_scope,
1618 g_quark_to_string(qalias), class_decl);
1619 if (ret) {
1620 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
1621 "Cannot register class alias: name=\"%s\"",
1622 g_quark_to_string(qalias));
1623 goto end;
1624 }
1625
1626 end:
1627 ctf_field_class_destroy(class_decl);
1628 class_decl = NULL;
1629 return ret;
1630 }
1631
1632 static
1633 int visit_struct_decl_entry(struct ctf_visitor_generate_ir *ctx, struct ctf_node *entry_node,
1634 struct ctf_field_class_struct *struct_decl)
1635 {
1636 int ret = 0;
1637
1638 switch (entry_node->type) {
1639 case NODE_TYPEDEF:
1640 ret = visit_field_class_def(ctx,
1641 entry_node->u.field_class_def.field_class_specifier_list,
1642 &entry_node->u.field_class_def.field_class_declarators);
1643 if (ret) {
1644 _BT_COMP_LOGE_APPEND_CAUSE_NODE(entry_node,
1645 "Cannot add field class found in structure field class: ret=%d",
1646 ret);
1647 goto end;
1648 }
1649 break;
1650 case NODE_TYPEALIAS:
1651 ret = visit_field_class_alias(ctx, entry_node->u.field_class_alias.target,
1652 entry_node->u.field_class_alias.alias);
1653 if (ret) {
1654 _BT_COMP_LOGE_APPEND_CAUSE_NODE(entry_node,
1655 "Cannot add field class alias found in structure field class: ret=%d",
1656 ret);
1657 goto end;
1658 }
1659 break;
1660 case NODE_STRUCT_OR_VARIANT_DECLARATION:
1661 /* Field */
1662 ret = visit_struct_decl_field(ctx, struct_decl,
1663 entry_node->u.struct_or_variant_declaration.
1664 field_class_specifier_list,
1665 &entry_node->u.struct_or_variant_declaration.
1666 field_class_declarators);
1667 if (ret) {
1668 goto end;
1669 }
1670 break;
1671 default:
1672 _BT_COMP_LOGE_APPEND_CAUSE_NODE(entry_node,
1673 "Unexpected node type: node-type=%d", entry_node->type);
1674 ret = -EINVAL;
1675 goto end;
1676 }
1677
1678 end:
1679 return ret;
1680 }
1681
1682 static
1683 int visit_variant_decl_entry(struct ctf_visitor_generate_ir *ctx, struct ctf_node *entry_node,
1684 struct ctf_field_class_variant *variant_decl)
1685 {
1686 int ret = 0;
1687
1688 switch (entry_node->type) {
1689 case NODE_TYPEDEF:
1690 ret = visit_field_class_def(ctx,
1691 entry_node->u.field_class_def.field_class_specifier_list,
1692 &entry_node->u.field_class_def.field_class_declarators);
1693 if (ret) {
1694 _BT_COMP_LOGE_APPEND_CAUSE_NODE(entry_node,
1695 "Cannot add field class found in variant field class: ret=%d",
1696 ret);
1697 goto end;
1698 }
1699 break;
1700 case NODE_TYPEALIAS:
1701 ret = visit_field_class_alias(ctx, entry_node->u.field_class_alias.target,
1702 entry_node->u.field_class_alias.alias);
1703 if (ret) {
1704 _BT_COMP_LOGE_APPEND_CAUSE_NODE(entry_node,
1705 "Cannot add field class alias found in variant field class: ret=%d",
1706 ret);
1707 goto end;
1708 }
1709 break;
1710 case NODE_STRUCT_OR_VARIANT_DECLARATION:
1711 /* Field */
1712 ret = visit_variant_decl_field(ctx, variant_decl,
1713 entry_node->u.struct_or_variant_declaration.
1714 field_class_specifier_list,
1715 &entry_node->u.struct_or_variant_declaration.
1716 field_class_declarators);
1717 if (ret) {
1718 goto end;
1719 }
1720 break;
1721 default:
1722 _BT_COMP_LOGE_APPEND_CAUSE_NODE(entry_node,
1723 "Unexpected node type: node-type=%d",
1724 entry_node->type);
1725 ret = -EINVAL;
1726 goto end;
1727 }
1728
1729 end:
1730 return ret;
1731 }
1732
1733 static
1734 int visit_struct_decl(struct ctf_visitor_generate_ir *ctx, const char *name,
1735 struct bt_list_head *decl_list, int has_body,
1736 struct bt_list_head *min_align,
1737 struct ctf_field_class_struct **struct_decl)
1738 {
1739 int ret = 0;
1740
1741 BT_ASSERT(struct_decl);
1742 *struct_decl = NULL;
1743
1744 /* For named struct (without body), lookup in declaration scope */
1745 if (!has_body) {
1746 if (!name) {
1747 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Bodyless structure field class: missing name.");
1748 ret = -EPERM;
1749 goto error;
1750 }
1751
1752 *struct_decl = ctx_decl_scope_lookup_struct(ctx, ctx->current_scope,
1753 name, -1, true);
1754 if (!*struct_decl) {
1755 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot find structure field class: name=\"struct %s\"",
1756 name);
1757 ret = -EINVAL;
1758 goto error;
1759 }
1760 } else {
1761 struct ctf_node *entry_node;
1762 uint64_t min_align_value = 0;
1763
1764 if (name) {
1765 if (ctx_decl_scope_lookup_struct(ctx,
1766 ctx->current_scope, name, 1, false)) {
1767 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Structure field class already declared in local scope: "
1768 "name=\"struct %s\"", name);
1769 ret = -EINVAL;
1770 goto error;
1771 }
1772 }
1773
1774 if (!bt_list_empty(min_align)) {
1775 ret = get_unary_unsigned(ctx, min_align,
1776 &min_align_value);
1777 if (ret) {
1778 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Unexpected unary expression for structure field class's `align` attribute: "
1779 "ret=%d", ret);
1780 goto error;
1781 }
1782 }
1783
1784 *struct_decl = ctf_field_class_struct_create();
1785 BT_ASSERT(*struct_decl);
1786
1787 if (min_align_value != 0) {
1788 (*struct_decl)->base.alignment = min_align_value;
1789 }
1790
1791 _TRY_PUSH_SCOPE_OR_GOTO_ERROR();
1792
1793 bt_list_for_each_entry(entry_node, decl_list, siblings) {
1794 ret = visit_struct_decl_entry(ctx, entry_node,
1795 *struct_decl);
1796 if (ret) {
1797 _BT_COMP_LOGE_APPEND_CAUSE_NODE(entry_node,
1798 "Cannot visit structure field class entry: "
1799 "ret=%d", ret);
1800 ctx_pop_scope(ctx);
1801 goto error;
1802 }
1803 }
1804
1805 ctx_pop_scope(ctx);
1806
1807 if (name) {
1808 ret = ctx_decl_scope_register_struct(ctx,
1809 ctx->current_scope, name, *struct_decl);
1810 if (ret) {
1811 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot register structure field class in declaration scope: "
1812 "name=\"struct %s\", ret=%d", name, ret);
1813 goto error;
1814 }
1815 }
1816 }
1817
1818 return 0;
1819
1820 error:
1821 ctf_field_class_destroy(&(*struct_decl)->base);
1822 *struct_decl = NULL;
1823 return ret;
1824 }
1825
1826 static
1827 int visit_variant_decl(struct ctf_visitor_generate_ir *ctx, const char *name,
1828 const char *tag, struct bt_list_head *decl_list,
1829 int has_body, struct ctf_field_class_variant **variant_decl)
1830 {
1831 int ret = 0;
1832 struct ctf_field_class_variant *untagged_variant_decl = NULL;
1833
1834 BT_ASSERT(variant_decl);
1835 *variant_decl = NULL;
1836
1837 /* For named variant (without body), lookup in declaration scope */
1838 if (!has_body) {
1839 if (!name) {
1840 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Bodyless variant field class: missing name.");
1841 ret = -EPERM;
1842 goto error;
1843 }
1844
1845 untagged_variant_decl =
1846 ctx_decl_scope_lookup_variant(ctx, ctx->current_scope,
1847 name, -1, true);
1848 if (!untagged_variant_decl) {
1849 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot find variant field class: name=\"variant %s\"",
1850 name);
1851 ret = -EINVAL;
1852 goto error;
1853 }
1854 } else {
1855 struct ctf_node *entry_node;
1856
1857 if (name) {
1858 if (ctx_decl_scope_lookup_variant(ctx,
1859 ctx->current_scope, name, 1, false)) {
1860 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Variant field class already declared in local scope: "
1861 "name=\"variant %s\"", name);
1862 ret = -EINVAL;
1863 goto error;
1864 }
1865 }
1866
1867 untagged_variant_decl = ctf_field_class_variant_create();
1868 BT_ASSERT(untagged_variant_decl);
1869 _TRY_PUSH_SCOPE_OR_GOTO_ERROR();
1870
1871 bt_list_for_each_entry(entry_node, decl_list, siblings) {
1872 ret = visit_variant_decl_entry(ctx, entry_node,
1873 untagged_variant_decl);
1874 if (ret) {
1875 _BT_COMP_LOGE_APPEND_CAUSE_NODE(entry_node,
1876 "Cannot visit variant field class entry: "
1877 "ret=%d", ret);
1878 ctx_pop_scope(ctx);
1879 goto error;
1880 }
1881 }
1882
1883 ctx_pop_scope(ctx);
1884
1885 if (name) {
1886 ret = ctx_decl_scope_register_variant(ctx,
1887 ctx->current_scope, name,
1888 untagged_variant_decl);
1889 if (ret) {
1890 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot register variant field class in declaration scope: "
1891 "name=\"variant %s\", ret=%d", name, ret);
1892 goto error;
1893 }
1894 }
1895 }
1896
1897 /*
1898 * If tagged, create tagged variant and return; otherwise
1899 * return untagged variant.
1900 */
1901 if (!tag) {
1902 *variant_decl = untagged_variant_decl;
1903 untagged_variant_decl = NULL;
1904 } else {
1905 /*
1906 * At this point, we have a fresh untagged variant; nobody
1907 * else owns it. Set its tag now.
1908 */
1909 g_string_assign(untagged_variant_decl->tag_ref, tag);
1910 *variant_decl = untagged_variant_decl;
1911 untagged_variant_decl = NULL;
1912 }
1913
1914 BT_ASSERT(!untagged_variant_decl);
1915 BT_ASSERT(*variant_decl);
1916 return 0;
1917
1918 error:
1919 ctf_field_class_destroy(&untagged_variant_decl->base);
1920 untagged_variant_decl = NULL;
1921 ctf_field_class_destroy(&(*variant_decl)->base);
1922 *variant_decl = NULL;
1923 return ret;
1924 }
1925
1926 struct uori {
1927 bool is_signed;
1928 union {
1929 uint64_t u;
1930 uint64_t i;
1931 } value;
1932 };
1933
1934 static
1935 int visit_enum_decl_entry(struct ctf_visitor_generate_ir *ctx, struct ctf_node *enumerator,
1936 struct ctf_field_class_enum *enum_decl, struct uori *last)
1937 {
1938 int ret = 0;
1939 int nr_vals = 0;
1940 struct ctf_node *iter;
1941 struct uori start = {
1942 .is_signed = false,
1943 .value = {
1944 .u = 0,
1945 },
1946 };
1947 struct uori end = {
1948 .is_signed = false,
1949 .value = {
1950 .u = 0,
1951 },
1952 };
1953 const char *label = enumerator->u.enumerator.id;
1954 struct bt_list_head *values = &enumerator->u.enumerator.values;
1955
1956 bt_list_for_each_entry(iter, values, siblings) {
1957 struct uori *target;
1958
1959 if (iter->type != NODE_UNARY_EXPRESSION) {
1960 _BT_COMP_LOGE_APPEND_CAUSE_NODE(iter,
1961 "Wrong expression for enumeration field class label: "
1962 "node-type=%d, label=\"%s\"", iter->type,
1963 label);
1964 ret = -EINVAL;
1965 goto error;
1966 }
1967
1968 if (nr_vals == 0) {
1969 target = &start;
1970 } else {
1971 target = &end;
1972 }
1973
1974 switch (iter->u.unary_expression.type) {
1975 case UNARY_SIGNED_CONSTANT:
1976 target->is_signed = true;
1977 target->value.i =
1978 iter->u.unary_expression.u.signed_constant;
1979 break;
1980 case UNARY_UNSIGNED_CONSTANT:
1981 target->is_signed = false;
1982 target->value.u =
1983 iter->u.unary_expression.u.unsigned_constant;
1984 break;
1985 default:
1986 _BT_COMP_LOGE_APPEND_CAUSE_NODE(iter,
1987 "Invalid enumeration field class entry: "
1988 "expecting constant signed or unsigned integer: "
1989 "node-type=%d, label=\"%s\"",
1990 iter->u.unary_expression.type, label);
1991 ret = -EINVAL;
1992 goto error;
1993 }
1994
1995 if (nr_vals > 1) {
1996 _BT_COMP_LOGE_APPEND_CAUSE_NODE(iter,
1997 "Invalid enumeration field class entry: label=\"%s\"",
1998 label);
1999 ret = -EINVAL;
2000 goto error;
2001 }
2002
2003 nr_vals++;
2004 }
2005
2006 if (nr_vals == 0) {
2007 start = *last;
2008 }
2009
2010 if (nr_vals <= 1) {
2011 end = start;
2012 }
2013
2014 if (end.is_signed) {
2015 last->value.i = end.value.i + 1;
2016 } else {
2017 last->value.u = end.value.u + 1;
2018 }
2019
2020 ctf_field_class_enum_map_range(enum_decl, label,
2021 start.value.u, end.value.u);
2022 return 0;
2023
2024 error:
2025 return ret;
2026 }
2027
2028 static
2029 int visit_enum_decl(struct ctf_visitor_generate_ir *ctx, const char *name,
2030 struct ctf_node *container_cls,
2031 struct bt_list_head *enumerator_list,
2032 int has_body, struct ctf_field_class_enum **enum_decl)
2033 {
2034 int ret = 0;
2035 GQuark qdummy_id;
2036 struct ctf_field_class_int *integer_decl = NULL;
2037
2038 BT_ASSERT(enum_decl);
2039 *enum_decl = NULL;
2040
2041 /* For named enum (without body), lookup in declaration scope */
2042 if (!has_body) {
2043 if (!name) {
2044 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Bodyless enumeration field class: missing name.");
2045 ret = -EPERM;
2046 goto error;
2047 }
2048
2049 *enum_decl = ctx_decl_scope_lookup_enum(ctx, ctx->current_scope,
2050 name, -1, true);
2051 if (!*enum_decl) {
2052 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot find enumeration field class: "
2053 "name=\"enum %s\"", name);
2054 ret = -EINVAL;
2055 goto error;
2056 }
2057 } else {
2058 struct ctf_node *iter;
2059 struct uori last_value = {
2060 .is_signed = false,
2061 .value = {
2062 .u = 0,
2063 },
2064 };
2065
2066 if (name) {
2067 if (ctx_decl_scope_lookup_enum(ctx, ctx->current_scope,
2068 name, 1, false)) {
2069 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Enumeration field class already declared in local scope: "
2070 "name=\"enum %s\"", name);
2071 ret = -EINVAL;
2072 goto error;
2073 }
2074 }
2075
2076 if (!container_cls) {
2077 integer_decl = ctf_field_class_as_int(ctx_decl_scope_lookup_alias(ctx,
2078 ctx->current_scope, "int", -1, true));
2079 if (!integer_decl) {
2080 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot find implicit `int` field class alias for enumeration field class.");
2081 ret = -EINVAL;
2082 goto error;
2083 }
2084 } else {
2085 ctf_field_class *decl;
2086
2087 ret = visit_field_class_declarator(ctx, container_cls,
2088 &qdummy_id, NULL, &decl, NULL);
2089 if (ret) {
2090 BT_ASSERT(!decl);
2091 ret = -EINVAL;
2092 goto error;
2093 }
2094
2095 integer_decl = ctf_field_class_as_int(decl);
2096 }
2097
2098 BT_ASSERT(integer_decl);
2099
2100 if (integer_decl->base.base.type != CTF_FIELD_CLASS_TYPE_INT) {
2101 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Container field class for enumeration field class is not an integer field class: "
2102 "fc-type=%d", integer_decl->base.base.type);
2103 ret = -EINVAL;
2104 goto error;
2105 }
2106
2107 *enum_decl = ctf_field_class_enum_create();
2108 BT_ASSERT(*enum_decl);
2109 (*enum_decl)->base.base.base.alignment =
2110 integer_decl->base.base.alignment;
2111 ctf_field_class_int_copy_content(
2112 &(*enum_decl)->base, integer_decl);
2113 last_value.is_signed = (*enum_decl)->base.is_signed;
2114
2115 bt_list_for_each_entry(iter, enumerator_list, siblings) {
2116 ret = visit_enum_decl_entry(ctx, iter, *enum_decl,
2117 &last_value);
2118 if (ret) {
2119 _BT_COMP_LOGE_APPEND_CAUSE_NODE(iter,
2120 "Cannot visit enumeration field class entry: "
2121 "ret=%d", ret);
2122 goto error;
2123 }
2124 }
2125
2126 if (name) {
2127 ret = ctx_decl_scope_register_enum(ctx,
2128 ctx->current_scope, name, *enum_decl);
2129 if (ret) {
2130 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot register enumeration field class in declaration scope: "
2131 "ret=%d", ret);
2132 goto error;
2133 }
2134 }
2135 }
2136
2137 goto end;
2138
2139 error:
2140 ctf_field_class_destroy(&(*enum_decl)->base.base.base);
2141 *enum_decl = NULL;
2142
2143 end:
2144 ctf_field_class_destroy(&integer_decl->base.base);
2145 integer_decl = NULL;
2146 return ret;
2147 }
2148
2149 static
2150 int visit_field_class_specifier(struct ctf_visitor_generate_ir *ctx,
2151 struct ctf_node *cls_specifier_list,
2152 struct ctf_field_class **decl)
2153 {
2154 int ret = 0;
2155 GString *str = NULL;
2156
2157 *decl = NULL;
2158 str = g_string_new("");
2159 ret = get_class_specifier_list_name(ctx, cls_specifier_list, str);
2160 if (ret) {
2161 _BT_COMP_LOGE_APPEND_CAUSE_NODE(cls_specifier_list,
2162 "Cannot get field class specifier list's name: ret=%d", ret);
2163 goto error;
2164 }
2165
2166 *decl = ctx_decl_scope_lookup_alias(ctx, ctx->current_scope, str->str,
2167 -1, true);
2168 if (!*decl) {
2169 _BT_COMP_LOGE_APPEND_CAUSE_NODE(cls_specifier_list,
2170 "Cannot find field class alias: name=\"%s\"", str->str);
2171 ret = -EINVAL;
2172 goto error;
2173 }
2174
2175 goto end;
2176
2177 error:
2178 ctf_field_class_destroy(*decl);
2179 *decl = NULL;
2180
2181 end:
2182 if (str) {
2183 g_string_free(str, TRUE);
2184 }
2185
2186 return ret;
2187 }
2188
2189 static
2190 int visit_integer_decl(struct ctf_visitor_generate_ir *ctx,
2191 struct bt_list_head *expressions,
2192 struct ctf_field_class_int **integer_decl)
2193 {
2194 int set = 0;
2195 int ret = 0;
2196 int signedness = 0;
2197 struct ctf_node *expression;
2198 uint64_t alignment = 0, size = 0;
2199 struct ctf_clock_class *mapped_clock_class = NULL;
2200 enum ctf_encoding encoding = CTF_ENCODING_NONE;
2201 bt_field_class_integer_preferred_display_base base =
2202 BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL;
2203 enum ctf_byte_order byte_order = ctx->ctf_tc->default_byte_order;
2204
2205 *integer_decl = NULL;
2206
2207 bt_list_for_each_entry(expression, expressions, siblings) {
2208 struct ctf_node *left, *right;
2209
2210 left = _BT_LIST_FIRST_ENTRY(&expression->u.ctf_expression.left,
2211 struct ctf_node, siblings);
2212 right = _BT_LIST_FIRST_ENTRY(
2213 &expression->u.ctf_expression.right, struct ctf_node,
2214 siblings);
2215
2216 if (left->u.unary_expression.type != UNARY_STRING) {
2217 _BT_COMP_LOGE_APPEND_CAUSE_NODE(left,
2218 "Unexpected unary expression type: type=%d",
2219 left->u.unary_expression.type);
2220 ret = -EINVAL;
2221 goto error;
2222 }
2223
2224 if (strcmp(left->u.unary_expression.u.string, "signed") == 0) {
2225 if (_IS_SET(&set, _INTEGER_SIGNED_SET)) {
2226 _BT_COMP_LOGE_APPEND_CAUSE_DUP_ATTR(left, "signed",
2227 "integer field class");
2228 ret = -EPERM;
2229 goto error;
2230 }
2231
2232 signedness = get_boolean(ctx, right);
2233 if (signedness < 0) {
2234 _BT_COMP_LOGE_APPEND_CAUSE_NODE(right,
2235 "Invalid boolean value for integer field class's `signed` attribute: "
2236 "ret=%d", ret);
2237 ret = -EINVAL;
2238 goto error;
2239 }
2240
2241 _SET(&set, _INTEGER_SIGNED_SET);
2242 } else if (strcmp(left->u.unary_expression.u.string, "byte_order") == 0) {
2243 if (_IS_SET(&set, _INTEGER_BYTE_ORDER_SET)) {
2244 _BT_COMP_LOGE_APPEND_CAUSE_DUP_ATTR(left, "byte_order",
2245 "integer field class");
2246 ret = -EPERM;
2247 goto error;
2248 }
2249
2250 byte_order = get_real_byte_order(ctx, right);
2251 if (byte_order == CTF_BYTE_ORDER_UNKNOWN) {
2252 _BT_COMP_LOGE_APPEND_CAUSE_NODE(right,
2253 "Invalid `byte_order` attribute in integer field class: "
2254 "ret=%d", ret);
2255 ret = -EINVAL;
2256 goto error;
2257 }
2258
2259 _SET(&set, _INTEGER_BYTE_ORDER_SET);
2260 } else if (strcmp(left->u.unary_expression.u.string, "size") == 0) {
2261 if (_IS_SET(&set, _INTEGER_SIZE_SET)) {
2262 _BT_COMP_LOGE_APPEND_CAUSE_DUP_ATTR(left, "size",
2263 "integer field class");
2264 ret = -EPERM;
2265 goto error;
2266 }
2267
2268 if (right->u.unary_expression.type !=
2269 UNARY_UNSIGNED_CONSTANT) {
2270 _BT_COMP_LOGE_APPEND_CAUSE_NODE(right,
2271 "Invalid `size` attribute in integer field class: "
2272 "expecting unsigned constant integer: "
2273 "node-type=%d",
2274 right->u.unary_expression.type);
2275 ret = -EINVAL;
2276 goto error;
2277 }
2278
2279 size = right->u.unary_expression.u.unsigned_constant;
2280 if (size == 0) {
2281 _BT_COMP_LOGE_APPEND_CAUSE_NODE(right,
2282 "Invalid `size` attribute in integer field class: "
2283 "expecting positive constant integer: "
2284 "size=%" PRIu64, size);
2285 ret = -EINVAL;
2286 goto error;
2287 } else if (size > 64) {
2288 _BT_COMP_LOGE_APPEND_CAUSE_NODE(right,
2289 "Invalid `size` attribute in integer field class: "
2290 "integer fields over 64 bits are not supported as of this version: "
2291 "size=%" PRIu64, size);
2292 ret = -EINVAL;
2293 goto error;
2294 }
2295
2296 _SET(&set, _INTEGER_SIZE_SET);
2297 } else if (strcmp(left->u.unary_expression.u.string, "align") == 0) {
2298 if (_IS_SET(&set, _INTEGER_ALIGN_SET)) {
2299 _BT_COMP_LOGE_APPEND_CAUSE_DUP_ATTR(left, "align",
2300 "integer field class");
2301 ret = -EPERM;
2302 goto error;
2303 }
2304
2305 if (right->u.unary_expression.type !=
2306 UNARY_UNSIGNED_CONSTANT) {
2307 _BT_COMP_LOGE_APPEND_CAUSE_NODE(right,
2308 "Invalid `align` attribute in integer field class: "
2309 "expecting unsigned constant integer: "
2310 "node-type=%d",
2311 right->u.unary_expression.type);
2312 ret = -EINVAL;
2313 goto error;
2314 }
2315
2316 alignment =
2317 right->u.unary_expression.u.unsigned_constant;
2318 if (!is_align_valid(alignment)) {
2319 _BT_COMP_LOGE_APPEND_CAUSE_NODE(right,
2320 "Invalid `align` attribute in integer field class: "
2321 "expecting power of two: "
2322 "align=%" PRIu64, alignment);
2323 ret = -EINVAL;
2324 goto error;
2325 }
2326
2327 _SET(&set, _INTEGER_ALIGN_SET);
2328 } else if (strcmp(left->u.unary_expression.u.string, "base") == 0) {
2329 if (_IS_SET(&set, _INTEGER_BASE_SET)) {
2330 _BT_COMP_LOGE_APPEND_CAUSE_DUP_ATTR(left, "base",
2331 "integer field class");
2332 ret = -EPERM;
2333 goto error;
2334 }
2335
2336 switch (right->u.unary_expression.type) {
2337 case UNARY_UNSIGNED_CONSTANT:
2338 {
2339 uint64_t constant = right->u.unary_expression.
2340 u.unsigned_constant;
2341
2342 switch (constant) {
2343 case 2:
2344 base = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_BINARY;
2345 break;
2346 case 8:
2347 base = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_OCTAL;
2348 break;
2349 case 10:
2350 base = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL;
2351 break;
2352 case 16:
2353 base = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_HEXADECIMAL;
2354 break;
2355 default:
2356 _BT_COMP_LOGE_APPEND_CAUSE_NODE(right,
2357 "Invalid `base` attribute in integer field class: "
2358 "base=%" PRIu64,
2359 right->u.unary_expression.u.unsigned_constant);
2360 ret = -EINVAL;
2361 goto error;
2362 }
2363 break;
2364 }
2365 case UNARY_STRING:
2366 {
2367 char *s_right = ctf_ast_concatenate_unary_strings(
2368 &expression->u.ctf_expression.right);
2369 if (!s_right) {
2370 _BT_COMP_LOGE_APPEND_CAUSE_NODE(right,
2371 "Unexpected unary expression for integer field class's `base` attribute.");
2372 ret = -EINVAL;
2373 goto error;
2374 }
2375
2376 if (strcmp(s_right, "decimal") == 0 ||
2377 strcmp(s_right, "dec") == 0 ||
2378 strcmp(s_right, "d") == 0 ||
2379 strcmp(s_right, "i") == 0 ||
2380 strcmp(s_right, "u") == 0) {
2381 base = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL;
2382 } else if (strcmp(s_right, "hexadecimal") == 0 ||
2383 strcmp(s_right, "hex") == 0 ||
2384 strcmp(s_right, "x") == 0 ||
2385 strcmp(s_right, "X") == 0 ||
2386 strcmp(s_right, "p") == 0) {
2387 base = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_HEXADECIMAL;
2388 } else if (strcmp(s_right, "octal") == 0 ||
2389 strcmp(s_right, "oct") == 0 ||
2390 strcmp(s_right, "o") == 0) {
2391 base = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_OCTAL;
2392 } else if (strcmp(s_right, "binary") == 0 ||
2393 strcmp(s_right, "b") == 0) {
2394 base = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_BINARY;
2395 } else {
2396 _BT_COMP_LOGE_APPEND_CAUSE_NODE(right,
2397 "Unexpected unary expression for integer field class's `base` attribute: "
2398 "base=\"%s\"", s_right);
2399 g_free(s_right);
2400 ret = -EINVAL;
2401 goto error;
2402 }
2403
2404 g_free(s_right);
2405 break;
2406 }
2407 default:
2408 _BT_COMP_LOGE_APPEND_CAUSE_NODE(right,
2409 "Invalid `base` attribute in integer field class: "
2410 "expecting unsigned constant integer or unary string.");
2411 ret = -EINVAL;
2412 goto error;
2413 }
2414
2415 _SET(&set, _INTEGER_BASE_SET);
2416 } else if (strcmp(left->u.unary_expression.u.string, "encoding") == 0) {
2417 char *s_right;
2418
2419 if (_IS_SET(&set, _INTEGER_ENCODING_SET)) {
2420 _BT_COMP_LOGE_APPEND_CAUSE_DUP_ATTR(left, "encoding",
2421 "integer field class");
2422 ret = -EPERM;
2423 goto error;
2424 }
2425
2426 if (right->u.unary_expression.type != UNARY_STRING) {
2427 _BT_COMP_LOGE_APPEND_CAUSE_NODE(right,
2428 "Invalid `encoding` attribute in integer field class: "
2429 "expecting unary string.");
2430 ret = -EINVAL;
2431 goto error;
2432 }
2433
2434 s_right = ctf_ast_concatenate_unary_strings(
2435 &expression->u.ctf_expression.right);
2436 if (!s_right) {
2437 _BT_COMP_LOGE_APPEND_CAUSE_NODE(right,
2438 "Unexpected unary expression for integer field class's `encoding` attribute.");
2439 ret = -EINVAL;
2440 goto error;
2441 }
2442
2443 if (strcmp(s_right, "UTF8") == 0 ||
2444 strcmp(s_right, "utf8") == 0 ||
2445 strcmp(s_right, "utf-8") == 0 ||
2446 strcmp(s_right, "UTF-8") == 0 ||
2447 strcmp(s_right, "ASCII") == 0 ||
2448 strcmp(s_right, "ascii") == 0) {
2449 encoding = CTF_ENCODING_UTF8;
2450 } else if (strcmp(s_right, "none") == 0) {
2451 encoding = CTF_ENCODING_NONE;
2452 } else {
2453 _BT_COMP_LOGE_APPEND_CAUSE_NODE(right,
2454 "Invalid `encoding` attribute in integer field class: "
2455 "unknown encoding: encoding=\"%s\"",
2456 s_right);
2457 g_free(s_right);
2458 ret = -EINVAL;
2459 goto error;
2460 }
2461
2462 g_free(s_right);
2463 _SET(&set, _INTEGER_ENCODING_SET);
2464 } else if (strcmp(left->u.unary_expression.u.string, "map") == 0) {
2465 const char *clock_name;
2466
2467 if (_IS_SET(&set, _INTEGER_MAP_SET)) {
2468 _BT_COMP_LOGE_APPEND_CAUSE_DUP_ATTR(left, "map",
2469 "integer field class");
2470 ret = -EPERM;
2471 goto error;
2472 }
2473
2474 if (right->u.unary_expression.type != UNARY_STRING) {
2475 _BT_COMP_LOGE_APPEND_CAUSE_NODE(right,
2476 "Invalid `map` attribute in integer field class: "
2477 "expecting unary string.");
2478 ret = -EINVAL;
2479 goto error;
2480 }
2481
2482 clock_name =
2483 get_map_clock_name_value(
2484 &expression->u.ctf_expression.right);
2485 if (!clock_name) {
2486 char *s_right = ctf_ast_concatenate_unary_strings(
2487 &expression->u.ctf_expression.right);
2488
2489 if (!s_right) {
2490 _BT_COMP_LOGE_APPEND_CAUSE_NODE(right,
2491 "Unexpected unary expression for integer field class's `map` attribute.");
2492 ret = -EINVAL;
2493 goto error;
2494 }
2495
2496 _BT_COMP_LOGE_NODE(right,
2497 "Invalid `map` attribute in integer field class: "
2498 "cannot find clock class at this point: name=\"%s\"",
2499 s_right);
2500 _SET(&set, _INTEGER_MAP_SET);
2501 g_free(s_right);
2502 continue;
2503 }
2504
2505 mapped_clock_class =
2506 ctf_trace_class_borrow_clock_class_by_name(
2507 ctx->ctf_tc, clock_name);
2508 if (!mapped_clock_class) {
2509 _BT_COMP_LOGE_APPEND_CAUSE_NODE(right,
2510 "Invalid `map` attribute in integer field class: "
2511 "cannot find clock class at this point: name=\"%s\"",
2512 clock_name);
2513 ret = -EINVAL;
2514 goto error;
2515 }
2516
2517 _SET(&set, _INTEGER_MAP_SET);
2518 } else {
2519 _BT_COMP_LOGW_NODE(left,
2520 "Unknown attribute in integer field class: "
2521 "attr-name=\"%s\"",
2522 left->u.unary_expression.u.string);
2523 }
2524 }
2525
2526 if (!_IS_SET(&set, _INTEGER_SIZE_SET)) {
2527 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Missing `size` attribute in integer field class.");
2528 ret = -EPERM;
2529 goto error;
2530 }
2531
2532 if (!_IS_SET(&set, _INTEGER_ALIGN_SET)) {
2533 if (size % CHAR_BIT) {
2534 /* Bit-packed alignment */
2535 alignment = 1;
2536 } else {
2537 /* Byte-packed alignment */
2538 alignment = CHAR_BIT;
2539 }
2540 }
2541
2542 *integer_decl = ctf_field_class_int_create();
2543 BT_ASSERT(*integer_decl);
2544 (*integer_decl)->base.base.alignment = alignment;
2545 (*integer_decl)->base.byte_order = byte_order;
2546 (*integer_decl)->base.size = size;
2547 (*integer_decl)->is_signed = (signedness > 0);
2548 (*integer_decl)->disp_base = base;
2549 (*integer_decl)->encoding = encoding;
2550 (*integer_decl)->mapped_clock_class = mapped_clock_class;
2551 return 0;
2552
2553 error:
2554 ctf_field_class_destroy(&(*integer_decl)->base.base);
2555 *integer_decl = NULL;
2556 return ret;
2557 }
2558
2559 static
2560 int visit_floating_point_number_decl(struct ctf_visitor_generate_ir *ctx,
2561 struct bt_list_head *expressions,
2562 struct ctf_field_class_float **float_decl)
2563 {
2564 int set = 0;
2565 int ret = 0;
2566 struct ctf_node *expression;
2567 uint64_t alignment = 1, exp_dig = 0, mant_dig = 0;
2568 enum ctf_byte_order byte_order = ctx->ctf_tc->default_byte_order;
2569
2570 *float_decl = NULL;
2571
2572 bt_list_for_each_entry(expression, expressions, siblings) {
2573 struct ctf_node *left, *right;
2574
2575 left = _BT_LIST_FIRST_ENTRY(&expression->u.ctf_expression.left,
2576 struct ctf_node, siblings);
2577 right = _BT_LIST_FIRST_ENTRY(
2578 &expression->u.ctf_expression.right, struct ctf_node,
2579 siblings);
2580
2581 if (left->u.unary_expression.type != UNARY_STRING) {
2582 _BT_COMP_LOGE_APPEND_CAUSE_NODE(left,
2583 "Unexpected unary expression type: type=%d",
2584 left->u.unary_expression.type);
2585 ret = -EINVAL;
2586 goto error;
2587 }
2588
2589 if (strcmp(left->u.unary_expression.u.string, "byte_order") == 0) {
2590 if (_IS_SET(&set, _FLOAT_BYTE_ORDER_SET)) {
2591 _BT_COMP_LOGE_APPEND_CAUSE_DUP_ATTR(left, "byte_order",
2592 "floating point number field class");
2593 ret = -EPERM;
2594 goto error;
2595 }
2596
2597 byte_order = get_real_byte_order(ctx, right);
2598 if (byte_order == CTF_BYTE_ORDER_UNKNOWN) {
2599 _BT_COMP_LOGE_APPEND_CAUSE_NODE(right,
2600 "Invalid `byte_order` attribute in floating point number field class: "
2601 "ret=%d", ret);
2602 ret = -EINVAL;
2603 goto error;
2604 }
2605
2606 _SET(&set, _FLOAT_BYTE_ORDER_SET);
2607 } else if (strcmp(left->u.unary_expression.u.string, "exp_dig") == 0) {
2608 if (_IS_SET(&set, _FLOAT_EXP_DIG_SET)) {
2609 _BT_COMP_LOGE_APPEND_CAUSE_DUP_ATTR(left, "exp_dig",
2610 "floating point number field class");
2611 ret = -EPERM;
2612 goto error;
2613 }
2614
2615 if (right->u.unary_expression.type !=
2616 UNARY_UNSIGNED_CONSTANT) {
2617 _BT_COMP_LOGE_APPEND_CAUSE_NODE(right,
2618 "Invalid `exp_dig` attribute in floating point number field class: "
2619 "expecting unsigned constant integer: "
2620 "node-type=%d",
2621 right->u.unary_expression.type);
2622 ret = -EINVAL;
2623 goto error;
2624 }
2625
2626 exp_dig = right->u.unary_expression.u.unsigned_constant;
2627 _SET(&set, _FLOAT_EXP_DIG_SET);
2628 } else if (strcmp(left->u.unary_expression.u.string, "mant_dig") == 0) {
2629 if (_IS_SET(&set, _FLOAT_MANT_DIG_SET)) {
2630 _BT_COMP_LOGE_APPEND_CAUSE_DUP_ATTR(left, "mant_dig",
2631 "floating point number field class");
2632 ret = -EPERM;
2633 goto error;
2634 }
2635
2636 if (right->u.unary_expression.type !=
2637 UNARY_UNSIGNED_CONSTANT) {
2638 _BT_COMP_LOGE_APPEND_CAUSE_NODE(right,
2639 "Invalid `mant_dig` attribute in floating point number field class: "
2640 "expecting unsigned constant integer: "
2641 "node-type=%d",
2642 right->u.unary_expression.type);
2643 ret = -EINVAL;
2644 goto error;
2645 }
2646
2647 mant_dig = right->u.unary_expression.u.
2648 unsigned_constant;
2649 _SET(&set, _FLOAT_MANT_DIG_SET);
2650 } else if (strcmp(left->u.unary_expression.u.string, "align") == 0) {
2651 if (_IS_SET(&set, _FLOAT_ALIGN_SET)) {
2652 _BT_COMP_LOGE_APPEND_CAUSE_DUP_ATTR(left, "align",
2653 "floating point number field class");
2654 ret = -EPERM;
2655 goto error;
2656 }
2657
2658 if (right->u.unary_expression.type !=
2659 UNARY_UNSIGNED_CONSTANT) {
2660 _BT_COMP_LOGE_APPEND_CAUSE_NODE(right,
2661 "Invalid `align` attribute in floating point number field class: "
2662 "expecting unsigned constant integer: "
2663 "node-type=%d",
2664 right->u.unary_expression.type);
2665 ret = -EINVAL;
2666 goto error;
2667 }
2668
2669 alignment = right->u.unary_expression.u.
2670 unsigned_constant;
2671
2672 if (!is_align_valid(alignment)) {
2673 _BT_COMP_LOGE_APPEND_CAUSE_NODE(right,
2674 "Invalid `align` attribute in floating point number field class: "
2675 "expecting power of two: "
2676 "align=%" PRIu64, alignment);
2677 ret = -EINVAL;
2678 goto error;
2679 }
2680
2681 _SET(&set, _FLOAT_ALIGN_SET);
2682 } else {
2683 _BT_COMP_LOGW_NODE(left,
2684 "Unknown attribute in floating point number field class: "
2685 "attr-name=\"%s\"",
2686 left->u.unary_expression.u.string);
2687 }
2688 }
2689
2690 if (!_IS_SET(&set, _FLOAT_MANT_DIG_SET)) {
2691 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Missing `mant_dig` attribute in floating point number field class.");
2692 ret = -EPERM;
2693 goto error;
2694 }
2695
2696 if (!_IS_SET(&set, _FLOAT_EXP_DIG_SET)) {
2697 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Missing `exp_dig` attribute in floating point number field class.");
2698 ret = -EPERM;
2699 goto error;
2700 }
2701
2702 if (mant_dig != 24 && mant_dig != 53) {
2703 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("`mant_dig` attribute: expecting 24 or 53.");
2704 ret = -EPERM;
2705 goto error;
2706 }
2707
2708 if (mant_dig == 24 && exp_dig != 8) {
2709 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("`exp_dig` attribute: expecting 8 because `mant_dig` is 24.");
2710 ret = -EPERM;
2711 goto error;
2712 }
2713
2714 if (mant_dig == 53 && exp_dig != 11) {
2715 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("`exp_dig` attribute: expecting 11 because `mant_dig` is 53.");
2716 ret = -EPERM;
2717 goto error;
2718 }
2719
2720 if (!_IS_SET(&set, _INTEGER_ALIGN_SET)) {
2721 if ((mant_dig + exp_dig) % CHAR_BIT) {
2722 /* Bit-packed alignment */
2723 alignment = 1;
2724 } else {
2725 /* Byte-packed alignment */
2726 alignment = CHAR_BIT;
2727 }
2728 }
2729
2730 *float_decl = ctf_field_class_float_create();
2731 BT_ASSERT(*float_decl);
2732 (*float_decl)->base.base.alignment = alignment;
2733 (*float_decl)->base.byte_order = byte_order;
2734 (*float_decl)->base.size = mant_dig + exp_dig;
2735 return 0;
2736
2737 error:
2738 ctf_field_class_destroy(&(*float_decl)->base.base);
2739 *float_decl = NULL;
2740 return ret;
2741 }
2742
2743 static
2744 int visit_string_decl(struct ctf_visitor_generate_ir *ctx,
2745 struct bt_list_head *expressions,
2746 struct ctf_field_class_string **string_decl)
2747 {
2748 int set = 0;
2749 int ret = 0;
2750 struct ctf_node *expression;
2751 enum ctf_encoding encoding = CTF_ENCODING_UTF8;
2752
2753 *string_decl = NULL;
2754
2755 bt_list_for_each_entry(expression, expressions, siblings) {
2756 struct ctf_node *left, *right;
2757
2758 left = _BT_LIST_FIRST_ENTRY(&expression->u.ctf_expression.left,
2759 struct ctf_node, siblings);
2760 right = _BT_LIST_FIRST_ENTRY(
2761 &expression->u.ctf_expression.right, struct ctf_node,
2762 siblings);
2763
2764 if (left->u.unary_expression.type != UNARY_STRING) {
2765 _BT_COMP_LOGE_APPEND_CAUSE_NODE(left,
2766 "Unexpected unary expression type: type=%d",
2767 left->u.unary_expression.type);
2768 ret = -EINVAL;
2769 goto error;
2770 }
2771
2772 if (strcmp(left->u.unary_expression.u.string, "encoding") == 0) {
2773 char *s_right;
2774
2775 if (_IS_SET(&set, _STRING_ENCODING_SET)) {
2776 _BT_COMP_LOGE_APPEND_CAUSE_DUP_ATTR(left, "encoding",
2777 "string field class");
2778 ret = -EPERM;
2779 goto error;
2780 }
2781
2782 if (right->u.unary_expression.type != UNARY_STRING) {
2783 _BT_COMP_LOGE_APPEND_CAUSE_NODE(right,
2784 "Invalid `encoding` attribute in string field class: "
2785 "expecting unary string.");
2786 ret = -EINVAL;
2787 goto error;
2788 }
2789
2790 s_right = ctf_ast_concatenate_unary_strings(
2791 &expression->u.ctf_expression.right);
2792 if (!s_right) {
2793 _BT_COMP_LOGE_APPEND_CAUSE_NODE(right,
2794 "Unexpected unary expression for string field class's `encoding` attribute.");
2795 ret = -EINVAL;
2796 goto error;
2797 }
2798
2799 if (strcmp(s_right, "UTF8") == 0 ||
2800 strcmp(s_right, "utf8") == 0 ||
2801 strcmp(s_right, "utf-8") == 0 ||
2802 strcmp(s_right, "UTF-8") == 0 ||
2803 strcmp(s_right, "ASCII") == 0 ||
2804 strcmp(s_right, "ascii") == 0) {
2805 encoding = CTF_ENCODING_UTF8;
2806 } else if (strcmp(s_right, "none") == 0) {
2807 encoding = CTF_ENCODING_NONE;
2808 } else {
2809 _BT_COMP_LOGE_APPEND_CAUSE_NODE(right,
2810 "Invalid `encoding` attribute in string field class: "
2811 "unknown encoding: encoding=\"%s\"",
2812 s_right);
2813 g_free(s_right);
2814 ret = -EINVAL;
2815 goto error;
2816 }
2817
2818 g_free(s_right);
2819 _SET(&set, _STRING_ENCODING_SET);
2820 } else {
2821 _BT_COMP_LOGW_NODE(left,
2822 "Unknown attribute in string field class: "
2823 "attr-name=\"%s\"",
2824 left->u.unary_expression.u.string);
2825 }
2826 }
2827
2828 *string_decl = ctf_field_class_string_create();
2829 BT_ASSERT(*string_decl);
2830 (*string_decl)->encoding = encoding;
2831 return 0;
2832
2833 error:
2834 ctf_field_class_destroy(&(*string_decl)->base);
2835 *string_decl = NULL;
2836 return ret;
2837 }
2838
2839 static
2840 int visit_field_class_specifier_list(struct ctf_visitor_generate_ir *ctx,
2841 struct ctf_node *ts_list, struct ctf_field_class **decl)
2842 {
2843 int ret = 0;
2844 struct ctf_node *first, *node;
2845
2846 *decl = NULL;
2847
2848 if (ts_list->type != NODE_TYPE_SPECIFIER_LIST) {
2849 _BT_COMP_LOGE_APPEND_CAUSE_NODE(ts_list,
2850 "Unexpected node type: node-type=%d", ts_list->type);
2851 ret = -EINVAL;
2852 goto error;
2853 }
2854
2855 first = _BT_LIST_FIRST_ENTRY(&ts_list->u.field_class_specifier_list.head,
2856 struct ctf_node, siblings);
2857 if (first->type != NODE_TYPE_SPECIFIER) {
2858 _BT_COMP_LOGE_APPEND_CAUSE_NODE(first,
2859 "Unexpected node type: node-type=%d", first->type);
2860 ret = -EINVAL;
2861 goto error;
2862 }
2863
2864 node = first->u.field_class_specifier.node;
2865
2866 switch (first->u.field_class_specifier.type) {
2867 case TYPESPEC_INTEGER: {
2868 ctf_field_class_int *int_decl;
2869
2870 ret = visit_integer_decl(ctx, &node->u.integer.expressions,
2871 &int_decl);
2872 if (ret) {
2873 BT_ASSERT(!int_decl);
2874 goto error;
2875 }
2876
2877 *decl = &int_decl->base.base;
2878 break;
2879 }
2880 case TYPESPEC_FLOATING_POINT: {
2881 ctf_field_class_float *float_decl;
2882
2883 ret = visit_floating_point_number_decl(ctx,
2884 &node->u.floating_point.expressions, &float_decl);
2885 if (ret) {
2886 BT_ASSERT(!float_decl);
2887 goto error;
2888 }
2889
2890 *decl = &float_decl->base.base;
2891 break;
2892 }
2893 case TYPESPEC_STRING: {
2894 ctf_field_class_string *string_decl;
2895
2896 ret = visit_string_decl(ctx,
2897 &node->u.string.expressions, &string_decl);
2898 if (ret) {
2899 BT_ASSERT(!string_decl);
2900 goto error;
2901 }
2902
2903 *decl = &string_decl->base;
2904 break;
2905 }
2906 case TYPESPEC_STRUCT: {
2907 ctf_field_class_struct *struct_decl;
2908
2909 ret = visit_struct_decl(ctx, node->u._struct.name,
2910 &node->u._struct.declaration_list,
2911 node->u._struct.has_body,
2912 &node->u._struct.min_align, &struct_decl);
2913 if (ret) {
2914 BT_ASSERT(!struct_decl);
2915 goto error;
2916 }
2917
2918 *decl = &struct_decl->base;
2919 break;
2920 }
2921 case TYPESPEC_VARIANT: {
2922 ctf_field_class_variant *variant_decl;
2923
2924 ret = visit_variant_decl(ctx, node->u.variant.name,
2925 node->u.variant.choice,
2926 &node->u.variant.declaration_list,
2927 node->u.variant.has_body, &variant_decl);
2928 if (ret) {
2929 BT_ASSERT(!variant_decl);
2930 goto error;
2931 }
2932
2933 *decl = &variant_decl->base;
2934 break;
2935 }
2936 case TYPESPEC_ENUM: {
2937 ctf_field_class_enum *enum_decl;
2938
2939 ret = visit_enum_decl(ctx, node->u._enum.enum_id,
2940 node->u._enum.container_field_class,
2941 &node->u._enum.enumerator_list,
2942 node->u._enum.has_body, &enum_decl);
2943 if (ret) {
2944 BT_ASSERT(!enum_decl);
2945 goto error;
2946 }
2947
2948 *decl = &enum_decl->base.base.base;
2949 break;
2950 }
2951 case TYPESPEC_VOID:
2952 case TYPESPEC_CHAR:
2953 case TYPESPEC_SHORT:
2954 case TYPESPEC_INT:
2955 case TYPESPEC_LONG:
2956 case TYPESPEC_FLOAT:
2957 case TYPESPEC_DOUBLE:
2958 case TYPESPEC_SIGNED:
2959 case TYPESPEC_UNSIGNED:
2960 case TYPESPEC_BOOL:
2961 case TYPESPEC_COMPLEX:
2962 case TYPESPEC_IMAGINARY:
2963 case TYPESPEC_CONST:
2964 case TYPESPEC_ID_TYPE:
2965 ret = visit_field_class_specifier(ctx, ts_list, decl);
2966 if (ret) {
2967 _BT_COMP_LOGE_APPEND_CAUSE_NODE(first,
2968 "Cannot visit field class specifier: ret=%d",
2969 ret);
2970 BT_ASSERT(!*decl);
2971 goto error;
2972 }
2973 break;
2974 default:
2975 _BT_COMP_LOGE_APPEND_CAUSE_NODE(first,
2976 "Unexpected field class specifier type: node-type=%d",
2977 first->u.field_class_specifier.type);
2978 ret = -EINVAL;
2979 goto error;
2980 }
2981
2982 BT_ASSERT(*decl);
2983 return 0;
2984
2985 error:
2986 ctf_field_class_destroy(*decl);
2987 *decl = NULL;
2988 return ret;
2989 }
2990
2991 static
2992 int visit_event_decl_entry(struct ctf_visitor_generate_ir *ctx, struct ctf_node *node,
2993 struct ctf_event_class *event_class, uint64_t *stream_id,
2994 int *set)
2995 {
2996 int ret = 0;
2997 char *left = NULL;
2998
2999 switch (node->type) {
3000 case NODE_TYPEDEF:
3001 ret = visit_field_class_def(ctx, node->u.field_class_def.field_class_specifier_list,
3002 &node->u.field_class_def.field_class_declarators);
3003 if (ret) {
3004 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3005 "Cannot add field class found in event class.");
3006 goto error;
3007 }
3008 break;
3009 case NODE_TYPEALIAS:
3010 ret = visit_field_class_alias(ctx, node->u.field_class_alias.target,
3011 node->u.field_class_alias.alias);
3012 if (ret) {
3013 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3014 "Cannot add field class alias found in event class.");
3015 goto error;
3016 }
3017 break;
3018 case NODE_CTF_EXPRESSION:
3019 {
3020 left = ctf_ast_concatenate_unary_strings(&node->u.ctf_expression.left);
3021 if (!left) {
3022 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node, "Cannot concatenate unary strings.");
3023 ret = -EINVAL;
3024 goto error;
3025 }
3026
3027 if (strcmp(left, "name") == 0) {
3028 /* This is already known at this stage */
3029 if (_IS_SET(set, _EVENT_NAME_SET)) {
3030 _BT_COMP_LOGE_APPEND_CAUSE_DUP_ATTR(node, "name", "event class");
3031 ret = -EPERM;
3032 goto error;
3033 }
3034
3035 _SET(set, _EVENT_NAME_SET);
3036 } else if (strcmp(left, "id") == 0) {
3037 int64_t id = -1;
3038
3039 if (_IS_SET(set, _EVENT_ID_SET)) {
3040 _BT_COMP_LOGE_APPEND_CAUSE_DUP_ATTR(node, "id", "event class");
3041 ret = -EPERM;
3042 goto error;
3043 }
3044
3045 ret = get_unary_unsigned(ctx,
3046 &node->u.ctf_expression.right,
3047 (uint64_t *) &id);
3048 /* Only read "id" if get_unary_unsigned() succeeded. */
3049 if (ret || (!ret && id < 0)) {
3050 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3051 "Unexpected unary expression for event class's `id` attribute.");
3052 ret = -EINVAL;
3053 goto error;
3054 }
3055
3056 event_class->id = id;
3057 _SET(set, _EVENT_ID_SET);
3058 } else if (strcmp(left, "stream_id") == 0) {
3059 if (_IS_SET(set, _EVENT_STREAM_ID_SET)) {
3060 _BT_COMP_LOGE_APPEND_CAUSE_DUP_ATTR(node, "stream_id",
3061 "event class");
3062 ret = -EPERM;
3063 goto error;
3064 }
3065
3066 ret = get_unary_unsigned(ctx,
3067 &node->u.ctf_expression.right, stream_id);
3068
3069 /*
3070 * Only read "stream_id" if get_unary_unsigned()
3071 * succeeded.
3072 */
3073 if (ret) {
3074 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3075 "Unexpected unary expression for event class's `stream_id` attribute.");
3076 ret = -EINVAL;
3077 goto error;
3078 }
3079
3080 _SET(set, _EVENT_STREAM_ID_SET);
3081 } else if (strcmp(left, "context") == 0) {
3082 if (_IS_SET(set, _EVENT_CONTEXT_SET)) {
3083 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3084 "Duplicate `context` entry in event class.");
3085 ret = -EPERM;
3086 goto error;
3087 }
3088
3089 ret = visit_field_class_specifier_list(ctx,
3090 _BT_LIST_FIRST_ENTRY(
3091 &node->u.ctf_expression.right,
3092 struct ctf_node, siblings),
3093 &event_class->spec_context_fc);
3094 if (ret) {
3095 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3096 "Cannot create event class's context field class.");
3097 goto error;
3098 }
3099
3100 BT_ASSERT(event_class->spec_context_fc);
3101 _SET(set, _EVENT_CONTEXT_SET);
3102 } else if (strcmp(left, "fields") == 0) {
3103 if (_IS_SET(set, _EVENT_FIELDS_SET)) {
3104 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3105 "Duplicate `fields` entry in event class.");
3106 ret = -EPERM;
3107 goto error;
3108 }
3109
3110 ret = visit_field_class_specifier_list(ctx,
3111 _BT_LIST_FIRST_ENTRY(
3112 &node->u.ctf_expression.right,
3113 struct ctf_node, siblings),
3114 &event_class->payload_fc);
3115 if (ret) {
3116 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3117 "Cannot create event class's payload field class.");
3118 goto error;
3119 }
3120
3121 BT_ASSERT(event_class->payload_fc);
3122 _SET(set, _EVENT_FIELDS_SET);
3123 } else if (strcmp(left, "loglevel") == 0) {
3124 uint64_t loglevel_value;
3125 bool is_log_level_known = true;
3126 bt_event_class_log_level log_level;
3127
3128 if (_IS_SET(set, _EVENT_LOG_LEVEL_SET)) {
3129 _BT_COMP_LOGE_APPEND_CAUSE_DUP_ATTR(node, "loglevel",
3130 "event class");
3131 ret = -EPERM;
3132 goto error;
3133 }
3134
3135 ret = get_unary_unsigned(ctx,
3136 &node->u.ctf_expression.right, &loglevel_value);
3137 if (ret) {
3138 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3139 "Unexpected unary expression for event class's `loglevel` attribute.");
3140 ret = -EINVAL;
3141 goto error;
3142 }
3143
3144 switch (loglevel_value) {
3145 case 0:
3146 log_level = BT_EVENT_CLASS_LOG_LEVEL_EMERGENCY;
3147 break;
3148 case 1:
3149 log_level = BT_EVENT_CLASS_LOG_LEVEL_ALERT;
3150 break;
3151 case 2:
3152 log_level = BT_EVENT_CLASS_LOG_LEVEL_CRITICAL;
3153 break;
3154 case 3:
3155 log_level = BT_EVENT_CLASS_LOG_LEVEL_ERROR;
3156 break;
3157 case 4:
3158 log_level = BT_EVENT_CLASS_LOG_LEVEL_WARNING;
3159 break;
3160 case 5:
3161 log_level = BT_EVENT_CLASS_LOG_LEVEL_NOTICE;
3162 break;
3163 case 6:
3164 log_level = BT_EVENT_CLASS_LOG_LEVEL_INFO;
3165 break;
3166 case 7:
3167 log_level = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_SYSTEM;
3168 break;
3169 case 8:
3170 log_level = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROGRAM;
3171 break;
3172 case 9:
3173 log_level = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROCESS;
3174 break;
3175 case 10:
3176 log_level = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_MODULE;
3177 break;
3178 case 11:
3179 log_level = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_UNIT;
3180 break;
3181 case 12:
3182 log_level = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_FUNCTION;
3183 break;
3184 case 13:
3185 log_level = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_LINE;
3186 break;
3187 case 14:
3188 log_level = BT_EVENT_CLASS_LOG_LEVEL_DEBUG;
3189 break;
3190 default:
3191 is_log_level_known = false;
3192 _BT_COMP_LOGW_NODE(node, "Not setting event class's log level because its value is unknown: "
3193 "log-level=%" PRIu64, loglevel_value);
3194 }
3195
3196 if (is_log_level_known) {
3197 ctf_event_class_set_log_level(event_class, log_level);
3198 }
3199
3200 _SET(set, _EVENT_LOG_LEVEL_SET);
3201 } else if (strcmp(left, "model.emf.uri") == 0) {
3202 char *right;
3203
3204 if (_IS_SET(set, _EVENT_MODEL_EMF_URI_SET)) {
3205 _BT_COMP_LOGE_APPEND_CAUSE_DUP_ATTR(node, "model.emf.uri",
3206 "event class");
3207 ret = -EPERM;
3208 goto error;
3209 }
3210
3211 right = ctf_ast_concatenate_unary_strings(
3212 &node->u.ctf_expression.right);
3213 if (!right) {
3214 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3215 "Unexpected unary expression for event class's `model.emf.uri` attribute.");
3216 ret = -EINVAL;
3217 goto error;
3218 }
3219
3220 if (strlen(right) == 0) {
3221 _BT_COMP_LOGW_NODE(node,
3222 "Not setting event class's EMF URI because it's empty.");
3223 } else {
3224 g_string_assign(event_class->emf_uri,
3225 right);
3226 }
3227
3228 g_free(right);
3229 _SET(set, _EVENT_MODEL_EMF_URI_SET);
3230 } else {
3231 _BT_COMP_LOGW_NODE(node,
3232 "Unknown attribute in event class: "
3233 "attr-name=\"%s\"", left);
3234 }
3235
3236 g_free(left);
3237 left = NULL;
3238 break;
3239 }
3240 default:
3241 ret = -EPERM;
3242 goto error;
3243 }
3244
3245 goto end;
3246
3247 error:
3248 g_free(left);
3249
3250 end:
3251 return ret;
3252 }
3253
3254 static
3255 char *get_event_decl_name(struct ctf_visitor_generate_ir *ctx, struct ctf_node *node)
3256 {
3257 char *left = NULL;
3258 char *name = NULL;
3259 struct ctf_node *iter;
3260 struct bt_list_head *decl_list = &node->u.event.declaration_list;
3261
3262 bt_list_for_each_entry(iter, decl_list, siblings) {
3263 if (iter->type != NODE_CTF_EXPRESSION) {
3264 continue;
3265 }
3266
3267 left = ctf_ast_concatenate_unary_strings(&iter->u.ctf_expression.left);
3268 if (!left) {
3269 _BT_COMP_LOGE_APPEND_CAUSE_NODE(iter,
3270 "Cannot concatenate unary strings.");
3271 goto error;
3272 }
3273
3274 if (strcmp(left, "name") == 0) {
3275 name = ctf_ast_concatenate_unary_strings(
3276 &iter->u.ctf_expression.right);
3277 if (!name) {
3278 _BT_COMP_LOGE_APPEND_CAUSE_NODE(iter,
3279 "Unexpected unary expression for event class's `name` attribute.");
3280 goto error;
3281 }
3282 }
3283
3284 g_free(left);
3285 left = NULL;
3286
3287 if (name) {
3288 break;
3289 }
3290 }
3291
3292 return name;
3293
3294 error:
3295 g_free(left);
3296 return NULL;
3297 }
3298
3299 static
3300 int visit_event_decl(struct ctf_visitor_generate_ir *ctx, struct ctf_node *node)
3301 {
3302 int ret = 0;
3303 int set = 0;
3304 struct ctf_node *iter;
3305 uint64_t stream_id = 0;
3306 char *event_name = NULL;
3307 struct ctf_event_class *event_class = NULL;
3308 struct ctf_stream_class *stream_class = NULL;
3309 struct bt_list_head *decl_list = &node->u.event.declaration_list;
3310 bool pop_scope = false;
3311
3312 if (node->visited) {
3313 goto end;
3314 }
3315
3316 node->visited = TRUE;
3317 event_name = get_event_decl_name(ctx, node);
3318 if (!event_name) {
3319 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3320 "Missing `name` attribute in event class.");
3321 ret = -EPERM;
3322 goto error;
3323 }
3324
3325 event_class = ctf_event_class_create();
3326 BT_ASSERT(event_class);
3327 g_string_assign(event_class->name, event_name);
3328 _TRY_PUSH_SCOPE_OR_GOTO_ERROR();
3329 pop_scope = true;
3330
3331 bt_list_for_each_entry(iter, decl_list, siblings) {
3332 ret = visit_event_decl_entry(ctx, iter, event_class,
3333 &stream_id, &set);
3334 if (ret) {
3335 _BT_COMP_LOGE_APPEND_CAUSE_NODE(iter, "Cannot visit event class's entry: "
3336 "ret=%d", ret);
3337 goto error;
3338 }
3339 }
3340
3341 if (!_IS_SET(&set, _EVENT_STREAM_ID_SET)) {
3342 /*
3343 * Allow missing stream_id if there is only a single
3344 * stream class.
3345 */
3346 switch (ctx->ctf_tc->stream_classes->len) {
3347 case 0:
3348 /* Create implicit stream class if there's none */
3349 stream_id = 0;
3350 stream_class = ctf_stream_class_create();
3351 BT_ASSERT(stream_class);
3352 stream_class->id = stream_id;
3353 g_ptr_array_add(ctx->ctf_tc->stream_classes,
3354 stream_class);
3355 break;
3356 case 1:
3357 /* Single stream class: get its ID */
3358 stream_class = (ctf_stream_class *) ctx->ctf_tc->stream_classes->pdata[0];
3359 stream_id = stream_class->id;
3360 break;
3361 default:
3362 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3363 "Missing `stream_id` attribute in event class.");
3364 ret = -EPERM;
3365 goto error;
3366 }
3367 }
3368
3369 /* We have the stream ID now; get the stream class if found */
3370 if (!stream_class) {
3371 stream_class = ctf_trace_class_borrow_stream_class_by_id(
3372 ctx->ctf_tc, stream_id);
3373 if (!stream_class) {
3374 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3375 "Cannot find stream class at this point: "
3376 "id=%" PRId64, stream_id);
3377 ret = -EINVAL;
3378 goto error;
3379 }
3380 }
3381
3382 BT_ASSERT(stream_class);
3383
3384 if (!_IS_SET(&set, _EVENT_ID_SET)) {
3385 /* Allow only one event without ID per stream */
3386 if (stream_class->event_classes->len != 0) {
3387 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3388 "Missing `id` attribute in event class.");
3389 ret = -EPERM;
3390 goto error;
3391 }
3392
3393 /* Automatic ID */
3394 event_class->id = 0;
3395 }
3396
3397 if (ctf_stream_class_borrow_event_class_by_id(stream_class,
3398 event_class->id)) {
3399 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3400 "Duplicate event class (same ID) in the same stream class: "
3401 "id=%" PRId64, event_class->id);
3402 ret = -EEXIST;
3403 goto error;
3404 }
3405
3406 ctf_stream_class_append_event_class(stream_class, event_class);
3407 event_class = NULL;
3408 goto end;
3409
3410 error:
3411 ctf_event_class_destroy(event_class);
3412 event_class = NULL;
3413
3414 if (ret >= 0) {
3415 ret = -1;
3416 }
3417
3418 end:
3419 if (pop_scope) {
3420 ctx_pop_scope(ctx);
3421 }
3422
3423 g_free(event_name);
3424
3425 return ret;
3426 }
3427
3428 static
3429 int auto_map_field_to_trace_clock_class(struct ctf_visitor_generate_ir *ctx,
3430 struct ctf_field_class *fc)
3431 {
3432 struct ctf_clock_class *clock_class_to_map_to = NULL;
3433 struct ctf_field_class_int *int_fc = ctf_field_class_as_int(fc);
3434 int ret = 0;
3435 uint64_t clock_class_count;
3436
3437 if (!fc) {
3438 goto end;
3439 }
3440
3441 if (fc->type != CTF_FIELD_CLASS_TYPE_INT &&
3442 fc->type != CTF_FIELD_CLASS_TYPE_ENUM) {
3443 goto end;
3444 }
3445
3446 if (int_fc->mapped_clock_class) {
3447 /* Already mapped */
3448 goto end;
3449 }
3450
3451 clock_class_count = ctx->ctf_tc->clock_classes->len;
3452
3453 switch (clock_class_count) {
3454 case 0:
3455 /*
3456 * No clock class exists in the trace at this point. Create an
3457 * implicit one at 1 GHz, named `default`, and use this clock
3458 * class.
3459 */
3460 clock_class_to_map_to = ctf_clock_class_create();
3461 BT_ASSERT(clock_class_to_map_to);
3462 clock_class_to_map_to->frequency = UINT64_C(1000000000);
3463 g_string_assign(clock_class_to_map_to->name, "default");
3464 BT_ASSERT(ret == 0);
3465 g_ptr_array_add(ctx->ctf_tc->clock_classes,
3466 clock_class_to_map_to);
3467 break;
3468 case 1:
3469 /*
3470 * Only one clock class exists in the trace at this point: use
3471 * this one.
3472 */
3473 clock_class_to_map_to = (ctf_clock_class *) ctx->ctf_tc->clock_classes->pdata[0];
3474 break;
3475 default:
3476 /*
3477 * Timestamp field not mapped to a clock class and there's more
3478 * than one clock class in the trace: this is an error.
3479 */
3480 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Timestamp field found with no mapped clock class, "
3481 "but there's more than one clock class in the trace at this point.");
3482 ret = -1;
3483 goto end;
3484 }
3485
3486 BT_ASSERT(clock_class_to_map_to);
3487 int_fc->mapped_clock_class = clock_class_to_map_to;
3488
3489 end:
3490 return ret;
3491 }
3492
3493 static
3494 int auto_map_fields_to_trace_clock_class(struct ctf_visitor_generate_ir *ctx,
3495 struct ctf_field_class *root_fc, const char *field_name)
3496 {
3497 int ret = 0;
3498 uint64_t i, count;
3499 struct ctf_field_class_struct *struct_fc = (ctf_field_class_struct *) root_fc;
3500 struct ctf_field_class_variant *var_fc = (ctf_field_class_variant *) root_fc;
3501
3502 if (!root_fc) {
3503 goto end;
3504 }
3505
3506 if (root_fc->type != CTF_FIELD_CLASS_TYPE_STRUCT &&
3507 root_fc->type != CTF_FIELD_CLASS_TYPE_VARIANT) {
3508 goto end;
3509 }
3510
3511 if (root_fc->type == CTF_FIELD_CLASS_TYPE_STRUCT) {
3512 count = struct_fc->members->len;
3513 } else {
3514 count = var_fc->options->len;
3515 }
3516
3517 for (i = 0; i < count; i++) {
3518 struct ctf_named_field_class *named_fc = NULL;
3519
3520 if (root_fc->type == CTF_FIELD_CLASS_TYPE_STRUCT) {
3521 named_fc = ctf_field_class_struct_borrow_member_by_index(
3522 struct_fc, i);
3523 } else if (root_fc->type == CTF_FIELD_CLASS_TYPE_VARIANT) {
3524 named_fc = ctf_field_class_variant_borrow_option_by_index(
3525 var_fc, i);
3526 } else {
3527 bt_common_abort();
3528 }
3529
3530 if (strcmp(named_fc->name->str, field_name) == 0) {
3531 ret = auto_map_field_to_trace_clock_class(ctx,
3532 named_fc->fc);
3533 if (ret) {
3534 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot automatically map field to trace's clock class: "
3535 "field-name=\"%s\"", field_name);
3536 goto end;
3537 }
3538 }
3539
3540 ret = auto_map_fields_to_trace_clock_class(ctx, named_fc->fc,
3541 field_name);
3542 if (ret) {
3543 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot automatically map structure or variant field class's fields to trace's clock class: "
3544 "field-name=\"%s\", root-field-name=\"%s\"",
3545 field_name, named_fc->name->str);
3546 goto end;
3547 }
3548 }
3549
3550 end:
3551 return ret;
3552 }
3553
3554 static
3555 int visit_stream_decl_entry(struct ctf_visitor_generate_ir *ctx, struct ctf_node *node,
3556 struct ctf_stream_class *stream_class, int *set)
3557 {
3558 int ret = 0;
3559 char *left = NULL;
3560
3561 switch (node->type) {
3562 case NODE_TYPEDEF:
3563 ret = visit_field_class_def(ctx, node->u.field_class_def.field_class_specifier_list,
3564 &node->u.field_class_def.field_class_declarators);
3565 if (ret) {
3566 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3567 "Cannot add field class found in stream class.");
3568 goto error;
3569 }
3570 break;
3571 case NODE_TYPEALIAS:
3572 ret = visit_field_class_alias(ctx, node->u.field_class_alias.target,
3573 node->u.field_class_alias.alias);
3574 if (ret) {
3575 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3576 "Cannot add field class alias found in stream class.");
3577 goto error;
3578 }
3579 break;
3580 case NODE_CTF_EXPRESSION:
3581 {
3582 left = ctf_ast_concatenate_unary_strings(&node->u.ctf_expression.left);
3583 if (!left) {
3584 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node, "Cannot concatenate unary strings.");
3585 ret = -EINVAL;
3586 goto error;
3587 }
3588
3589 if (strcmp(left, "id") == 0) {
3590 int64_t id;
3591
3592 if (_IS_SET(set, _STREAM_ID_SET)) {
3593 _BT_COMP_LOGE_APPEND_CAUSE_DUP_ATTR(node, "id",
3594 "stream declaration");
3595 ret = -EPERM;
3596 goto error;
3597 }
3598
3599 ret = get_unary_unsigned(ctx,
3600 &node->u.ctf_expression.right,
3601 (uint64_t *) &id);
3602
3603 /* Only read "id" if get_unary_unsigned() succeeded. */
3604 if (ret || (!ret && id < 0)) {
3605 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3606 "Unexpected unary expression for stream class's `id` attribute.");
3607 ret = -EINVAL;
3608 goto error;
3609 }
3610
3611 if (ctf_trace_class_borrow_stream_class_by_id(
3612 ctx->ctf_tc, id)) {
3613 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3614 "Duplicate stream class (same ID): id=%" PRId64,
3615 id);
3616 ret = -EEXIST;
3617 goto error;
3618 }
3619
3620 stream_class->id = id;
3621 _SET(set, _STREAM_ID_SET);
3622 } else if (strcmp(left, "event.header") == 0) {
3623 if (_IS_SET(set, _STREAM_EVENT_HEADER_SET)) {
3624 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3625 "Duplicate `event.header` entry in stream class.");
3626 ret = -EPERM;
3627 goto error;
3628 }
3629
3630 ret = visit_field_class_specifier_list(ctx,
3631 _BT_LIST_FIRST_ENTRY(
3632 &node->u.ctf_expression.right,
3633 struct ctf_node, siblings),
3634 &stream_class->event_header_fc);
3635 if (ret) {
3636 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3637 "Cannot create stream class's event header field class.");
3638 goto error;
3639 }
3640
3641 BT_ASSERT(stream_class->event_header_fc);
3642 ret = auto_map_fields_to_trace_clock_class(ctx,
3643 stream_class->event_header_fc, "timestamp");
3644 if (ret) {
3645 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3646 "Cannot automatically map specific event header field class fields named `timestamp` to trace's clock class.");
3647 goto error;
3648 }
3649
3650 _SET(set, _STREAM_EVENT_HEADER_SET);
3651 } else if (strcmp(left, "event.context") == 0) {
3652 if (_IS_SET(set, _STREAM_EVENT_CONTEXT_SET)) {
3653 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3654 "Duplicate `event.context` entry in stream class.");
3655 ret = -EPERM;
3656 goto error;
3657 }
3658
3659 ret = visit_field_class_specifier_list(ctx,
3660 _BT_LIST_FIRST_ENTRY(
3661 &node->u.ctf_expression.right,
3662 struct ctf_node, siblings),
3663 &stream_class->event_common_context_fc);
3664 if (ret) {
3665 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3666 "Cannot create stream class's event context field class.");
3667 goto error;
3668 }
3669
3670 BT_ASSERT(stream_class->event_common_context_fc);
3671 _SET(set, _STREAM_EVENT_CONTEXT_SET);
3672 } else if (strcmp(left, "packet.context") == 0) {
3673 if (_IS_SET(set, _STREAM_PACKET_CONTEXT_SET)) {
3674 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3675 "Duplicate `packet.context` entry in stream class.");
3676 ret = -EPERM;
3677 goto error;
3678 }
3679
3680 ret = visit_field_class_specifier_list(ctx,
3681 _BT_LIST_FIRST_ENTRY(
3682 &node->u.ctf_expression.right,
3683 struct ctf_node, siblings),
3684 &stream_class->packet_context_fc);
3685 if (ret) {
3686 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3687 "Cannot create stream class's packet context field class.");
3688 goto error;
3689 }
3690
3691 BT_ASSERT(stream_class->packet_context_fc);
3692 ret = auto_map_fields_to_trace_clock_class(ctx,
3693 stream_class->packet_context_fc,
3694 "timestamp_begin");
3695 if (ret) {
3696 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3697 "Cannot automatically map specific packet context field class fields named `timestamp_begin` to trace's clock class.");
3698 goto error;
3699 }
3700
3701 ret = auto_map_fields_to_trace_clock_class(ctx,
3702 stream_class->packet_context_fc,
3703 "timestamp_end");
3704 if (ret) {
3705 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3706 "Cannot automatically map specific packet context field class fields named `timestamp_end` to trace's clock class.");
3707 goto error;
3708 }
3709
3710 _SET(set, _STREAM_PACKET_CONTEXT_SET);
3711 } else {
3712 _BT_COMP_LOGW_NODE(node,
3713 "Unknown attribute in stream class: "
3714 "attr-name=\"%s\"", left);
3715 }
3716
3717 g_free(left);
3718 left = NULL;
3719 break;
3720 }
3721
3722 default:
3723 ret = -EPERM;
3724 goto error;
3725 }
3726
3727 return 0;
3728
3729 error:
3730 g_free(left);
3731 return ret;
3732 }
3733
3734 static
3735 int visit_stream_decl(struct ctf_visitor_generate_ir *ctx, struct ctf_node *node)
3736 {
3737 int set = 0;
3738 int ret = 0;
3739 struct ctf_node *iter;
3740 struct ctf_stream_class *stream_class = NULL;
3741 struct bt_list_head *decl_list = &node->u.stream.declaration_list;
3742
3743 if (node->visited) {
3744 goto end;
3745 }
3746
3747 node->visited = TRUE;
3748 stream_class = ctf_stream_class_create();
3749 BT_ASSERT(stream_class);
3750 _TRY_PUSH_SCOPE_OR_GOTO_ERROR();
3751
3752 bt_list_for_each_entry(iter, decl_list, siblings) {
3753 ret = visit_stream_decl_entry(ctx, iter, stream_class, &set);
3754 if (ret) {
3755 _BT_COMP_LOGE_APPEND_CAUSE_NODE(iter,
3756 "Cannot visit stream class's entry: "
3757 "ret=%d", ret);
3758 ctx_pop_scope(ctx);
3759 goto error;
3760 }
3761 }
3762
3763 ctx_pop_scope(ctx);
3764
3765 if (_IS_SET(&set, _STREAM_ID_SET)) {
3766 /* Check that packet header has `stream_id` field */
3767 struct ctf_named_field_class *named_fc = NULL;
3768
3769 if (!ctx->ctf_tc->packet_header_fc) {
3770 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3771 "Stream class has a `id` attribute, "
3772 "but trace has no packet header field class.");
3773 ret = -EINVAL;
3774 goto error;
3775 }
3776
3777 named_fc = ctf_field_class_struct_borrow_member_by_name(
3778 ctf_field_class_as_struct(ctx->ctf_tc->packet_header_fc), "stream_id");
3779 if (!named_fc) {
3780 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3781 "Stream class has a `id` attribute, "
3782 "but trace's packet header field class has no `stream_id` field.");
3783 ret = -EINVAL;
3784 goto error;
3785 }
3786
3787 if (named_fc->fc->type != CTF_FIELD_CLASS_TYPE_INT &&
3788 named_fc->fc->type != CTF_FIELD_CLASS_TYPE_ENUM) {
3789 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3790 "Stream class has a `id` attribute, "
3791 "but trace's packet header field class's `stream_id` field is not an integer field class.");
3792 ret = -EINVAL;
3793 goto error;
3794 }
3795 } else {
3796 /* Allow only _one_ ID-less stream */
3797 if (ctx->ctf_tc->stream_classes->len != 0) {
3798 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3799 "Missing `id` attribute in stream class as there's more than one stream class in the trace.");
3800 ret = -EPERM;
3801 goto error;
3802 }
3803
3804 /* Automatic ID: 0 */
3805 stream_class->id = 0;
3806 }
3807
3808 /*
3809 * Make sure that this stream class's ID is currently unique in
3810 * the trace.
3811 */
3812 if (ctf_trace_class_borrow_stream_class_by_id(ctx->ctf_tc,
3813 stream_class->id)) {
3814 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3815 "Duplicate stream class (same ID): id=%" PRId64,
3816 stream_class->id);
3817 ret = -EINVAL;
3818 goto error;
3819 }
3820
3821 g_ptr_array_add(ctx->ctf_tc->stream_classes, stream_class);
3822 stream_class = NULL;
3823 goto end;
3824
3825 error:
3826 ctf_stream_class_destroy(stream_class);
3827 stream_class = NULL;
3828
3829 end:
3830 return ret;
3831 }
3832
3833 static
3834 int visit_trace_decl_entry(struct ctf_visitor_generate_ir *ctx, struct ctf_node *node,
3835 int *set)
3836 {
3837 int ret = 0;
3838 char *left = NULL;
3839 uint64_t val;
3840
3841 switch (node->type) {
3842 case NODE_TYPEDEF:
3843 ret = visit_field_class_def(ctx, node->u.field_class_def.field_class_specifier_list,
3844 &node->u.field_class_def.field_class_declarators);
3845 if (ret) {
3846 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3847 "Cannot add field class found in trace (`trace` block).");
3848 goto error;
3849 }
3850 break;
3851 case NODE_TYPEALIAS:
3852 ret = visit_field_class_alias(ctx, node->u.field_class_alias.target,
3853 node->u.field_class_alias.alias);
3854 if (ret) {
3855 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3856 "Cannot add field class alias found in trace (`trace` block).");
3857 goto error;
3858 }
3859 break;
3860 case NODE_CTF_EXPRESSION:
3861 {
3862 left = ctf_ast_concatenate_unary_strings(&node->u.ctf_expression.left);
3863 if (!left) {
3864 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node, "Cannot concatenate unary strings.");
3865 ret = -EINVAL;
3866 goto error;
3867 }
3868
3869 if (strcmp(left, "major") == 0) {
3870 if (_IS_SET(set, _TRACE_MAJOR_SET)) {
3871 _BT_COMP_LOGE_APPEND_CAUSE_DUP_ATTR(node, "major", "trace");
3872 ret = -EPERM;
3873 goto error;
3874 }
3875
3876 ret = get_unary_unsigned(ctx,
3877 &node->u.ctf_expression.right, &val);
3878 if (ret) {
3879 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3880 "Unexpected unary expression for trace's `major` attribute.");
3881 ret = -EINVAL;
3882 goto error;
3883 }
3884
3885 if (val != 1) {
3886 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3887 "Invalid trace's `minor` attribute: expecting 1.");
3888 ret = -EINVAL;
3889 goto error;
3890 }
3891
3892 ctx->ctf_tc->major = val;
3893 _SET(set, _TRACE_MAJOR_SET);
3894 } else if (strcmp(left, "minor") == 0) {
3895 if (_IS_SET(set, _TRACE_MINOR_SET)) {
3896 _BT_COMP_LOGE_APPEND_CAUSE_DUP_ATTR(node, "minor", "trace");
3897 ret = -EPERM;
3898 goto error;
3899 }
3900
3901 ret = get_unary_unsigned(ctx,
3902 &node->u.ctf_expression.right, &val);
3903 if (ret) {
3904 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3905 "Unexpected unary expression for trace's `minor` attribute.");
3906 ret = -EINVAL;
3907 goto error;
3908 }
3909
3910 if (val != 8) {
3911 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3912 "Invalid trace's `minor` attribute: expecting 8.");
3913 ret = -EINVAL;
3914 goto error;
3915 }
3916
3917 ctx->ctf_tc->minor = val;
3918 _SET(set, _TRACE_MINOR_SET);
3919 } else if (strcmp(left, "uuid") == 0) {
3920 if (_IS_SET(set, _TRACE_UUID_SET)) {
3921 _BT_COMP_LOGE_APPEND_CAUSE_DUP_ATTR(node, "uuid", "trace");
3922 ret = -EPERM;
3923 goto error;
3924 }
3925
3926 ret = get_unary_uuid(ctx,
3927 &node->u.ctf_expression.right,
3928 ctx->ctf_tc->uuid);
3929 if (ret) {
3930 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3931 "Invalid trace's `uuid` attribute.");
3932 goto error;
3933 }
3934
3935 ctx->ctf_tc->is_uuid_set = true;
3936 _SET(set, _TRACE_UUID_SET);
3937 } else if (strcmp(left, "byte_order") == 0) {
3938 /* Default byte order is already known at this stage */
3939 if (_IS_SET(set, _TRACE_BYTE_ORDER_SET)) {
3940 _BT_COMP_LOGE_APPEND_CAUSE_DUP_ATTR(node, "byte_order",
3941 "trace");
3942 ret = -EPERM;
3943 goto error;
3944 }
3945
3946 BT_ASSERT(ctx->ctf_tc->default_byte_order != CTF_BYTE_ORDER_UNKNOWN);
3947 _SET(set, _TRACE_BYTE_ORDER_SET);
3948 } else if (strcmp(left, "packet.header") == 0) {
3949 if (_IS_SET(set, _TRACE_PACKET_HEADER_SET)) {
3950 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3951 "Duplicate `packet.header` entry in trace.");
3952 ret = -EPERM;
3953 goto error;
3954 }
3955
3956 ret = visit_field_class_specifier_list(ctx,
3957 _BT_LIST_FIRST_ENTRY(
3958 &node->u.ctf_expression.right,
3959 struct ctf_node, siblings),
3960 &ctx->ctf_tc->packet_header_fc);
3961 if (ret) {
3962 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
3963 "Cannot create trace's packet header field class.");
3964 goto error;
3965 }
3966
3967 BT_ASSERT(ctx->ctf_tc->packet_header_fc);
3968 _SET(set, _TRACE_PACKET_HEADER_SET);
3969 } else {
3970 _BT_COMP_LOGW_NODE(node,
3971 "Unknown attribute in stream class: "
3972 "attr-name=\"%s\"", left);
3973 }
3974
3975 g_free(left);
3976 left = NULL;
3977 break;
3978 }
3979 default:
3980 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node, "Unknown expression in trace.");
3981 ret = -EINVAL;
3982 goto error;
3983 }
3984
3985 return 0;
3986
3987 error:
3988 g_free(left);
3989 return ret;
3990 }
3991
3992 static
3993 int visit_trace_decl(struct ctf_visitor_generate_ir *ctx, struct ctf_node *node)
3994 {
3995 int ret = 0;
3996 int set = 0;
3997 struct ctf_node *iter;
3998 struct bt_list_head *decl_list = &node->u.trace.declaration_list;
3999
4000 if (node->visited) {
4001 goto end;
4002 }
4003
4004 node->visited = TRUE;
4005
4006 if (ctx->is_trace_visited) {
4007 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node, "Duplicate trace (`trace` block).");
4008 ret = -EEXIST;
4009 goto error;
4010 }
4011
4012 _TRY_PUSH_SCOPE_OR_GOTO_ERROR();
4013
4014 bt_list_for_each_entry(iter, decl_list, siblings) {
4015 ret = visit_trace_decl_entry(ctx, iter, &set);
4016 if (ret) {
4017 _BT_COMP_LOGE_APPEND_CAUSE_NODE(iter, "Cannot visit trace's entry (`trace` block): "
4018 "ret=%d", ret);
4019 ctx_pop_scope(ctx);
4020 goto error;
4021 }
4022 }
4023
4024 ctx_pop_scope(ctx);
4025
4026 if (!_IS_SET(&set, _TRACE_MAJOR_SET)) {
4027 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
4028 "Missing `major` attribute in trace (`trace` block).");
4029 ret = -EPERM;
4030 goto error;
4031 }
4032
4033 if (!_IS_SET(&set, _TRACE_MINOR_SET)) {
4034 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
4035 "Missing `minor` attribute in trace (`trace` block).");
4036 ret = -EPERM;
4037 goto error;
4038 }
4039
4040 if (!_IS_SET(&set, _TRACE_BYTE_ORDER_SET)) {
4041 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
4042 "Missing `byte_order` attribute in trace (`trace` block).");
4043 ret = -EPERM;
4044 goto error;
4045 }
4046
4047 ctx->is_trace_visited = true;
4048
4049 end:
4050 return 0;
4051
4052 error:
4053 return ret;
4054 }
4055
4056 static
4057 int visit_env(struct ctf_visitor_generate_ir *ctx, struct ctf_node *node)
4058 {
4059 int ret = 0;
4060 char *left = NULL;
4061 struct ctf_node *entry_node;
4062 struct bt_list_head *decl_list = &node->u.env.declaration_list;
4063
4064 if (node->visited) {
4065 goto end;
4066 }
4067
4068 node->visited = TRUE;
4069
4070 bt_list_for_each_entry(entry_node, decl_list, siblings) {
4071 struct bt_list_head *right_head =
4072 &entry_node->u.ctf_expression.right;
4073
4074 if (entry_node->type != NODE_CTF_EXPRESSION) {
4075 _BT_COMP_LOGE_APPEND_CAUSE_NODE(entry_node,
4076 "Wrong expression in environment entry: "
4077 "node-type=%d", entry_node->type);
4078 ret = -EPERM;
4079 goto error;
4080 }
4081
4082 left = ctf_ast_concatenate_unary_strings(
4083 &entry_node->u.ctf_expression.left);
4084 if (!left) {
4085 _BT_COMP_LOGE_APPEND_CAUSE_NODE(entry_node,
4086 "Cannot get environment entry's name.");
4087 ret = -EINVAL;
4088 goto error;
4089 }
4090
4091 if (is_unary_string(right_head)) {
4092 char *right = ctf_ast_concatenate_unary_strings(right_head);
4093
4094 if (!right) {
4095 _BT_COMP_LOGE_APPEND_CAUSE_NODE(entry_node,
4096 "Unexpected unary expression for environment entry's value: "
4097 "name=\"%s\"", left);
4098 ret = -EINVAL;
4099 goto error;
4100 }
4101
4102 if (strcmp(left, "tracer_name") == 0) {
4103 if (strncmp(right, "lttng", 5) == 0) {
4104 BT_COMP_LOGI("Detected LTTng trace from `%s` environment value: "
4105 "tracer-name=\"%s\"",
4106 left, right);
4107 ctx->is_lttng = true;
4108 }
4109 }
4110
4111 ctf_trace_class_append_env_entry(ctx->ctf_tc,
4112 left, CTF_TRACE_CLASS_ENV_ENTRY_TYPE_STR,
4113 right, 0);
4114 g_free(right);
4115 } else if (is_unary_unsigned(right_head) ||
4116 is_unary_signed(right_head)) {
4117 int64_t v;
4118
4119 if (is_unary_unsigned(right_head)) {
4120 ret = get_unary_unsigned(ctx, right_head,
4121 (uint64_t *) &v);
4122 } else {
4123 ret = get_unary_signed(right_head, &v);
4124 }
4125 if (ret) {
4126 _BT_COMP_LOGE_APPEND_CAUSE_NODE(entry_node,
4127 "Unexpected unary expression for environment entry's value: "
4128 "name=\"%s\"", left);
4129 ret = -EINVAL;
4130 goto error;
4131 }
4132
4133 ctf_trace_class_append_env_entry(ctx->ctf_tc,
4134 left, CTF_TRACE_CLASS_ENV_ENTRY_TYPE_INT,
4135 NULL, v);
4136 } else {
4137 _BT_COMP_LOGW_NODE(entry_node,
4138 "Environment entry has unknown type: "
4139 "name=\"%s\"", left);
4140 }
4141
4142 g_free(left);
4143 left = NULL;
4144 }
4145
4146 end:
4147 return 0;
4148
4149 error:
4150 g_free(left);
4151 return ret;
4152 }
4153
4154 static
4155 int set_trace_byte_order(struct ctf_visitor_generate_ir *ctx, struct ctf_node *trace_node)
4156 {
4157 int ret = 0;
4158 int set = 0;
4159 char *left = NULL;
4160 struct ctf_node *node;
4161 struct bt_list_head *decl_list = &trace_node->u.trace.declaration_list;
4162
4163 bt_list_for_each_entry(node, decl_list, siblings) {
4164 if (node->type == NODE_CTF_EXPRESSION) {
4165 struct ctf_node *right_node;
4166
4167 left = ctf_ast_concatenate_unary_strings(
4168 &node->u.ctf_expression.left);
4169 if (!left) {
4170 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
4171 "Cannot concatenate unary strings.");
4172 ret = -EINVAL;
4173 goto error;
4174 }
4175
4176 if (strcmp(left, "byte_order") == 0) {
4177 enum ctf_byte_order bo;
4178
4179 if (_IS_SET(&set, _TRACE_BYTE_ORDER_SET)) {
4180 _BT_COMP_LOGE_APPEND_CAUSE_DUP_ATTR(node, "byte_order",
4181 "trace");
4182 ret = -EPERM;
4183 goto error;
4184 }
4185
4186 _SET(&set, _TRACE_BYTE_ORDER_SET);
4187 right_node = _BT_LIST_FIRST_ENTRY(
4188 &node->u.ctf_expression.right,
4189 struct ctf_node, siblings);
4190 bo = byte_order_from_unary_expr(ctx,
4191 right_node);
4192 if (bo == CTF_BYTE_ORDER_UNKNOWN) {
4193 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
4194 "Invalid `byte_order` attribute in trace (`trace` block): "
4195 "expecting `le`, `be`, or `network`.");
4196 ret = -EINVAL;
4197 goto error;
4198 } else if (bo == CTF_BYTE_ORDER_DEFAULT) {
4199 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
4200 "Invalid `byte_order` attribute in trace (`trace` block): "
4201 "cannot be set to `native` here.");
4202 ret = -EPERM;
4203 goto error;
4204 }
4205
4206 ctx->ctf_tc->default_byte_order = bo;
4207 }
4208
4209 g_free(left);
4210 left = NULL;
4211 }
4212 }
4213
4214 if (!_IS_SET(&set, _TRACE_BYTE_ORDER_SET)) {
4215 _BT_COMP_LOGE_APPEND_CAUSE_NODE(trace_node,
4216 "Missing `byte_order` attribute in trace (`trace` block).");
4217 ret = -EINVAL;
4218 goto error;
4219 }
4220
4221 return 0;
4222
4223 error:
4224 g_free(left);
4225 return ret;
4226 }
4227
4228 static
4229 int visit_clock_decl_entry(struct ctf_visitor_generate_ir *ctx, struct ctf_node *entry_node,
4230 struct ctf_clock_class *clock, int *set, int64_t *offset_seconds,
4231 uint64_t *offset_cycles)
4232 {
4233 int ret = 0;
4234 char *left = NULL;
4235
4236 if (entry_node->type != NODE_CTF_EXPRESSION) {
4237 _BT_COMP_LOGE_APPEND_CAUSE_NODE(entry_node,
4238 "Unexpected node type: node-type=%d",
4239 entry_node->type);
4240 ret = -EPERM;
4241 goto error;
4242 }
4243
4244 left = ctf_ast_concatenate_unary_strings(&entry_node->u.ctf_expression.left);
4245 if (!left) {
4246 _BT_COMP_LOGE_APPEND_CAUSE_NODE(entry_node, "Cannot concatenate unary strings.");
4247 ret = -EINVAL;
4248 goto error;
4249 }
4250
4251 if (strcmp(left, "name") == 0) {
4252 char *right;
4253
4254 if (_IS_SET(set, _CLOCK_NAME_SET)) {
4255 _BT_COMP_LOGE_APPEND_CAUSE_DUP_ATTR(entry_node, "name", "clock class");
4256 ret = -EPERM;
4257 goto error;
4258 }
4259
4260 right = ctf_ast_concatenate_unary_strings(
4261 &entry_node->u.ctf_expression.right);
4262 if (!right) {
4263 _BT_COMP_LOGE_APPEND_CAUSE_NODE(entry_node,
4264 "Unexpected unary expression for clock class's `name` attribute.");
4265 ret = -EINVAL;
4266 goto error;
4267 }
4268
4269 g_string_assign(clock->name, right);
4270 g_free(right);
4271 _SET(set, _CLOCK_NAME_SET);
4272 } else if (strcmp(left, "uuid") == 0) {
4273 bt_uuid_t uuid;
4274
4275 if (_IS_SET(set, _CLOCK_UUID_SET)) {
4276 _BT_COMP_LOGE_APPEND_CAUSE_DUP_ATTR(entry_node, "uuid", "clock class");
4277 ret = -EPERM;
4278 goto error;
4279 }
4280
4281 ret = get_unary_uuid(ctx, &entry_node->u.ctf_expression.right,
4282 uuid);
4283 if (ret) {
4284 _BT_COMP_LOGE_APPEND_CAUSE_NODE(entry_node,
4285 "Invalid clock class's `uuid` attribute.");
4286 goto error;
4287 }
4288
4289 clock->has_uuid = true;
4290 bt_uuid_copy(clock->uuid, uuid);
4291 _SET(set, _CLOCK_UUID_SET);
4292 } else if (strcmp(left, "description") == 0) {
4293 char *right;
4294
4295 if (_IS_SET(set, _CLOCK_DESCRIPTION_SET)) {
4296 _BT_COMP_LOGE_APPEND_CAUSE_DUP_ATTR(entry_node, "description",
4297 "clock class");
4298 ret = -EPERM;
4299 goto error;
4300 }
4301
4302 right = ctf_ast_concatenate_unary_strings(
4303 &entry_node->u.ctf_expression.right);
4304 if (!right) {
4305 _BT_COMP_LOGE_APPEND_CAUSE_NODE(entry_node,
4306 "Unexpected unary expression for clock class's `description` attribute.");
4307 ret = -EINVAL;
4308 goto error;
4309 }
4310
4311 g_string_assign(clock->description, right);
4312 g_free(right);
4313 _SET(set, _CLOCK_DESCRIPTION_SET);
4314 } else if (strcmp(left, "freq") == 0) {
4315 uint64_t freq = UINT64_C(-1);
4316
4317 if (_IS_SET(set, _CLOCK_FREQ_SET)) {
4318 _BT_COMP_LOGE_APPEND_CAUSE_DUP_ATTR(entry_node, "freq", "clock class");
4319 ret = -EPERM;
4320 goto error;
4321 }
4322
4323 ret = get_unary_unsigned(ctx,
4324 &entry_node->u.ctf_expression.right, &freq);
4325 if (ret) {
4326 _BT_COMP_LOGE_APPEND_CAUSE_NODE(entry_node,
4327 "Unexpected unary expression for clock class's `freq` attribute.");
4328 ret = -EINVAL;
4329 goto error;
4330 }
4331
4332 if (freq == UINT64_C(-1) || freq == 0) {
4333 _BT_COMP_LOGE_APPEND_CAUSE_NODE(entry_node,
4334 "Invalid clock class frequency: freq=%" PRIu64,
4335 freq);
4336 ret = -EINVAL;
4337 goto error;
4338 }
4339
4340 clock->frequency = freq;
4341 _SET(set, _CLOCK_FREQ_SET);
4342 } else if (strcmp(left, "precision") == 0) {
4343 uint64_t precision;
4344
4345 if (_IS_SET(set, _CLOCK_PRECISION_SET)) {
4346 _BT_COMP_LOGE_APPEND_CAUSE_DUP_ATTR(entry_node, "precision",
4347 "clock class");
4348 ret = -EPERM;
4349 goto error;
4350 }
4351
4352 ret = get_unary_unsigned(ctx,
4353 &entry_node->u.ctf_expression.right, &precision);
4354 if (ret) {
4355 _BT_COMP_LOGE_APPEND_CAUSE_NODE(entry_node,
4356 "Unexpected unary expression for clock class's `precision` attribute.");
4357 ret = -EINVAL;
4358 goto error;
4359 }
4360
4361 clock->precision = precision;
4362 _SET(set, _CLOCK_PRECISION_SET);
4363 } else if (strcmp(left, "offset_s") == 0) {
4364 if (_IS_SET(set, _CLOCK_OFFSET_S_SET)) {
4365 _BT_COMP_LOGE_APPEND_CAUSE_DUP_ATTR(entry_node, "offset_s",
4366 "clock class");
4367 ret = -EPERM;
4368 goto error;
4369 }
4370
4371 ret = get_unary_signed(
4372 &entry_node->u.ctf_expression.right, offset_seconds);
4373 if (ret) {
4374 _BT_COMP_LOGE_APPEND_CAUSE_NODE(entry_node,
4375 "Unexpected unary expression for clock class's `offset_s` attribute.");
4376 ret = -EINVAL;
4377 goto error;
4378 }
4379
4380 _SET(set, _CLOCK_OFFSET_S_SET);
4381 } else if (strcmp(left, "offset") == 0) {
4382 if (_IS_SET(set, _CLOCK_OFFSET_SET)) {
4383 _BT_COMP_LOGE_APPEND_CAUSE_DUP_ATTR(entry_node, "offset", "clock class");
4384 ret = -EPERM;
4385 goto error;
4386 }
4387
4388 ret = get_unary_unsigned(ctx,
4389 &entry_node->u.ctf_expression.right, offset_cycles);
4390 if (ret) {
4391 _BT_COMP_LOGE_APPEND_CAUSE_NODE(entry_node,
4392 "Unexpected unary expression for clock class's `offset` attribute.");
4393 ret = -EINVAL;
4394 goto error;
4395 }
4396
4397 _SET(set, _CLOCK_OFFSET_SET);
4398 } else if (strcmp(left, "absolute") == 0) {
4399 struct ctf_node *right;
4400
4401 if (_IS_SET(set, _CLOCK_ABSOLUTE_SET)) {
4402 _BT_COMP_LOGE_APPEND_CAUSE_DUP_ATTR(entry_node, "absolute",
4403 "clock class");
4404 ret = -EPERM;
4405 goto error;
4406 }
4407
4408 right = _BT_LIST_FIRST_ENTRY(
4409 &entry_node->u.ctf_expression.right,
4410 struct ctf_node, siblings);
4411 ret = get_boolean(ctx, right);
4412 if (ret < 0) {
4413 _BT_COMP_LOGE_APPEND_CAUSE_NODE(entry_node,
4414 "Unexpected unary expression for clock class's `absolute` attribute.");
4415 ret = -EINVAL;
4416 goto error;
4417 }
4418
4419 clock->is_absolute = ret;
4420 _SET(set, _CLOCK_ABSOLUTE_SET);
4421 } else {
4422 _BT_COMP_LOGW_NODE(entry_node,
4423 "Unknown attribute in clock class: attr-name=\"%s\"",
4424 left);
4425 }
4426
4427 g_free(left);
4428 left = NULL;
4429 return 0;
4430
4431 error:
4432 g_free(left);
4433 return ret;
4434 }
4435
4436 static inline
4437 uint64_t cycles_from_ns(uint64_t frequency, uint64_t ns)
4438 {
4439 uint64_t cycles;
4440
4441 /* 1GHz */
4442 if (frequency == UINT64_C(1000000000)) {
4443 cycles = ns;
4444 } else {
4445 cycles = (uint64_t) (((double) ns * (double) frequency) / 1e9);
4446 }
4447
4448 return cycles;
4449 }
4450
4451 static
4452 void calibrate_clock_class_offsets(int64_t *offset_seconds,
4453 uint64_t *offset_cycles, uint64_t freq)
4454 {
4455 if (*offset_cycles >= freq) {
4456 const uint64_t s_in_offset_cycles = *offset_cycles / freq;
4457
4458 *offset_seconds += (int64_t) s_in_offset_cycles;
4459 *offset_cycles -= (s_in_offset_cycles * freq);
4460 }
4461 }
4462
4463 static
4464 void apply_clock_class_is_absolute(struct ctf_visitor_generate_ir *ctx,
4465 struct ctf_clock_class *clock)
4466 {
4467 if (ctx->decoder_config.force_clock_class_origin_unix_epoch) {
4468 clock->is_absolute = true;
4469 }
4470
4471 return;
4472 }
4473
4474 static
4475 void apply_clock_class_offset(struct ctf_visitor_generate_ir *ctx,
4476 struct ctf_clock_class *clock)
4477 {
4478 uint64_t freq;
4479 int64_t offset_s_to_apply = ctx->decoder_config.clock_class_offset_s;
4480 uint64_t offset_ns_to_apply;
4481 int64_t cur_offset_s;
4482 uint64_t cur_offset_cycles;
4483
4484 if (ctx->decoder_config.clock_class_offset_s == 0 &&
4485 ctx->decoder_config.clock_class_offset_ns == 0) {
4486 goto end;
4487 }
4488
4489 /* Transfer nanoseconds to seconds as much as possible */
4490 if (ctx->decoder_config.clock_class_offset_ns < 0) {
4491 const int64_t abs_ns = -ctx->decoder_config.clock_class_offset_ns;
4492 const int64_t abs_extra_s = abs_ns / INT64_C(1000000000) + 1;
4493 const int64_t extra_s = -abs_extra_s;
4494 const int64_t offset_ns = ctx->decoder_config.clock_class_offset_ns -
4495 (extra_s * INT64_C(1000000000));
4496
4497 BT_ASSERT(offset_ns > 0);
4498 offset_ns_to_apply = (uint64_t) offset_ns;
4499 offset_s_to_apply += extra_s;
4500 } else {
4501 const int64_t extra_s = ctx->decoder_config.clock_class_offset_ns /
4502 INT64_C(1000000000);
4503 const int64_t offset_ns = ctx->decoder_config.clock_class_offset_ns -
4504 (extra_s * INT64_C(1000000000));
4505
4506 BT_ASSERT(offset_ns >= 0);
4507 offset_ns_to_apply = (uint64_t) offset_ns;
4508 offset_s_to_apply += extra_s;
4509 }
4510
4511 freq = clock->frequency;
4512 cur_offset_s = clock->offset_seconds;
4513 cur_offset_cycles = clock->offset_cycles;
4514
4515 /* Apply offsets */
4516 cur_offset_s += offset_s_to_apply;
4517 cur_offset_cycles += cycles_from_ns(freq, offset_ns_to_apply);
4518
4519 /*
4520 * Recalibrate offsets because the part in cycles can be greater
4521 * than the frequency at this point.
4522 */
4523 calibrate_clock_class_offsets(&cur_offset_s, &cur_offset_cycles, freq);
4524
4525 /* Set final offsets */
4526 clock->offset_seconds = cur_offset_s;
4527 clock->offset_cycles = cur_offset_cycles;
4528
4529 end:
4530 return;
4531 }
4532
4533 static
4534 int visit_clock_decl(struct ctf_visitor_generate_ir *ctx, struct ctf_node *clock_node)
4535 {
4536 int ret = 0;
4537 int set = 0;
4538 struct ctf_clock_class *clock;
4539 struct ctf_node *entry_node;
4540 struct bt_list_head *decl_list = &clock_node->u.clock.declaration_list;
4541 const char *clock_class_name;
4542 int64_t offset_seconds = 0;
4543 uint64_t offset_cycles = 0;
4544 uint64_t freq;
4545
4546 if (clock_node->visited) {
4547 return 0;
4548 }
4549
4550 clock_node->visited = TRUE;
4551
4552 /* CTF 1.8's default frequency for a clock class is 1 GHz */
4553 clock = ctf_clock_class_create();
4554 if (!clock) {
4555 _BT_COMP_LOGE_APPEND_CAUSE_NODE(clock_node,
4556 "Cannot create default clock class.");
4557 ret = -ENOMEM;
4558 goto end;
4559 }
4560
4561 bt_list_for_each_entry(entry_node, decl_list, siblings) {
4562 ret = visit_clock_decl_entry(ctx, entry_node, clock, &set,
4563 &offset_seconds, &offset_cycles);
4564 if (ret) {
4565 _BT_COMP_LOGE_APPEND_CAUSE_NODE(entry_node,
4566 "Cannot visit clock class's entry: ret=%d",
4567 ret);
4568 goto end;
4569 }
4570 }
4571
4572 if (!_IS_SET(&set, _CLOCK_NAME_SET)) {
4573 _BT_COMP_LOGE_APPEND_CAUSE_NODE(clock_node,
4574 "Missing `name` attribute in clock class.");
4575 ret = -EPERM;
4576 goto end;
4577 }
4578
4579 clock_class_name = clock->name->str;
4580 BT_ASSERT(clock_class_name);
4581 if (ctx->is_lttng && strcmp(clock_class_name, "monotonic") == 0) {
4582 /*
4583 * Old versions of LTTng forgot to set its clock class
4584 * as absolute, even if it is. This is important because
4585 * it's a condition to be able to sort messages
4586 * from different sources.
4587 */
4588 clock->is_absolute = true;
4589 }
4590
4591 /*
4592 * Adjust offsets so that the part in cycles is less than the
4593 * frequency (move to the part in seconds).
4594 */
4595 freq = clock->frequency;
4596 calibrate_clock_class_offsets(&offset_seconds, &offset_cycles, freq);
4597 BT_ASSERT(offset_cycles < clock->frequency);
4598 clock->offset_seconds = offset_seconds;
4599 clock->offset_cycles = offset_cycles;
4600 apply_clock_class_offset(ctx, clock);
4601 apply_clock_class_is_absolute(ctx, clock);
4602 g_ptr_array_add(ctx->ctf_tc->clock_classes, clock);
4603 clock = NULL;
4604
4605 end:
4606 if (clock) {
4607 ctf_clock_class_destroy(clock);
4608 }
4609
4610 return ret;
4611 }
4612
4613 static
4614 int visit_root_decl(struct ctf_visitor_generate_ir *ctx, struct ctf_node *root_decl_node)
4615 {
4616 int ret = 0;
4617
4618 if (root_decl_node->visited) {
4619 goto end;
4620 }
4621
4622 root_decl_node->visited = TRUE;
4623
4624 switch (root_decl_node->type) {
4625 case NODE_TYPEDEF:
4626 ret = visit_field_class_def(ctx,
4627 root_decl_node->u.field_class_def.field_class_specifier_list,
4628 &root_decl_node->u.field_class_def.field_class_declarators);
4629 if (ret) {
4630 _BT_COMP_LOGE_APPEND_CAUSE_NODE(root_decl_node,
4631 "Cannot add field class found in root scope.");
4632 goto end;
4633 }
4634 break;
4635 case NODE_TYPEALIAS:
4636 ret = visit_field_class_alias(ctx, root_decl_node->u.field_class_alias.target,
4637 root_decl_node->u.field_class_alias.alias);
4638 if (ret) {
4639 _BT_COMP_LOGE_APPEND_CAUSE_NODE(root_decl_node,
4640 "Cannot add field class alias found in root scope.");
4641 goto end;
4642 }
4643 break;
4644 case NODE_TYPE_SPECIFIER_LIST:
4645 {
4646 struct ctf_field_class *decl = NULL;
4647
4648 /*
4649 * Just add the field class specifier to the root
4650 * declaration scope. Put local reference.
4651 */
4652 ret = visit_field_class_specifier_list(ctx, root_decl_node, &decl);
4653 if (ret) {
4654 _BT_COMP_LOGE_APPEND_CAUSE_NODE(root_decl_node,
4655 "Cannot visit root scope's field class: "
4656 "ret=%d", ret);
4657 BT_ASSERT(!decl);
4658 goto end;
4659 }
4660
4661 ctf_field_class_destroy(decl);
4662 decl = NULL;
4663 break;
4664 }
4665 default:
4666 _BT_COMP_LOGE_APPEND_CAUSE_NODE(root_decl_node,
4667 "Unexpected node type: node-type=%d",
4668 root_decl_node->type);
4669 ret = -EPERM;
4670 goto end;
4671 }
4672
4673 end:
4674 return ret;
4675 }
4676
4677 BT_HIDDEN
4678 struct ctf_visitor_generate_ir *ctf_visitor_generate_ir_create(
4679 const struct ctf_metadata_decoder_config *decoder_config)
4680 {
4681 struct ctf_visitor_generate_ir *ctx = NULL;
4682
4683 /* Create visitor's context */
4684 ctx = ctx_create(decoder_config);
4685 if (!ctx) {
4686 BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, decoder_config->log_level,
4687 decoder_config->self_comp,
4688 "Cannot create visitor's context.");
4689 goto error;
4690 }
4691
4692 goto end;
4693
4694 error:
4695 ctx_destroy(ctx);
4696 ctx = NULL;
4697
4698 end:
4699 return ctx;
4700 }
4701
4702 BT_HIDDEN
4703 void ctf_visitor_generate_ir_destroy(struct ctf_visitor_generate_ir *visitor)
4704 {
4705 ctx_destroy(visitor);
4706 }
4707
4708 BT_HIDDEN
4709 bt_trace_class *ctf_visitor_generate_ir_get_ir_trace_class(
4710 struct ctf_visitor_generate_ir *ctx)
4711 {
4712 BT_ASSERT_DBG(ctx);
4713
4714 if (ctx->trace_class) {
4715 bt_trace_class_get_ref(ctx->trace_class);
4716 }
4717
4718 return ctx->trace_class;
4719 }
4720
4721 BT_HIDDEN
4722 struct ctf_trace_class *ctf_visitor_generate_ir_borrow_ctf_trace_class(
4723 struct ctf_visitor_generate_ir *ctx)
4724 {
4725 BT_ASSERT_DBG(ctx);
4726 BT_ASSERT_DBG(ctx->ctf_tc);
4727 return ctx->ctf_tc;
4728 }
4729
4730 BT_HIDDEN
4731 int ctf_visitor_generate_ir_visit_node(struct ctf_visitor_generate_ir *ctx,
4732 struct ctf_node *node)
4733 {
4734 int ret = 0;
4735
4736 BT_COMP_LOGI_STR("Visiting metadata's AST to generate CTF IR objects.");
4737
4738 switch (node->type) {
4739 case NODE_ROOT:
4740 {
4741 struct ctf_node *iter;
4742 bool got_trace_decl = false;
4743
4744 /*
4745 * The first thing we need is the native byte order of
4746 * the trace block, because early class aliases can have
4747 * a `byte_order` attribute set to `native`. If we don't
4748 * have the native byte order yet, and we don't have any
4749 * trace block yet, then fail with EINCOMPLETE.
4750 */
4751 if (ctx->ctf_tc->default_byte_order == CTF_BYTE_ORDER_UNKNOWN) {
4752 bt_list_for_each_entry(iter, &node->u.root.trace, siblings) {
4753 if (got_trace_decl) {
4754 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
4755 "Duplicate trace (`trace` block).");
4756 ret = -1;
4757 goto end;
4758 }
4759
4760 ret = set_trace_byte_order(ctx, iter);
4761 if (ret) {
4762 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
4763 "Cannot set trace's native byte order: "
4764 "ret=%d", ret);
4765 goto end;
4766 }
4767
4768 got_trace_decl = true;
4769 }
4770
4771 if (!got_trace_decl) {
4772 BT_COMP_LOGD_STR("Incomplete AST: need trace (`trace` block).");
4773 ret = -EINCOMPLETE;
4774 goto end;
4775 }
4776 }
4777
4778 BT_ASSERT(ctx->ctf_tc->default_byte_order == CTF_BYTE_ORDER_LITTLE ||
4779 ctx->ctf_tc->default_byte_order == CTF_BYTE_ORDER_BIG);
4780 BT_ASSERT(ctx->current_scope &&
4781 !ctx->current_scope->parent_scope);
4782
4783 /* Environment */
4784 bt_list_for_each_entry(iter, &node->u.root.env, siblings) {
4785 ret = visit_env(ctx, iter);
4786 if (ret) {
4787 _BT_COMP_LOGE_APPEND_CAUSE_NODE(iter,
4788 "Cannot visit trace's environment (`env` block) entry: "
4789 "ret=%d", ret);
4790 goto end;
4791 }
4792 }
4793
4794 BT_ASSERT(ctx->current_scope &&
4795 !ctx->current_scope->parent_scope);
4796
4797 /*
4798 * Visit clock blocks.
4799 */
4800 bt_list_for_each_entry(iter, &node->u.root.clock, siblings) {
4801 ret = visit_clock_decl(ctx, iter);
4802 if (ret) {
4803 _BT_COMP_LOGE_APPEND_CAUSE_NODE(iter,
4804 "Cannot visit clock class: ret=%d",
4805 ret);
4806 goto end;
4807 }
4808 }
4809
4810 BT_ASSERT(ctx->current_scope &&
4811 !ctx->current_scope->parent_scope);
4812
4813 /*
4814 * Visit root declarations next, as they can be used by any
4815 * following entity.
4816 */
4817 bt_list_for_each_entry(iter, &node->u.root.declaration_list,
4818 siblings) {
4819 ret = visit_root_decl(ctx, iter);
4820 if (ret) {
4821 _BT_COMP_LOGE_APPEND_CAUSE_NODE(iter,
4822 "Cannot visit root entry: ret=%d",
4823 ret);
4824 goto end;
4825 }
4826 }
4827
4828 BT_ASSERT(ctx->current_scope &&
4829 !ctx->current_scope->parent_scope);
4830
4831 /* Callsite blocks are not supported */
4832 bt_list_for_each_entry(iter, &node->u.root.callsite, siblings) {
4833 _BT_COMP_LOGW_NODE(iter,
4834 "\"callsite\" blocks are not supported as of this version.");
4835 }
4836
4837 BT_ASSERT(ctx->current_scope &&
4838 !ctx->current_scope->parent_scope);
4839
4840 /* Trace */
4841 bt_list_for_each_entry(iter, &node->u.root.trace, siblings) {
4842 ret = visit_trace_decl(ctx, iter);
4843 if (ret) {
4844 _BT_COMP_LOGE_APPEND_CAUSE_NODE(iter,
4845 "Cannot visit trace (`trace` block): "
4846 "ret=%d", ret);
4847 goto end;
4848 }
4849 }
4850
4851 BT_ASSERT(ctx->current_scope &&
4852 !ctx->current_scope->parent_scope);
4853
4854 /* Streams */
4855 bt_list_for_each_entry(iter, &node->u.root.stream, siblings) {
4856 ret = visit_stream_decl(ctx, iter);
4857 if (ret) {
4858 _BT_COMP_LOGE_APPEND_CAUSE_NODE(iter,
4859 "Cannot visit stream class: ret=%d",
4860 ret);
4861 goto end;
4862 }
4863 }
4864
4865 BT_ASSERT(ctx->current_scope &&
4866 !ctx->current_scope->parent_scope);
4867
4868 /* Events */
4869 bt_list_for_each_entry(iter, &node->u.root.event, siblings) {
4870 ret = visit_event_decl(ctx, iter);
4871 if (ret) {
4872 _BT_COMP_LOGE_APPEND_CAUSE_NODE(iter,
4873 "Cannot visit event class: ret=%d",
4874 ret);
4875 goto end;
4876 }
4877 }
4878
4879 BT_ASSERT(ctx->current_scope &&
4880 !ctx->current_scope->parent_scope);
4881 break;
4882 }
4883 default:
4884 _BT_COMP_LOGE_APPEND_CAUSE_NODE(node,
4885 "Unexpected node type: node-type=%d",
4886 node->type);
4887 ret = -EINVAL;
4888 goto end;
4889 }
4890
4891 /* Update default clock classes */
4892 ret = ctf_trace_class_update_default_clock_classes(ctx->ctf_tc,
4893 &ctx->log_cfg);
4894 if (ret) {
4895 ret = -EINVAL;
4896 goto end;
4897 }
4898
4899 /* Update trace class meanings */
4900 ret = ctf_trace_class_update_meanings(ctx->ctf_tc);
4901 if (ret) {
4902 ret = -EINVAL;
4903 goto end;
4904 }
4905
4906 /* Update stream class configuration */
4907 ret = ctf_trace_class_update_stream_class_config(ctx->ctf_tc);
4908 if (ret) {
4909 ret = -EINVAL;
4910 goto end;
4911 }
4912
4913 /* Update text arrays and sequences */
4914 ret = ctf_trace_class_update_text_array_sequence(ctx->ctf_tc);
4915 if (ret) {
4916 ret = -EINVAL;
4917 goto end;
4918 }
4919
4920 /* Update structure/array/sequence alignments */
4921 ret = ctf_trace_class_update_alignments(ctx->ctf_tc);
4922 if (ret) {
4923 ret = -EINVAL;
4924 goto end;
4925 }
4926
4927 /* Resolve sequence lengths and variant tags */
4928 ret = ctf_trace_class_resolve_field_classes(ctx->ctf_tc, &ctx->log_cfg);
4929 if (ret) {
4930 ret = -EINVAL;
4931 goto end;
4932 }
4933
4934 if (ctx->trace_class) {
4935 /*
4936 * Update "in IR" for field classes.
4937 *
4938 * If we have no IR trace class, then we'll have no way
4939 * to create IR fields anyway, so we leave all the
4940 * `in_ir` members false.
4941 */
4942 ret = ctf_trace_class_update_in_ir(ctx->ctf_tc);
4943 if (ret) {
4944 ret = -EINVAL;
4945 goto end;
4946 }
4947 }
4948
4949 /* Update saved value indexes */
4950 ret = ctf_trace_class_update_value_storing_indexes(ctx->ctf_tc);
4951 if (ret) {
4952 ret = -EINVAL;
4953 goto end;
4954 }
4955
4956 /* Validate what we have so far */
4957 ret = ctf_trace_class_validate(ctx->ctf_tc, &ctx->log_cfg);
4958 if (ret) {
4959 ret = -EINVAL;
4960 goto end;
4961 }
4962
4963 /*
4964 * If there are fields which are not related to the CTF format
4965 * itself in the packet header and in event header field
4966 * classes, warn about it because they are never translated.
4967 */
4968 ctf_trace_class_warn_meaningless_header_fields(ctx->ctf_tc,
4969 &ctx->log_cfg);
4970
4971 if (ctx->trace_class) {
4972 /* Copy new CTF metadata -> new IR metadata */
4973 ret = ctf_trace_class_translate(ctx->log_cfg.self_comp,
4974 ctx->trace_class, ctx->ctf_tc);
4975 if (ret) {
4976 ret = -EINVAL;
4977 goto end;
4978 }
4979 }
4980
4981 end:
4982 return ret;
4983 }
BabelTrace - Trace Format Babel Tower
This page took 0.214229 seconds and 3 git commands to generate.