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