projects / libside.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Refactoring: move basic types to their own struct
[libside.git] / include / side / trace.h
CommitLineData
f611d0c3
MD		 1// SPDX-License-Identifier: MIT
2/*
3 * Copyright 2022 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
4 */
5
6#ifndef _SIDE_TRACE_H
7#define _SIDE_TRACE_H
8
9#include <stdint.h>
10#include <inttypes.h>
11#include <stdlib.h>
12#include <stdio.h>
fb25b355 13#include <math.h>
f611d0c3 14#include <side/macros.h>
8bdd5c12 15#include <side/endian.h>
f611d0c3
MD		 16
17/* SIDE stands for "Static Instrumentation Dynamically Enabled" */
18
64f5abc7
MD		 19//TODO: as those structures will be ABI, we need to either consider them
20//fixed forever, or think of a scheme that would allow their binary
07f35472 21//representation to be extended if need be.
64f5abc7 22
f611d0c3 23struct side_arg_vec;
a2e2357e
MD		 24struct side_arg_vec_description;
25struct side_arg_dynamic_vec;
26struct side_arg_dynamic_vec_vla;
f611d0c3
MD		 27struct side_type_description;
28struct side_event_field;
7a1cb105 29struct side_event_field_sg;
352a4b77 30struct side_tracer_visitor_ctx;
c208889e 31struct side_tracer_dynamic_struct_visitor_ctx;
bdc39c09 32struct side_tracer_dynamic_vla_visitor_ctx;
d89fabc8
MD		 33struct side_event_description;
34struct side_arg_dynamic_event_struct;
6e46f5e6 35struct side_events_register_handle;
f611d0c3
MD		 36
37enum side_type {
e24949fa 38 /* Basic types */
4f40d951 39 SIDE_TYPE_BOOL,
f611d0c3
MD		 40 SIDE_TYPE_U8,
41 SIDE_TYPE_U16,
42 SIDE_TYPE_U32,
43 SIDE_TYPE_U64,
44 SIDE_TYPE_S8,
45 SIDE_TYPE_S16,
46 SIDE_TYPE_S32,
47 SIDE_TYPE_S64,
f7653b43 48 SIDE_TYPE_BYTE,
dd6e76cb
MD		 49 SIDE_TYPE_POINTER32,
50 SIDE_TYPE_POINTER64,
e24949fa
MD		 51 SIDE_TYPE_FLOAT_BINARY16,
52 SIDE_TYPE_FLOAT_BINARY32,
53 SIDE_TYPE_FLOAT_BINARY64,
54 SIDE_TYPE_FLOAT_BINARY128,
55 SIDE_TYPE_STRING,
ba845af5 56
e24949fa 57 /* Compound types */
f611d0c3 58 SIDE_TYPE_STRUCT,
7a1cb105 59 SIDE_TYPE_STRUCT_SG,
f611d0c3
MD		 60 SIDE_TYPE_ARRAY,
61 SIDE_TYPE_VLA,
62 SIDE_TYPE_VLA_VISITOR,
ba845af5
MD		 63
64 SIDE_TYPE_ARRAY_U8,
65 SIDE_TYPE_ARRAY_U16,
66 SIDE_TYPE_ARRAY_U32,
67 SIDE_TYPE_ARRAY_U64,
68 SIDE_TYPE_ARRAY_S8,
69 SIDE_TYPE_ARRAY_S16,
70 SIDE_TYPE_ARRAY_S32,
71 SIDE_TYPE_ARRAY_S64,
f7653b43 72 SIDE_TYPE_ARRAY_BYTE,
dd6e76cb
MD		 73 SIDE_TYPE_ARRAY_POINTER32,
74 SIDE_TYPE_ARRAY_POINTER64,
ba845af5 75
1533629f
MD		 76 SIDE_TYPE_VLA_U8,
77 SIDE_TYPE_VLA_U16,
78 SIDE_TYPE_VLA_U32,
79 SIDE_TYPE_VLA_U64,
80 SIDE_TYPE_VLA_S8,
81 SIDE_TYPE_VLA_S16,
82 SIDE_TYPE_VLA_S32,
83 SIDE_TYPE_VLA_S64,
f7653b43 84 SIDE_TYPE_VLA_BYTE,
dd6e76cb
MD		 85 SIDE_TYPE_VLA_POINTER32,
86 SIDE_TYPE_VLA_POINTER64,
1533629f 87
af6aa6e1 88 /* Enumeration types */
d8be25de 89 SIDE_TYPE_ENUM,
bab5d6e4 90 SIDE_TYPE_ENUM_BITMAP,
af6aa6e1 91
e24949fa 92 /* Dynamic type */
bdc39c09
MD		 93 SIDE_TYPE_DYNAMIC,
94};
95
96enum side_dynamic_type {
e24949fa 97 /* Basic types */
bdc39c09 98 SIDE_DYNAMIC_TYPE_NULL,
4f40d951 99 SIDE_DYNAMIC_TYPE_BOOL,
bdc39c09
MD		 100 SIDE_DYNAMIC_TYPE_U8,
101 SIDE_DYNAMIC_TYPE_U16,
102 SIDE_DYNAMIC_TYPE_U32,
103 SIDE_DYNAMIC_TYPE_U64,
104 SIDE_DYNAMIC_TYPE_S8,
105 SIDE_DYNAMIC_TYPE_S16,
106 SIDE_DYNAMIC_TYPE_S32,
107 SIDE_DYNAMIC_TYPE_S64,
f7653b43 108 SIDE_DYNAMIC_TYPE_BYTE,
dd6e76cb
MD		 109 SIDE_DYNAMIC_TYPE_POINTER32,
110 SIDE_DYNAMIC_TYPE_POINTER64,
fb25b355
MD		 111 SIDE_DYNAMIC_TYPE_FLOAT_BINARY16,
112 SIDE_DYNAMIC_TYPE_FLOAT_BINARY32,
113 SIDE_DYNAMIC_TYPE_FLOAT_BINARY64,
114 SIDE_DYNAMIC_TYPE_FLOAT_BINARY128,
bdc39c09
MD		 115 SIDE_DYNAMIC_TYPE_STRING,
116
e24949fa 117 /* Compound types */
c208889e
MD		 118 SIDE_DYNAMIC_TYPE_STRUCT,
119 SIDE_DYNAMIC_TYPE_STRUCT_VISITOR,
a2e2357e 120 SIDE_DYNAMIC_TYPE_VLA,
bdc39c09 121 SIDE_DYNAMIC_TYPE_VLA_VISITOR,
f611d0c3
MD		 122};
123
bc3c89b3 124enum side_attr_type {
e2c978ee 125 SIDE_ATTR_TYPE_NULL,
bc3c89b3 126 SIDE_ATTR_TYPE_BOOL,
bc3c89b3
MD		 127 SIDE_ATTR_TYPE_U8,
128 SIDE_ATTR_TYPE_U16,
129 SIDE_ATTR_TYPE_U32,
130 SIDE_ATTR_TYPE_U64,
131 SIDE_ATTR_TYPE_S8,
132 SIDE_ATTR_TYPE_S16,
133 SIDE_ATTR_TYPE_S32,
134 SIDE_ATTR_TYPE_S64,
dd6e76cb
MD		 135 SIDE_ATTR_TYPE_POINTER32,
136 SIDE_ATTR_TYPE_POINTER64,
bc3c89b3
MD		 137 SIDE_ATTR_TYPE_FLOAT_BINARY16,
138 SIDE_ATTR_TYPE_FLOAT_BINARY32,
139 SIDE_ATTR_TYPE_FLOAT_BINARY64,
140 SIDE_ATTR_TYPE_FLOAT_BINARY128,
bc3c89b3
MD		 141 SIDE_ATTR_TYPE_STRING,
142};
143
7a1cb105
MD		 144enum side_type_sg {
145 SIDE_TYPE_SG_UNSIGNED_INT,
146 SIDE_TYPE_SG_SIGNED_INT,
147};
148
f611d0c3
MD		 149enum side_loglevel {
150 SIDE_LOGLEVEL_EMERG = 0,
151 SIDE_LOGLEVEL_ALERT = 1,
152 SIDE_LOGLEVEL_CRIT = 2,
153 SIDE_LOGLEVEL_ERR = 3,
154 SIDE_LOGLEVEL_WARNING = 4,
155 SIDE_LOGLEVEL_NOTICE = 5,
156 SIDE_LOGLEVEL_INFO = 6,
157 SIDE_LOGLEVEL_DEBUG = 7,
158};
159
160enum side_visitor_status {
f611d0c3 161 SIDE_VISITOR_STATUS_OK = 0,
db6ecef9 162 SIDE_VISITOR_STATUS_ERROR = -1,
f611d0c3
MD		 163};
164
a3f36db7
MD		 165enum side_error {
166 SIDE_ERROR_OK = 0,
167 SIDE_ERROR_INVAL = 1,
168 SIDE_ERROR_EXIST = 2,
169 SIDE_ERROR_NOMEM = 3,
170 SIDE_ERROR_NOENT = 4,
6e46f5e6 171 SIDE_ERROR_EXITING = 5,
a3f36db7
MD		 172};
173
8bdd5c12
MD		 174enum side_type_byte_order {
175 SIDE_TYPE_BYTE_ORDER_LE = 0,
176 SIDE_TYPE_BYTE_ORDER_BE = 1,
177};
178
179#if (SIDE_BYTE_ORDER == SIDE_LITTLE_ENDIAN)
180# define SIDE_TYPE_BYTE_ORDER_HOST SIDE_TYPE_BYTE_ORDER_LE
181#else
182# define SIDE_TYPE_BYTE_ORDER_HOST SIDE_TYPE_BYTE_ORDER_BE
183#endif
184
185#if (SIDE_FLOAT_WORD_ORDER == SIDE_LITTLE_ENDIAN)
186# define SIDE_TYPE_FLOAT_WORD_ORDER_HOST SIDE_TYPE_BYTE_ORDER_LE
187#else
188# define SIDE_TYPE_FLOAT_WORD_ORDER_HOST SIDE_TYPE_BYTE_ORDER_BE
189#endif
190
f93e01ac
MD		 191typedef enum side_visitor_status (*side_visitor)(
192 const struct side_tracer_visitor_ctx *tracer_ctx,
193 void *app_ctx);
194typedef enum side_visitor_status (*side_dynamic_struct_visitor)(
195 const struct side_tracer_dynamic_struct_visitor_ctx *tracer_ctx,
196 void *app_ctx);
197typedef enum side_visitor_status (*side_dynamic_vla_visitor)(
198 const struct side_tracer_dynamic_vla_visitor_ctx *tracer_ctx,
199 void *app_ctx);
f611d0c3 200
d37fe349 201union side_integer_value {
43d85239
MD		 202 uint8_t side_u8;
203 uint16_t side_u16;
204 uint32_t side_u32;
205 uint64_t side_u64;
206 int8_t side_s8;
207 int16_t side_s16;
208 int32_t side_s32;
209 int64_t side_s64;
210};
211
d37fe349 212union side_float_value {
bc3c89b3
MD		 213#if __HAVE_FLOAT16
214 _Float16 side_float_binary16;
215#endif
216#if __HAVE_FLOAT32
217 _Float32 side_float_binary32;
218#endif
219#if __HAVE_FLOAT64
220 _Float64 side_float_binary64;
221#endif
222#if __HAVE_FLOAT128
223 _Float128 side_float_binary128;
224#endif
a4969f31
MD		 225};
226
227struct side_attr_value {
228 uint32_t type; /* enum side_attr_type */
229 union {
5f82db91
MD		 230 uint8_t bool_value;
231 uint64_t string_value; /* const char * */
d37fe349
MD		 232 union side_integer_value integer_value;
233 union side_float_value float_value;
bc3c89b3
MD		 234 } u;
235};
236
65010f43
MD		 237/* User attributes. */
238struct side_attr {
239 const char *key;
bc3c89b3 240 const struct side_attr_value value;
65010f43
MD		 241};
242
87405d12
MD		 243struct side_type_integer {
244 const struct side_attr *attr;
245 uint32_t nr_attr;
246 uint16_t integer_size_bits; /* bits */
247 uint16_t len_bits; /* bits */
248 uint8_t signedness; /* true/false */
249 uint8_t byte_order; /* enum side_type_byte_order */
250};
251
252struct side_type_float {
253 const struct side_attr *attr;
254 uint32_t nr_attr;
255 uint32_t byte_order; /* enum side_type_byte_order */
256 uint16_t float_size_bits; /* bits */
257};
258
79f677ba
MD		 259struct side_enum_mapping {
260 int64_t range_begin;
261 int64_t range_end;
262 const char *label;
263};
264
265struct side_enum_mappings {
266 const struct side_enum_mapping *mappings;
d4328528 267 const struct side_attr *attr;
79f677ba 268 uint32_t nr_mappings;
d4328528 269 uint32_t nr_attr;
79f677ba
MD		 270};
271
66cff328 272struct side_enum_bitmap_mapping {
9ff49ee4
MD		 273 uint64_t range_begin;
274 uint64_t range_end;
66cff328
MD		 275 const char *label;
276};
277
278struct side_enum_bitmap_mappings {
279 const struct side_enum_bitmap_mapping *mappings;
d4328528 280 const struct side_attr *attr;
66cff328 281 uint32_t nr_mappings;
d4328528 282 uint32_t nr_attr;
66cff328
MD		 283};
284
c7a14585
MD		 285struct side_type_struct {
286 uint32_t nr_fields;
287 uint32_t nr_attr;
288 const struct side_event_field *fields;
289 const struct side_attr *attr;
290};
291
5f82db91
MD		 292struct side_type_null {
293 const struct side_attr *attr;
294 uint32_t nr_attr;
295};
296
297struct side_type_bool {
298 const struct side_attr *attr;
299 uint32_t nr_attr;
300};
301
302struct side_type_byte {
303 const struct side_attr *attr;
304 uint32_t nr_attr;
305};
306
307struct side_type_dynamic {
308 const struct side_attr *attr;
309 uint32_t nr_attr;
310};
311
312struct side_type_string {
313 const struct side_attr *attr;
314 uint32_t nr_attr;
315};
316
7a1cb105 317struct side_type_sg_description {
87405d12
MD		 318 uint64_t offset; /* bytes */
319 uint32_t type; /* enum side_type_sg */
7a1cb105 320 union {
7a1cb105 321 struct {
87405d12
MD		 322 struct side_type_integer type;
323 uint16_t offset_bits; /* bits */
324 } side_integer;
7a1cb105
MD		 325 } u;
326};
327
328struct side_struct_field_sg {
329 const char *field_name;
330 struct side_type_sg_description side_type;
331};
332
333/* Structure fields scatter-gather. */
334struct side_type_struct_sg {
335 uint32_t nr_fields;
336 uint32_t nr_attr;
337 const struct side_struct_field_sg *fields_sg;
338 const struct side_attr *attr;
339};
340
f611d0c3 341struct side_type_description {
2f5827d5 342 uint32_t type; /* enum side_type */
f611d0c3 343 union {
e24949fa 344 /* Basic types */
5f82db91
MD		 345 struct side_type_bool side_bool;
346 struct side_type_byte side_byte;
347 struct side_type_dynamic side_dynamic;
348 struct side_type_string side_string;
56c21987 349 struct side_type_integer side_integer;
d44b44d1 350 struct side_type_float side_float;
56c21987 351
e24949fa 352 /* Compound types */
d4328528 353 struct {
f611d0c3 354 const struct side_type_description *elem_type;
d4328528
MD		 355 const struct side_attr *attr;
356 uint32_t length;
357 uint32_t nr_attr;
f611d0c3
MD		 358 } side_array;
359 struct {
360 const struct side_type_description *elem_type;
d4328528
MD		 361 const struct side_attr *attr;
362 uint32_t nr_attr;
f611d0c3
MD		 363 } side_vla;
364 struct {
365 const struct side_type_description *elem_type;
352a4b77 366 side_visitor visitor;
d4328528
MD		 367 const struct side_attr *attr;
368 uint32_t nr_attr;
f611d0c3 369 } side_vla_visitor;
d4328528 370 const struct side_type_struct *side_struct;
7a1cb105 371 const struct side_type_struct_sg *side_struct_sg;
af6aa6e1
MD		 372
373 /* Enumeration types */
d8be25de 374 struct {
d8be25de 375 const struct side_enum_mappings *mappings;
f89c4ad1 376 const struct side_type_description *elem_type;
d8be25de 377 } side_enum;
af6aa6e1 378 struct {
af6aa6e1 379 const struct side_enum_bitmap_mappings *mappings;
f89c4ad1 380 const struct side_type_description *elem_type;
bab5d6e4 381 } side_enum_bitmap;
f611d0c3
MD		 382 } u;
383};
384
385struct side_event_field {
386 const char *field_name;
387 struct side_type_description side_type;
388};
389
8a25ce77
MD		 390enum side_event_flags {
391 SIDE_EVENT_FLAG_VARIADIC = (1 << 0),
392};
393
d89fabc8
MD		 394struct side_callback {
395 union {
396 void (*call)(const struct side_event_description *desc,
397 const struct side_arg_vec_description *sav_desc,
398 void *priv);
399 void (*call_variadic)(const struct side_event_description *desc,
400 const struct side_arg_vec_description *sav_desc,
401 const struct side_arg_dynamic_event_struct *var_struct,
402 void *priv);
403 } u;
404 void *priv;
405};
406
f611d0c3 407struct side_event_description {
83a72806 408 uintptr_t *enabled;
f611d0c3
MD		 409 const char *provider_name;
410 const char *event_name;
411 const struct side_event_field *fields;
65010f43 412 const struct side_attr *attr;
054b7b5c 413 const struct side_callback *callbacks;
83a72806
MD		 414 uint64_t flags;
415 uint32_t version;
416 uint32_t loglevel; /* enum side_loglevel */
417 uint32_t nr_fields;
418 uint32_t nr_attr;
419 uint32_t nr_callbacks;
f611d0c3
MD		 420};
421
bdc39c09 422struct side_arg_dynamic_vec {
2f5827d5 423 uint32_t dynamic_type; /* enum side_dynamic_type */
bdc39c09 424 union {
5f82db91
MD		 425 struct side_type_null side_null_type;
426
e24949fa 427 /* Basic types */
8d20e708 428 struct {
5f82db91
MD		 429 struct side_type_bool type;
430 uint8_t value;
431 } side_bool;
432
433 struct {
434 struct side_type_byte type;
435 uint8_t value;
436 } side_byte;
437
438 struct {
439 struct side_type_string type;
440 uint64_t value; /* const char * */
441 } side_string;
bdc39c09 442
d2be7696
MD		 443 /* Integer type */
444 struct {
445 struct side_type_integer type;
446 union side_integer_value value;
447 } side_integer;
448
aac52685
MD		 449 struct {
450 struct side_type_float type;
451 union side_float_value value;
452 } side_float;
453
e24949fa 454 /* Compound types */
c208889e 455 const struct side_arg_dynamic_event_struct *side_dynamic_struct;
bdc39c09 456 struct {
8ceca0cd 457 void *app_ctx;
c208889e 458 side_dynamic_struct_visitor visitor;
8d20e708
MD		 459 const struct side_attr *attr;
460 uint32_t nr_attr;
c208889e 461 } side_dynamic_struct_visitor;
a2e2357e 462 const struct side_arg_dynamic_vec_vla *side_dynamic_vla;
bdc39c09 463 struct {
8ceca0cd 464 void *app_ctx;
bdc39c09 465 side_dynamic_vla_visitor visitor;
8d20e708
MD		 466 const struct side_attr *attr;
467 uint32_t nr_attr;
bdc39c09
MD		 468 } side_dynamic_vla_visitor;
469 } u;
470};
471
8d20e708
MD		 472struct side_arg_dynamic_vec_vla {
473 const struct side_arg_dynamic_vec *sav;
474 const struct side_attr *attr;
475 uint32_t len;
476 uint32_t nr_attr;
477};
478
465e5e7e
MD		 479struct side_arg_dynamic_event_field {
480 const char *field_name;
481 const struct side_arg_dynamic_vec elem;
465e5e7e
MD		 482};
483
c208889e 484struct side_arg_dynamic_event_struct {
465e5e7e 485 const struct side_arg_dynamic_event_field *fields;
8d20e708 486 const struct side_attr *attr;
465e5e7e 487 uint32_t len;
8d20e708 488 uint32_t nr_attr;
465e5e7e
MD		 489};
490
f611d0c3 491struct side_arg_vec {
1e8256c9 492 enum side_type type;
f611d0c3 493 union {
56c21987 494 /* Basic types */
5f82db91
MD		 495 uint8_t bool_value;
496 uint8_t byte_value;
497 uint64_t string_value; /* const char * */
498 union side_integer_value integer_value;
d37fe349 499 union side_float_value float_value;
e24949fa
MD		 500
501 /* Compound types */
f611d0c3
MD		 502 const struct side_arg_vec_description *side_struct;
503 const struct side_arg_vec_description *side_array;
504 const struct side_arg_vec_description *side_vla;
352a4b77 505 void *side_vla_app_visitor_ctx;
ba845af5 506 void *side_array_fixint;
1533629f
MD		 507 struct {
508 void *p;
509 uint32_t length;
510 } side_vla_fixint;
7a1cb105 511 void *side_struct_sg_ptr;
bdc39c09 512
e24949fa 513 /* Dynamic type */
5f82db91 514 struct side_arg_dynamic_vec dynamic_value;
f611d0c3
MD		 515 } u;
516};
517
518struct side_arg_vec_description {
519 const struct side_arg_vec *sav;
520 uint32_t len;
521};
522
352a4b77
MD		 523/* The visitor pattern is a double-dispatch visitor. */
524struct side_tracer_visitor_ctx {
f93e01ac
MD		 525 enum side_visitor_status (*write_elem)(
526 const struct side_tracer_visitor_ctx *tracer_ctx,
527 const struct side_arg_vec *elem);
352a4b77
MD		 528 void *priv; /* Private tracer context. */
529};
530
c208889e 531struct side_tracer_dynamic_struct_visitor_ctx {
f93e01ac
MD		 532 enum side_visitor_status (*write_field)(
533 const struct side_tracer_dynamic_struct_visitor_ctx *tracer_ctx,
2b359235 534 const struct side_arg_dynamic_event_field *dynamic_field);
bdc39c09
MD		 535 void *priv; /* Private tracer context. */
536};
537
538struct side_tracer_dynamic_vla_visitor_ctx {
f93e01ac
MD		 539 enum side_visitor_status (*write_elem)(
540 const struct side_tracer_dynamic_vla_visitor_ctx *tracer_ctx,
541 const struct side_arg_dynamic_vec *elem);
bdc39c09
MD		 542 void *priv; /* Private tracer context. */
543};
544
e24949fa
MD		 545/* Event and type attributes */
546
dd6e76cb
MD		 547#if SIDE_BITS_PER_LONG == 64
548# define SIDE_TYPE_POINTER_HOST SIDE_TYPE_POINTER64
549# define SIDE_TYPE_ARRAY_POINTER_HOST SIDE_TYPE_ARRAY_POINTER64
550# define SIDE_TYPE_VLA_POINTER_HOST SIDE_TYPE_VLA_POINTER64
551# define SIDE_DYNAMIC_TYPE_POINTER_HOST SIDE_DYNAMIC_TYPE_POINTER64
552# define SIDE_ATTR_TYPE_POINTER_HOST SIDE_ATTR_TYPE_POINTER64
35d25fc5 553# define SIDE_PTR_HOST .side_u64
dd6e76cb
MD		 554#else
555# define SIDE_TYPE_POINTER_HOST SIDE_TYPE_POINTER32
556# define SIDE_TYPE_ARRAY_POINTER_HOST SIDE_TYPE_ARRAY_POINTER32
557# define SIDE_TYPE_VLA_POINTER_HOST SIDE_TYPE_VLA_POINTER32
558# define SIDE_DYNAMIC_TYPE_POINTER_HOST SIDE_DYNAMIC_TYPE_POINTER32
559# define SIDE_ATTR_TYPE_POINTER_HOST SIDE_ATTR_TYPE_POINTER32
35d25fc5 560# define SIDE_PTR_HOST .side_u32
dd6e76cb
MD		 561#endif
562
65010f43
MD		 563#define side_attr(_key, _value) \
564 { \
565 .key = _key, \
bc3c89b3 566 .value = SIDE_PARAM(_value), \
65010f43
MD		 567 }
568
569#define side_attr_list(...) \
570 SIDE_COMPOUND_LITERAL(const struct side_attr, __VA_ARGS__)
571
e2c978ee 572#define side_attr_null(_val) { .type = SIDE_ATTR_TYPE_NULL }
5f82db91 573#define side_attr_bool(_val) { .type = SIDE_ATTR_TYPE_BOOL, .u = { .bool_value = !!(_val) } }
35d25fc5
MD		 574#define side_attr_u8(_val) { .type = SIDE_ATTR_TYPE_U8, .u = { .integer_value = { .side_u8 = (_val) } } }
575#define side_attr_u16(_val) { .type = SIDE_ATTR_TYPE_U16, .u = { .integer_value = { .side_u16 = (_val) } } }
576#define side_attr_u32(_val) { .type = SIDE_ATTR_TYPE_U32, .u = { .integer_value = { .side_u32 = (_val) } } }
577#define side_attr_u64(_val) { .type = SIDE_ATTR_TYPE_U64, .u = { .integer_value = { .side_u64 = (_val) } } }
578#define side_attr_s8(_val) { .type = SIDE_ATTR_TYPE_S8, .u = { .integer_value = { .side_s8 = (_val) } } }
579#define side_attr_s16(_val) { .type = SIDE_ATTR_TYPE_S16, .u = { .integer_value = { .side_s16 = (_val) } } }
580#define side_attr_s32(_val) { .type = SIDE_ATTR_TYPE_S32, .u = { .integer_value = { .side_s32 = (_val) } } }
581#define side_attr_s64(_val) { .type = SIDE_ATTR_TYPE_S64, .u = { .integer_value = { .side_s64 = (_val) } } }
582#define side_attr_pointer(_val) { .type = SIDE_ATTR_TYPE_POINTER_HOST, .u = { .integer_value = { SIDE_PTR_HOST = (uintptr_t) (_val) } } }
583#define side_attr_float_binary16(_val) { .type = SIDE_ATTR_TYPE_FLOAT_BINARY16, .u = { .float_value = { .side_float_binary16 = (_val) } } }
584#define side_attr_float_binary32(_val) { .type = SIDE_ATTR_TYPE_FLOAT_BINARY32, .u = { .float_value = { .side_float_binary32 = (_val) } } }
585#define side_attr_float_binary64(_val) { .type = SIDE_ATTR_TYPE_FLOAT_BINARY64, .u = { .float_value = { .side_float_binary64 = (_val) } } }
586#define side_attr_float_binary128(_val) { .type = SIDE_ATTR_TYPE_FLOAT_BINARY128, .u = { .float_value = { .side_float_binary128 = (_val) } } }
5f82db91 587#define side_attr_string(_val) { .type = SIDE_ATTR_TYPE_STRING, .u = { .string_value = (uintptr_t) (_val) } }
e24949fa
MD		 588
589/* Static field definition */
590
5f82db91 591#define side_type_bool(_attr) \
f37a556f 592 { \
5f82db91
MD		 593 .type = SIDE_TYPE_BOOL, \
594 .u = { \
595 .side_bool = { \
596 .attr = _attr, \
597 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
598 }, \
599 }, \
600 }
601
602#define side_type_byte(_attr) \
603 { \
604 .type = SIDE_TYPE_BYTE, \
d4328528 605 .u = { \
5f82db91
MD		 606 .side_byte = { \
607 .attr = _attr, \
608 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
609 }, \
610 }, \
611 }
612
613#define side_type_string(_attr) \
614 { \
615 .type = SIDE_TYPE_STRING, \
616 .u = { \
617 .side_string = { \
618 .attr = _attr, \
619 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
620 }, \
621 }, \
622 }
623
624#define side_type_dynamic(_attr) \
625 { \
626 .type = SIDE_TYPE_DYNAMIC, \
627 .u = { \
628 .side_dynamic = { \
d4328528
MD		 629 .attr = _attr, \
630 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
631 }, \
632 }, \
f37a556f 633 }
f93e01ac 634
56c21987
MD		 635#define _side_type_integer(_type, _signedness, _byte_order, _integer_size_bits, _len_bits, _attr) \
636 { \
637 .type = _type, \
638 .u = { \
639 .side_integer = { \
640 .attr = _attr, \
641 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
56c21987
MD		 642 .integer_size_bits = _integer_size_bits, \
643 .len_bits = _len_bits, \
984bcab7
MD		 644 .signedness = _signedness, \
645 .byte_order = _byte_order, \
56c21987
MD		 646 }, \
647 }, \
648 }
649
d44b44d1
MD		 650#define _side_type_float(_type, _byte_order, _float_size_bits, _attr) \
651 { \
652 .type = _type, \
653 .u = { \
654 .side_float = { \
655 .attr = _attr, \
656 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
657 .byte_order = _byte_order, \
658 .float_size_bits = _float_size_bits, \
659 }, \
660 }, \
661 }
662
cb6f04c2 663#define _side_field(_name, _type) \
f93e01ac
MD		 664 { \
665 .field_name = _name, \
cb6f04c2 666 .side_type = _type, \
f93e01ac 667 }
f611d0c3 668
8bdd5c12 669/* Host endian */
56c21987
MD		 670#define side_type_u8(_attr) _side_type_integer(SIDE_TYPE_U8, false, SIDE_TYPE_BYTE_ORDER_HOST, 8, 8, SIDE_PARAM(_attr))
671#define side_type_u16(_attr) _side_type_integer(SIDE_TYPE_U16, false, SIDE_TYPE_BYTE_ORDER_HOST, 16, 16, SIDE_PARAM(_attr))
672#define side_type_u32(_attr) _side_type_integer(SIDE_TYPE_U32, false, SIDE_TYPE_BYTE_ORDER_HOST, 32, 32, SIDE_PARAM(_attr))
673#define side_type_u64(_attr) _side_type_integer(SIDE_TYPE_U64, false, SIDE_TYPE_BYTE_ORDER_HOST, 64, 64, SIDE_PARAM(_attr))
674#define side_type_s8(_attr) _side_type_integer(SIDE_TYPE_S8, true, SIDE_TYPE_BYTE_ORDER_HOST, 8, 8, SIDE_PARAM(_attr))
675#define side_type_s16(_attr) _side_type_integer(SIDE_TYPE_S16, true, SIDE_TYPE_BYTE_ORDER_HOST, 16, 16, SIDE_PARAM(_attr))
676#define side_type_s32(_attr) _side_type_integer(SIDE_TYPE_S32, true, SIDE_TYPE_BYTE_ORDER_HOST, 32, 32, SIDE_PARAM(_attr))
677#define side_type_s64(_attr) _side_type_integer(SIDE_TYPE_S64, true, SIDE_TYPE_BYTE_ORDER_HOST, 64, 64, SIDE_PARAM(_attr))
3fa64a4c
MD		 678#define side_type_pointer(_attr) _side_type_integer(SIDE_TYPE_POINTER_HOST, false, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_BITS_PER_LONG, \
679 SIDE_BITS_PER_LONG, SIDE_PARAM(_attr))
d44b44d1
MD		 680#define side_type_float_binary16(_attr) _side_type_float(SIDE_TYPE_FLOAT_BINARY16, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, 16, SIDE_PARAM(_attr))
681#define side_type_float_binary32(_attr) _side_type_float(SIDE_TYPE_FLOAT_BINARY32, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, 32, SIDE_PARAM(_attr))
682#define side_type_float_binary64(_attr) _side_type_float(SIDE_TYPE_FLOAT_BINARY64, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, 64, SIDE_PARAM(_attr))
683#define side_type_float_binary128(_attr) _side_type_float(SIDE_TYPE_FLOAT_BINARY128, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, 128, SIDE_PARAM(_attr))
8bdd5c12 684
cb6f04c2
MD		 685#define side_field_bool(_name, _attr) _side_field(_name, side_type_bool(SIDE_PARAM(_attr)))
686#define side_field_u8(_name, _attr) _side_field(_name, side_type_u8(SIDE_PARAM(_attr)))
687#define side_field_u16(_name, _attr) _side_field(_name, side_type_u16(SIDE_PARAM(_attr)))
688#define side_field_u32(_name, _attr) _side_field(_name, side_type_u32(SIDE_PARAM(_attr)))
689#define side_field_u64(_name, _attr) _side_field(_name, side_type_u64(SIDE_PARAM(_attr)))
690#define side_field_s8(_name, _attr) _side_field(_name, side_type_s8(SIDE_PARAM(_attr)))
691#define side_field_s16(_name, _attr) _side_field(_name, side_type_s16(SIDE_PARAM(_attr)))
692#define side_field_s32(_name, _attr) _side_field(_name, side_type_s32(SIDE_PARAM(_attr)))
693#define side_field_s64(_name, _attr) _side_field(_name, side_type_s64(SIDE_PARAM(_attr)))
f7653b43 694#define side_field_byte(_name, _attr) _side_field(_name, side_type_byte(SIDE_PARAM(_attr)))
f5e650d7 695#define side_field_pointer(_name, _attr) _side_field(_name, side_type_pointer(SIDE_PARAM(_attr)))
cb6f04c2
MD		 696#define side_field_float_binary16(_name, _attr) _side_field(_name, side_type_float_binary16(SIDE_PARAM(_attr)))
697#define side_field_float_binary32(_name, _attr) _side_field(_name, side_type_float_binary32(SIDE_PARAM(_attr)))
698#define side_field_float_binary64(_name, _attr) _side_field(_name, side_type_float_binary64(SIDE_PARAM(_attr)))
699#define side_field_float_binary128(_name, _attr) _side_field(_name, side_type_float_binary128(SIDE_PARAM(_attr)))
700#define side_field_string(_name, _attr) _side_field(_name, side_type_string(SIDE_PARAM(_attr)))
701#define side_field_dynamic(_name, _attr) _side_field(_name, side_type_dynamic(SIDE_PARAM(_attr)))
485b800a 702
8bdd5c12 703/* Little endian */
56c21987
MD		 704#define side_type_u16_le(_attr) _side_type_integer(SIDE_TYPE_U16, false, SIDE_TYPE_BYTE_ORDER_LE, 16, 16, SIDE_PARAM(_attr))
705#define side_type_u32_le(_attr) _side_type_integer(SIDE_TYPE_U32, false, SIDE_TYPE_BYTE_ORDER_LE, 32, 32, SIDE_PARAM(_attr))
706#define side_type_u64_le(_attr) _side_type_integer(SIDE_TYPE_U64, false, SIDE_TYPE_BYTE_ORDER_LE, 64, 64, SIDE_PARAM(_attr))
707#define side_type_s16_le(_attr) _side_type_integer(SIDE_TYPE_S16, true, SIDE_TYPE_BYTE_ORDER_LE, 16, 16, SIDE_PARAM(_attr))
708#define side_type_s32_le(_attr) _side_type_integer(SIDE_TYPE_S32, true, SIDE_TYPE_BYTE_ORDER_LE, 32, 32, SIDE_PARAM(_attr))
709#define side_type_s64_le(_attr) _side_type_integer(SIDE_TYPE_S64, true, SIDE_TYPE_BYTE_ORDER_LE, 64, 64, SIDE_PARAM(_attr))
3fa64a4c
MD		 710#define side_type_pointer_le(_attr) _side_type_integer(SIDE_TYPE_POINTER_HOST, false, SIDE_TYPE_BYTE_ORDER_LE, SIDE_BITS_PER_LONG, \
711 SIDE_BITS_PER_LONG, SIDE_PARAM(_attr))
d44b44d1
MD		 712#define side_type_float_binary16_le(_attr) _side_type_float(SIDE_TYPE_FLOAT_BINARY16, SIDE_TYPE_BYTE_ORDER_LE, 16, SIDE_PARAM(_attr))
713#define side_type_float_binary32_le(_attr) _side_type_float(SIDE_TYPE_FLOAT_BINARY32, SIDE_TYPE_BYTE_ORDER_LE, 32, SIDE_PARAM(_attr))
714#define side_type_float_binary64_le(_attr) _side_type_float(SIDE_TYPE_FLOAT_BINARY64, SIDE_TYPE_BYTE_ORDER_LE, 64, SIDE_PARAM(_attr))
715#define side_type_float_binary128_le(_attr) _side_type_float(SIDE_TYPE_FLOAT_BINARY128, SIDE_TYPE_BYTE_ORDER_LE, 128, SIDE_PARAM(_attr))
8bdd5c12
MD		 716
717#define side_field_u16_le(_name, _attr) _side_field(_name, side_type_u16_le(SIDE_PARAM(_attr)))
718#define side_field_u32_le(_name, _attr) _side_field(_name, side_type_u32_le(SIDE_PARAM(_attr)))
719#define side_field_u64_le(_name, _attr) _side_field(_name, side_type_u64_le(SIDE_PARAM(_attr)))
720#define side_field_s16_le(_name, _attr) _side_field(_name, side_type_s16_le(SIDE_PARAM(_attr)))
721#define side_field_s32_le(_name, _attr) _side_field(_name, side_type_s32_le(SIDE_PARAM(_attr)))
722#define side_field_s64_le(_name, _attr) _side_field(_name, side_type_s64_le(SIDE_PARAM(_attr)))
f5e650d7 723#define side_field_pointer_le(_name, _attr) _side_field(_name, side_type_pointer_le(SIDE_PARAM(_attr)))
8bdd5c12
MD		 724#define side_field_float_binary16_le(_name, _attr) _side_field(_name, side_type_float_binary16_le(SIDE_PARAM(_attr)))
725#define side_field_float_binary32_le(_name, _attr) _side_field(_name, side_type_float_binary32_le(SIDE_PARAM(_attr)))
726#define side_field_float_binary64_le(_name, _attr) _side_field(_name, side_type_float_binary64_le(SIDE_PARAM(_attr)))
727#define side_field_float_binary128_le(_name, _attr) _side_field(_name, side_type_float_binary128_le(SIDE_PARAM(_attr)))
728
729/* Big endian */
56c21987
MD		 730#define side_type_u16_be(_attr) _side_type_integer(SIDE_TYPE_U16, false, SIDE_TYPE_BYTE_ORDER_BE, 16, 16, SIDE_PARAM(_attr))
731#define side_type_u32_be(_attr) _side_type_integer(SIDE_TYPE_U32, false, SIDE_TYPE_BYTE_ORDER_BE, 32, 32, SIDE_PARAM(_attr))
732#define side_type_u64_be(_attr) _side_type_integer(SIDE_TYPE_U64, false, SIDE_TYPE_BYTE_ORDER_BE, 64, 64, SIDE_PARAM(_attr))
733#define side_type_s16_be(_attr) _side_type_integer(SIDE_TYPE_S16, false, SIDE_TYPE_BYTE_ORDER_BE, 16, 16, SIDE_PARAM(_attr))
734#define side_type_s32_be(_attr) _side_type_integer(SIDE_TYPE_S32, false, SIDE_TYPE_BYTE_ORDER_BE, 32, 32, SIDE_PARAM(_attr))
735#define side_type_s64_be(_attr) _side_type_integer(SIDE_TYPE_S64, false, SIDE_TYPE_BYTE_ORDER_BE, 64, 64, SIDE_PARAM(_attr))
3fa64a4c
MD		 736#define side_type_pointer_be(_attr) _side_type_integer(SIDE_TYPE_POINTER_HOST, false, SIDE_TYPE_BYTE_ORDER_BE, SIDE_BITS_PER_LONG, \
737 SIDE_BITS_PER_LONG, SIDE_PARAM(_attr))
d44b44d1
MD		 738#define side_type_float_binary16_be(_attr) _side_type_float(SIDE_TYPE_FLOAT_BINARY16, SIDE_TYPE_BYTE_ORDER_BE, 16, SIDE_PARAM(_attr))
739#define side_type_float_binary32_be(_attr) _side_type_float(SIDE_TYPE_FLOAT_BINARY32, SIDE_TYPE_BYTE_ORDER_BE, 32, SIDE_PARAM(_attr))
740#define side_type_float_binary64_be(_attr) _side_type_float(SIDE_TYPE_FLOAT_BINARY64, SIDE_TYPE_BYTE_ORDER_BE, 64, SIDE_PARAM(_attr))
741#define side_type_float_binary128_be(_attr) _side_type_float(SIDE_TYPE_FLOAT_BINARY128, SIDE_TYPE_BYTE_ORDER_BE, 128, SIDE_PARAM(_attr))
8bdd5c12
MD		 742
743#define side_field_u16_be(_name, _attr) _side_field(_name, side_type_u16_be(SIDE_PARAM(_attr)))
744#define side_field_u32_be(_name, _attr) _side_field(_name, side_type_u32_be(SIDE_PARAM(_attr)))
745#define side_field_u64_be(_name, _attr) _side_field(_name, side_type_u64_be(SIDE_PARAM(_attr)))
746#define side_field_s16_be(_name, _attr) _side_field(_name, side_type_s16_be(SIDE_PARAM(_attr)))
747#define side_field_s32_be(_name, _attr) _side_field(_name, side_type_s32_be(SIDE_PARAM(_attr)))
748#define side_field_s64_be(_name, _attr) _side_field(_name, side_type_s64_be(SIDE_PARAM(_attr)))
f5e650d7 749#define side_field_pointer_be(_name, _attr) _side_field(_name, side_type_pointer_be(SIDE_PARAM(_attr)))
8bdd5c12
MD		 750#define side_field_float_binary16_be(_name, _attr) _side_field(_name, side_type_float_binary16_be(SIDE_PARAM(_attr)))
751#define side_field_float_binary32_be(_name, _attr) _side_field(_name, side_type_float_binary32_be(SIDE_PARAM(_attr)))
752#define side_field_float_binary64_be(_name, _attr) _side_field(_name, side_type_float_binary64_be(SIDE_PARAM(_attr)))
753#define side_field_float_binary128_be(_name, _attr) _side_field(_name, side_type_float_binary128_be(SIDE_PARAM(_attr)))
754
f89c4ad1 755#define side_type_enum(_mappings, _elem_type) \
79f677ba 756 { \
d8be25de 757 .type = SIDE_TYPE_ENUM, \
79f677ba 758 .u = { \
d8be25de 759 .side_enum = { \
d8be25de 760 .mappings = _mappings, \
f89c4ad1 761 .elem_type = _elem_type, \
d8be25de 762 }, \
79f677ba
MD		 763 }, \
764 }
f89c4ad1
MD		 765#define side_field_enum(_name, _mappings, _elem_type) \
766 _side_field(_name, side_type_enum(SIDE_PARAM(_mappings), SIDE_PARAM(_elem_type)))
d4328528 767
f89c4ad1 768#define side_type_enum_bitmap(_mappings, _elem_type) \
af6aa6e1 769 { \
bab5d6e4 770 .type = SIDE_TYPE_ENUM_BITMAP, \
af6aa6e1 771 .u = { \
bab5d6e4 772 .side_enum_bitmap = { \
af6aa6e1 773 .mappings = _mappings, \
f89c4ad1 774 .elem_type = _elem_type, \
af6aa6e1
MD		 775 }, \
776 }, \
777 }
f89c4ad1
MD		 778#define side_field_enum_bitmap(_name, _mappings, _elem_type) \
779 _side_field(_name, side_type_enum_bitmap(SIDE_PARAM(_mappings), SIDE_PARAM(_elem_type)))
66cff328 780
c7a14585 781#define side_type_struct(_struct) \
f611d0c3
MD		 782 { \
783 .type = SIDE_TYPE_STRUCT, \
784 .u = { \
c7a14585 785 .side_struct = _struct, \
f611d0c3
MD		 786 }, \
787 }
c7a14585
MD		 788#define side_field_struct(_name, _struct) \
789 _side_field(_name, side_type_struct(SIDE_PARAM(_struct)))
790
791#define _side_type_struct_define(_fields, _attr) \
792 { \
793 .nr_fields = SIDE_ARRAY_SIZE(SIDE_PARAM(_fields)), \
794 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
795 .fields = _fields, \
796 .attr = _attr, \
797 }
798
799#define side_define_struct(_identifier, _fields, _attr) \
800 const struct side_type_struct _identifier = _side_type_struct_define(SIDE_PARAM(_fields), SIDE_PARAM(_attr))
801
802#define side_struct_literal(_fields, _attr) \
803 SIDE_COMPOUND_LITERAL(const struct side_type_struct, \
804 _side_type_struct_define(SIDE_PARAM(_fields), SIDE_PARAM(_attr)))
f611d0c3 805
7a1cb105
MD		 806/* Scatter-gather struct */
807
87405d12 808#define _side_type_sg_integer(_type, _signedness, _byte_order, _offset, _integer_size_bits, _offset_bits, _len_bits, _attr) \
7a1cb105 809 { \
87405d12 810 .offset = _offset, \
7a1cb105
MD		 811 .type = _type, \
812 .u = { \
87405d12
MD		 813 .side_integer = { \
814 .type = { \
815 .attr = _attr, \
816 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
817 .integer_size_bits = _integer_size_bits, \
818 .len_bits = _len_bits, \
819 .signedness = _signedness, \
820 .byte_order = _byte_order, \
821 }, \
7a1cb105 822 .offset_bits = _offset_bits, \
7a1cb105
MD		 823 }, \
824 }, \
825 }
826
827#define _side_field_sg(_name, _type) \
828 { \
829 .field_name = _name, \
830 .side_type = _type, \
831 }
832
833#define side_type_sg_unsigned_integer(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _attr) \
87405d12 834 _side_type_sg_integer(SIDE_TYPE_SG_UNSIGNED_INT, false, SIDE_TYPE_BYTE_ORDER_HOST, \
7a1cb105
MD		 835 _integer_offset, _integer_size_bits, _offset_bits, _len_bits, SIDE_PARAM(_attr))
836#define side_type_sg_signed_integer(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _attr) \
87405d12 837 _side_type_sg_integer(SIDE_TYPE_SG_SIGNED_INT, true, SIDE_TYPE_BYTE_ORDER_HOST, \
7a1cb105
MD		 838 _integer_offset, _integer_size_bits, _offset_bits, _len_bits, SIDE_PARAM(_attr))
839
840#define side_field_sg_unsigned_integer(_name, _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _attr) \
841 _side_field_sg(_name, side_type_sg_unsigned_integer(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, SIDE_PARAM(_attr)))
842#define side_field_sg_signed_integer(_name, _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _attr) \
843 _side_field_sg(_name, side_type_sg_signed_integer(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, SIDE_PARAM(_attr)))
844
845#define side_type_struct_sg(_struct_sg) \
846 { \
847 .type = SIDE_TYPE_STRUCT_SG, \
848 .u = { \
849 .side_struct_sg = _struct_sg, \
850 }, \
851 }
852#define side_field_struct_sg(_name, _struct_sg) \
853 _side_field(_name, side_type_struct_sg(SIDE_PARAM(_struct_sg)))
854
855#define _side_type_struct_sg_define(_fields_sg, _attr) \
856 { \
857 .nr_fields = SIDE_ARRAY_SIZE(SIDE_PARAM(_fields_sg)), \
858 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
859 .fields_sg = _fields_sg, \
860 .attr = _attr, \
861 }
862
863#define side_define_struct_sg(_identifier, _fields_sg, _attr) \
864 const struct side_type_struct_sg _identifier = _side_type_struct_sg_define(SIDE_PARAM(_fields_sg), SIDE_PARAM(_attr))
865
866#define side_struct_sg_literal(_fields_sg, _attr) \
867 SIDE_COMPOUND_LITERAL(const struct side_type_struct_sg, \
868 _side_type_struct_sg_define(SIDE_PARAM(_fields_sg), SIDE_PARAM(_attr)))
869
32ba58fc 870#define side_type_array(_elem_type, _length, _attr) \
f611d0c3
MD		 871 { \
872 .type = SIDE_TYPE_ARRAY, \
873 .u = { \
874 .side_array = { \
f611d0c3 875 .elem_type = _elem_type, \
d4328528
MD		 876 .attr = _attr, \
877 .length = _length, \
878 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
f611d0c3
MD		 879 }, \
880 }, \
881 }
f37a556f 882#define side_field_array(_name, _elem_type, _length, _attr) \
be14d73f 883 _side_field(_name, side_type_array(SIDE_PARAM(_elem_type), _length, SIDE_PARAM(_attr)))
f611d0c3 884
32ba58fc 885#define side_type_vla(_elem_type, _attr) \
f611d0c3
MD		 886 { \
887 .type = SIDE_TYPE_VLA, \
888 .u = { \
889 .side_vla = { \
890 .elem_type = _elem_type, \
d4328528
MD		 891 .attr = _attr, \
892 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
f611d0c3
MD		 893 }, \
894 }, \
895 }
f37a556f 896#define side_field_vla(_name, _elem_type, _attr) \
be14d73f 897 _side_field(_name, side_type_vla(SIDE_PARAM(_elem_type), SIDE_PARAM(_attr)))
f611d0c3 898
32ba58fc 899#define side_type_vla_visitor(_elem_type, _visitor, _attr) \
f611d0c3
MD		 900 { \
901 .type = SIDE_TYPE_VLA_VISITOR, \
902 .u = { \
903 .side_vla_visitor = { \
cdd6e858 904 .elem_type = SIDE_PARAM(_elem_type), \
352a4b77 905 .visitor = _visitor, \
d4328528
MD		 906 .attr = _attr, \
907 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
f611d0c3
MD		 908 }, \
909 }, \
910 }
f37a556f 911#define side_field_vla_visitor(_name, _elem_type, _visitor, _attr) \
be14d73f 912 _side_field(_name, side_type_vla_visitor(SIDE_PARAM(_elem_type), _visitor, SIDE_PARAM(_attr)))
f611d0c3 913
71002b5e 914#define side_elem(...) \
cdd6e858
MD		 915 SIDE_COMPOUND_LITERAL(const struct side_type_description, __VA_ARGS__)
916
f611d0c3
MD		 917#define side_field_list(...) \
918 SIDE_COMPOUND_LITERAL(const struct side_event_field, __VA_ARGS__)
919
7a1cb105
MD		 920#define side_field_sg_list(...) \
921 SIDE_COMPOUND_LITERAL(const struct side_struct_field_sg, __VA_ARGS__)
922
e24949fa
MD		 923/* Static field arguments */
924
5f82db91
MD		 925#define side_arg_bool(_val) { .type = SIDE_TYPE_BOOL, .u = { .bool_value = !!(_val) } }
926#define side_arg_byte(_val) { .type = SIDE_TYPE_BYTE, .u = { .byte_value = (_val) } }
927#define side_arg_string(_val) { .type = SIDE_TYPE_STRING, .u = { .string_value = (uintptr_t) (_val) } }
928#define side_arg_dynamic(_dynamic_arg_type) { .type = SIDE_TYPE_DYNAMIC, .u = { .dynamic_value = _dynamic_arg_type } }
929
35d25fc5
MD		 930#define side_arg_u8(_val) { .type = SIDE_TYPE_U8, .u = { .integer_value = { .side_u8 = (_val) } } }
931#define side_arg_u16(_val) { .type = SIDE_TYPE_U16, .u = { .integer_value = { .side_u16 = (_val) } } }
932#define side_arg_u32(_val) { .type = SIDE_TYPE_U32, .u = { .integer_value = { .side_u32 = (_val) } } }
933#define side_arg_u64(_val) { .type = SIDE_TYPE_U64, .u = { .integer_value = { .side_u64 = (_val) } } }
934#define side_arg_s8(_val) { .type = SIDE_TYPE_S8, .u = { .integer_value = { .side_s8 = (_val) } } }
935#define side_arg_s16(_val) { .type = SIDE_TYPE_S16, .u = { .integer_value = { .side_s16 = (_val) } } }
936#define side_arg_s32(_val) { .type = SIDE_TYPE_S32, .u = { .integer_value = { .side_s32 = (_val) } } }
937#define side_arg_s64(_val) { .type = SIDE_TYPE_S64, .u = { .integer_value = { .side_s64 = (_val) } } }
35d25fc5
MD		 938#define side_arg_pointer(_val) { .type = SIDE_TYPE_POINTER_HOST, .u = { .integer_value = { SIDE_PTR_HOST = (uintptr_t) (_val) } } }
939#define side_arg_enum_bitmap8(_val) { .type = SIDE_TYPE_ENUM_BITMAP8, .u = { .integer_value = { .side_u8 = (_val) } } }
940#define side_arg_enum_bitmap16(_val) { .type = SIDE_TYPE_ENUM_BITMAP16, .u = { .integer_value = { .side_u16 = (_val) } } }
941#define side_arg_enum_bitmap32(_val) { .type = SIDE_TYPE_ENUM_BITMAP32, .u = { .integer_value = { .side_u32 = (_val) } } }
942#define side_arg_enum_bitmap64(_val) { .type = SIDE_TYPE_ENUM_BITMAP64, .u = { .integer_value = { .side_u64 = (_val) } } }
af6aa6e1
MD		 943#define side_arg_enum_bitmap_array(_side_type) { .type = SIDE_TYPE_ENUM_BITMAP_ARRAY, .u = { .side_array = (_side_type) } }
944#define side_arg_enum_bitmap_vla(_side_type) { .type = SIDE_TYPE_ENUM_BITMAP_VLA, .u = { .side_vla = (_side_type) } }
35d25fc5
MD		 945#define side_arg_float_binary16(_val) { .type = SIDE_TYPE_FLOAT_BINARY16, .u = { .float_value = { .side_float_binary16 = (_val) } } }
946#define side_arg_float_binary32(_val) { .type = SIDE_TYPE_FLOAT_BINARY32, .u = { .float_value = { .side_float_binary32 = (_val) } } }
947#define side_arg_float_binary64(_val) { .type = SIDE_TYPE_FLOAT_BINARY64, .u = { .float_value = { .side_float_binary64 = (_val) } } }
948#define side_arg_float_binary128(_val) { .type = SIDE_TYPE_FLOAT_BINARY128, .u = { .float_value = { .side_float_binary128 = (_val) } } }
e24949fa 949
f611d0c3 950#define side_arg_struct(_side_type) { .type = SIDE_TYPE_STRUCT, .u = { .side_struct = (_side_type) } }
7a1cb105 951#define side_arg_struct_sg(_ptr) { .type = SIDE_TYPE_STRUCT_SG, .u = { .side_struct_sg_ptr = (_ptr) } }
f611d0c3
MD		 952#define side_arg_array(_side_type) { .type = SIDE_TYPE_ARRAY, .u = { .side_array = (_side_type) } }
953#define side_arg_vla(_side_type) { .type = SIDE_TYPE_VLA, .u = { .side_vla = (_side_type) } }
352a4b77 954#define side_arg_vla_visitor(_ctx) { .type = SIDE_TYPE_VLA_VISITOR, .u = { .side_vla_app_visitor_ctx = (_ctx) } }
f611d0c3 955
1533629f
MD		 956#define side_arg_array_u8(_ptr) { .type = SIDE_TYPE_ARRAY_U8, .u = { .side_array_fixint = (_ptr) } }
957#define side_arg_array_u16(_ptr) { .type = SIDE_TYPE_ARRAY_U16, .u = { .side_array_fixint = (_ptr) } }
958#define side_arg_array_u32(_ptr) { .type = SIDE_TYPE_ARRAY_U32, .u = { .side_array_fixint = (_ptr) } }
959#define side_arg_array_u64(_ptr) { .type = SIDE_TYPE_ARRAY_U64, .u = { .side_array_fixint = (_ptr) } }
960#define side_arg_array_s8(_ptr) { .type = SIDE_TYPE_ARRAY_S8, .u = { .side_array_fixint = (_ptr) } }
961#define side_arg_array_s16(_ptr) { .type = SIDE_TYPE_ARRAY_S16, .u = { .side_array_fixint = (_ptr) } }
962#define side_arg_array_s32(_ptr) { .type = SIDE_TYPE_ARRAY_S32, .u = { .side_array_fixint = (_ptr) } }
963#define side_arg_array_s64(_ptr) { .type = SIDE_TYPE_ARRAY_S64, .u = { .side_array_fixint = (_ptr) } }
f7653b43 964#define side_arg_array_byte(_ptr) { .type = SIDE_TYPE_ARRAY_BYTE, .u = { .side_array_fixint = (_ptr) } }
dd6e76cb 965#define side_arg_array_pointer(_ptr) { .type = SIDE_TYPE_ARRAY_POINTER_HOST, .u = { .side_array_fixint = (_ptr) } }
1533629f
MD		 966
967#define side_arg_vla_u8(_ptr, _length) { .type = SIDE_TYPE_VLA_U8, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } }
968#define side_arg_vla_u16(_ptr, _length) { .type = SIDE_TYPE_VLA_U16, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
969#define side_arg_vla_u32(_ptr, _length) { .type = SIDE_TYPE_VLA_U32, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
970#define side_arg_vla_u64(_ptr, _length) { .type = SIDE_TYPE_VLA_U64, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
971#define side_arg_vla_s8(_ptr, _length) { .type = SIDE_TYPE_VLA_S8, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
972#define side_arg_vla_s16(_ptr, _length) { .type = SIDE_TYPE_VLA_S16, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
973#define side_arg_vla_s32(_ptr, _length) { .type = SIDE_TYPE_VLA_S32, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
974#define side_arg_vla_s64(_ptr, _length) { .type = SIDE_TYPE_VLA_S64, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
f7653b43 975#define side_arg_vla_byte(_ptr, _length) { .type = SIDE_TYPE_VLA_BYTE, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
dd6e76cb 976#define side_arg_vla_pointer(_ptr, _length) { .type = SIDE_TYPE_VLA_POINTER_HOST, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
ba845af5 977
e24949fa
MD		 978/* Dynamic field arguments */
979
808bd9bf
MD		 980#define side_arg_dynamic_null(_attr) \
981 { \
982 .dynamic_type = SIDE_DYNAMIC_TYPE_NULL, \
8d20e708 983 .u = { \
5f82db91 984 .side_null_type = { \
8d20e708
MD		 985 .attr = _attr, \
986 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
987 }, \
988 }, \
808bd9bf
MD		 989 }
990
991#define side_arg_dynamic_bool(_val, _attr) \
992 { \
993 .dynamic_type = SIDE_DYNAMIC_TYPE_BOOL, \
808bd9bf 994 .u = { \
5f82db91
MD		 995 .side_bool = { \
996 .type = { \
997 .attr = _attr, \
998 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
8d20e708 999 }, \
5f82db91 1000 .value = !!(_val), \
8d20e708 1001 }, \
808bd9bf
MD		 1002 }, \
1003 }
1004
8bdd5c12 1005#define side_arg_dynamic_byte(_val, _attr) \
808bd9bf 1006 { \
8bdd5c12 1007 .dynamic_type = SIDE_DYNAMIC_TYPE_BYTE, \
808bd9bf 1008 .u = { \
5f82db91
MD		 1009 .side_byte = { \
1010 .type = { \
1011 .attr = _attr, \
1012 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
8d20e708 1013 }, \
5f82db91 1014 .value = (_val), \
8d20e708 1015 }, \
808bd9bf
MD		 1016 }, \
1017 }
8bdd5c12 1018#define side_arg_dynamic_string(_val, _attr) \
808bd9bf 1019 { \
8bdd5c12 1020 .dynamic_type = SIDE_DYNAMIC_TYPE_STRING, \
808bd9bf 1021 .u = { \
5f82db91
MD		 1022 .side_string = { \
1023 .type = { \
1024 .attr = _attr, \
1025 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
8d20e708 1026 }, \
5f82db91 1027 .value = (uintptr_t) (_val), \
8d20e708 1028 }, \
808bd9bf
MD		 1029 }, \
1030 }
1031
d2be7696 1032#define _side_arg_dynamic_integer(_field, _val, _type, _signedness, _byte_order, _integer_size_bits, _len_bits, _attr) \
808bd9bf 1033 { \
d2be7696 1034 .dynamic_type = _type, \
808bd9bf 1035 .u = { \
d2be7696
MD		 1036 .side_integer = { \
1037 .type = { \
1038 .attr = _attr, \
1039 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
1040 .integer_size_bits = _integer_size_bits, \
1041 .len_bits = _len_bits, \
1042 .signedness = _signedness, \
1043 .byte_order = _byte_order, \
8d20e708 1044 }, \
d2be7696
MD		 1045 .value = { \
1046 _field = (_val), \
8d20e708
MD		 1047 }, \
1048 }, \
808bd9bf
MD		 1049 }, \
1050 }
d2be7696
MD		 1051
1052#define side_arg_dynamic_u8(_val, _attr) \
1053 _side_arg_dynamic_integer(.side_u8, _val, SIDE_DYNAMIC_TYPE_U8, false, SIDE_TYPE_BYTE_ORDER_HOST, 8, 8, SIDE_PARAM(_attr))
1054#define side_arg_dynamic_s8(_val, _attr) \
1055 _side_arg_dynamic_integer(.side_s8, _val, SIDE_DYNAMIC_TYPE_S8, true, SIDE_TYPE_BYTE_ORDER_HOST, 8, 8, SIDE_PARAM(_attr))
1056
1057#define _side_arg_dynamic_u16(_val, _byte_order, _attr) \
1058 _side_arg_dynamic_integer(.side_u16, _val, SIDE_DYNAMIC_TYPE_U16, false, _byte_order, 16, 16, SIDE_PARAM(_attr))
1059#define _side_arg_dynamic_u32(_val, _byte_order, _attr) \
1060 _side_arg_dynamic_integer(.side_u32, _val, SIDE_DYNAMIC_TYPE_U32, false, _byte_order, 32, 32, SIDE_PARAM(_attr))
8bdd5c12 1061#define _side_arg_dynamic_u64(_val, _byte_order, _attr) \
d2be7696 1062 _side_arg_dynamic_integer(.side_u64, _val, SIDE_DYNAMIC_TYPE_U64, false, _byte_order, 64, 64, SIDE_PARAM(_attr))
8bdd5c12
MD		 1063
1064#define _side_arg_dynamic_s16(_val, _byte_order, _attr) \
d2be7696 1065 _side_arg_dynamic_integer(.side_s16, _val, SIDE_DYNAMIC_TYPE_S16, true, _byte_order, 16, 16, SIDE_PARAM(_attr))
8bdd5c12 1066#define _side_arg_dynamic_s32(_val, _byte_order, _attr) \
d2be7696 1067 _side_arg_dynamic_integer(.side_s32, _val, SIDE_DYNAMIC_TYPE_S32, true, _byte_order, 32, 32, SIDE_PARAM(_attr))
8bdd5c12 1068#define _side_arg_dynamic_s64(_val, _byte_order, _attr) \
d2be7696
MD		 1069 _side_arg_dynamic_integer(.side_s64, _val, SIDE_DYNAMIC_TYPE_S64, true, _byte_order, 64, 64, SIDE_PARAM(_attr))
1070
f5e650d7 1071#define _side_arg_dynamic_pointer(_val, _byte_order, _attr) \
d2be7696
MD		 1072 _side_arg_dynamic_integer(SIDE_PTR_HOST, (uintptr_t) (_val), SIDE_DYNAMIC_TYPE_POINTER_HOST, false, _byte_order, \
1073 SIDE_BITS_PER_LONG, SIDE_BITS_PER_LONG, SIDE_PARAM(_attr))
1074
aac52685 1075#define _side_arg_dynamic_float(_field, _val, _type, _byte_order, _float_size_bits, _attr) \
fb25b355 1076 { \
aac52685 1077 .dynamic_type = _type, \
fb25b355 1078 .u = { \
aac52685
MD		 1079 .side_float = { \
1080 .type = { \
1081 .attr = _attr, \
1082 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
1083 .byte_order = _byte_order, \
1084 .float_size_bits = _float_size_bits, \
8d20e708 1085 }, \
aac52685
MD		 1086 .value = { \
1087 _field = (_val), \
8d20e708
MD		 1088 }, \
1089 }, \
fb25b355
MD		 1090 }, \
1091 }
aac52685
MD		 1092
1093#define _side_arg_dynamic_float_binary16(_val, _byte_order, _attr) \
1094 _side_arg_dynamic_float(.side_float_binary16, _val, SIDE_DYNAMIC_TYPE_FLOAT_BINARY16, _byte_order, 16, SIDE_PARAM(_attr))
1095#define _side_arg_dynamic_float_binary32(_val, _byte_order, _attr) \
1096 _side_arg_dynamic_float(.side_float_binary32, _val, SIDE_DYNAMIC_TYPE_FLOAT_BINARY32, _byte_order, 32, SIDE_PARAM(_attr))
8bdd5c12 1097#define _side_arg_dynamic_float_binary64(_val, _byte_order, _attr) \
aac52685 1098 _side_arg_dynamic_float(.side_float_binary64, _val, SIDE_DYNAMIC_TYPE_FLOAT_BINARY64, _byte_order, 64, SIDE_PARAM(_attr))
8bdd5c12 1099#define _side_arg_dynamic_float_binary128(_val, _byte_order, _attr) \
aac52685 1100 _side_arg_dynamic_float(.side_float_binary128, _val, SIDE_DYNAMIC_TYPE_FLOAT_BINARY128, _byte_order, 128, SIDE_PARAM(_attr))
808bd9bf 1101
8bdd5c12
MD		 1102/* Host endian */
1103#define side_arg_dynamic_u16(_val, _attr) _side_arg_dynamic_u16(_val, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
1104#define side_arg_dynamic_u32(_val, _attr) _side_arg_dynamic_u32(_val, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
1105#define side_arg_dynamic_u64(_val, _attr) _side_arg_dynamic_u64(_val, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
1106#define side_arg_dynamic_s16(_val, _attr) _side_arg_dynamic_s16(_val, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
1107#define side_arg_dynamic_s32(_val, _attr) _side_arg_dynamic_s32(_val, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
1108#define side_arg_dynamic_s64(_val, _attr) _side_arg_dynamic_s64(_val, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
f5e650d7 1109#define side_arg_dynamic_pointer(_val, _attr) _side_arg_dynamic_pointer(_val, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
8bdd5c12
MD		 1110#define side_arg_dynamic_float_binary16(_val, _attr) _side_arg_dynamic_float_binary16(_val, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, SIDE_PARAM(_attr))
1111#define side_arg_dynamic_float_binary32(_val, _attr) _side_arg_dynamic_float_binary32(_val, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, SIDE_PARAM(_attr))
1112#define side_arg_dynamic_float_binary64(_val, _attr) _side_arg_dynamic_float_binary64(_val, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, SIDE_PARAM(_attr))
1113#define side_arg_dynamic_float_binary128(_val, _attr) _side_arg_dynamic_float_binary128(_val, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, SIDE_PARAM(_attr))
1114
1115/* Little endian */
1116#define side_arg_dynamic_u16_le(_val, _attr) _side_arg_dynamic_u16(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
1117#define side_arg_dynamic_u32_le(_val, _attr) _side_arg_dynamic_u32(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
1118#define side_arg_dynamic_u64_le(_val, _attr) _side_arg_dynamic_u64(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
1119#define side_arg_dynamic_s16_le(_val, _attr) _side_arg_dynamic_s16(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
1120#define side_arg_dynamic_s32_le(_val, _attr) _side_arg_dynamic_s32(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
1121#define side_arg_dynamic_s64_le(_val, _attr) _side_arg_dynamic_s64(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
f5e650d7 1122#define side_arg_dynamic_pointer_le(_val, _attr) _side_arg_dynamic_pointer(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
8bdd5c12
MD		 1123#define side_arg_dynamic_float_binary16_le(_val, _attr) _side_arg_dynamic_float_binary16(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
1124#define side_arg_dynamic_float_binary32_le(_val, _attr) _side_arg_dynamic_float_binary32(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
1125#define side_arg_dynamic_float_binary64_le(_val, _attr) _side_arg_dynamic_float_binary64(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
1126#define side_arg_dynamic_float_binary128_le(_val, _attr) _side_arg_dynamic_float_binary128(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
1127
1128/* Big endian */
1129#define side_arg_dynamic_u16_be(_val, _attr) _side_arg_dynamic_u16(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
1130#define side_arg_dynamic_u32_be(_val, _attr) _side_arg_dynamic_u32(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
1131#define side_arg_dynamic_u64_be(_val, _attr) _side_arg_dynamic_u64(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
1132#define side_arg_dynamic_s16_be(_val, _attr) _side_arg_dynamic_s16(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
1133#define side_arg_dynamic_s32_be(_val, _attr) _side_arg_dynamic_s32(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
1134#define side_arg_dynamic_s64_be(_val, _attr) _side_arg_dynamic_s64(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
f5e650d7 1135#define side_arg_dynamic_pointer_be(_val, _attr) _side_arg_dynamic_pointer(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
8bdd5c12
MD		 1136#define side_arg_dynamic_float_binary16_be(_val, _attr) _side_arg_dynamic_float_binary16(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
1137#define side_arg_dynamic_float_binary32_be(_val, _attr) _side_arg_dynamic_float_binary32(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
1138#define side_arg_dynamic_float_binary64_be(_val, _attr) _side_arg_dynamic_float_binary64(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
1139#define side_arg_dynamic_float_binary128_be(_val, _attr) _side_arg_dynamic_float_binary128(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
1140
8d20e708 1141#define side_arg_dynamic_vla(_vla) \
808bd9bf
MD		 1142 { \
1143 .dynamic_type = SIDE_DYNAMIC_TYPE_VLA, \
808bd9bf
MD		 1144 .u = { \
1145 .side_dynamic_vla = (_vla), \
1146 }, \
1147 }
1148
1149#define side_arg_dynamic_vla_visitor(_dynamic_vla_visitor, _ctx, _attr) \
bdc39c09 1150 { \
1e8256c9 1151 .dynamic_type = SIDE_DYNAMIC_TYPE_VLA_VISITOR, \
bdc39c09 1152 .u = { \
8ceca0cd
MD		 1153 .side_dynamic_vla_visitor = { \
1154 .app_ctx = _ctx, \
1155 .visitor = _dynamic_vla_visitor, \
8d20e708
MD		 1156 .attr = _attr, \
1157 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
8ceca0cd 1158 }, \
bdc39c09
MD		 1159 }, \
1160 }
1161
8d20e708 1162#define side_arg_dynamic_struct(_struct) \
808bd9bf
MD		 1163 { \
1164 .dynamic_type = SIDE_DYNAMIC_TYPE_STRUCT, \
808bd9bf
MD		 1165 .u = { \
1166 .side_dynamic_struct = (_struct), \
1167 }, \
1168 }
1169
1170#define side_arg_dynamic_struct_visitor(_dynamic_struct_visitor, _ctx, _attr) \
bdc39c09 1171 { \
1e8256c9 1172 .dynamic_type = SIDE_DYNAMIC_TYPE_STRUCT_VISITOR, \
bdc39c09 1173 .u = { \
8ceca0cd
MD		 1174 .side_dynamic_struct_visitor = { \
1175 .app_ctx = _ctx, \
1176 .visitor = _dynamic_struct_visitor, \
8d20e708
MD		 1177 .attr = _attr, \
1178 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
8ceca0cd 1179 }, \
bdc39c09
MD		 1180 }, \
1181 }
1182
8d20e708 1183#define side_arg_dynamic_define_vec(_identifier, _sav, _attr) \
a2e2357e
MD		 1184 const struct side_arg_dynamic_vec _identifier##_vec[] = { _sav }; \
1185 const struct side_arg_dynamic_vec_vla _identifier = { \
1186 .sav = _identifier##_vec, \
8d20e708 1187 .attr = _attr, \
a2e2357e 1188 .len = SIDE_ARRAY_SIZE(_identifier##_vec), \
8d20e708 1189 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
a2e2357e
MD		 1190 }
1191
8d20e708 1192#define side_arg_dynamic_define_struct(_identifier, _struct_fields, _attr) \
c208889e
MD		 1193 const struct side_arg_dynamic_event_field _identifier##_fields[] = { _struct_fields }; \
1194 const struct side_arg_dynamic_event_struct _identifier = { \
465e5e7e 1195 .fields = _identifier##_fields, \
8d20e708 1196 .attr = _attr, \
465e5e7e 1197 .len = SIDE_ARRAY_SIZE(_identifier##_fields), \
8d20e708 1198 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
465e5e7e
MD		 1199 }
1200
f611d0c3
MD		 1201#define side_arg_define_vec(_identifier, _sav) \
1202 const struct side_arg_vec _identifier##_vec[] = { _sav }; \
1203 const struct side_arg_vec_description _identifier = { \
1204 .sav = _identifier##_vec, \
1205 .len = SIDE_ARRAY_SIZE(_identifier##_vec), \
1206 }
a2e2357e 1207
465e5e7e
MD		 1208#define side_arg_dynamic_field(_name, _elem) \
1209 { \
1210 .field_name = _name, \
1211 .elem = _elem, \
1212 }
1213
f611d0c3
MD		 1214#define side_arg_list(...) __VA_ARGS__
1215
d4328528 1216#define side_define_enum(_identifier, _mappings, _attr) \
79f677ba
MD		 1217 const struct side_enum_mappings _identifier = { \
1218 .mappings = _mappings, \
d4328528 1219 .attr = _attr, \
79f677ba 1220 .nr_mappings = SIDE_ARRAY_SIZE(SIDE_PARAM(_mappings)), \
d4328528 1221 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
79f677ba
MD		 1222 }
1223
66cff328 1224#define side_enum_mapping_list(...) \
79f677ba
MD		 1225 SIDE_COMPOUND_LITERAL(const struct side_enum_mapping, __VA_ARGS__)
1226
1227#define side_enum_mapping_range(_label, _begin, _end) \
1228 { \
1229 .range_begin = _begin, \
1230 .range_end = _end, \
1231 .label = _label, \
1232 }
1233
1234#define side_enum_mapping_value(_label, _value) \
1235 { \
1236 .range_begin = _value, \
1237 .range_end = _value, \
1238 .label = _label, \
1239 }
1240
d4328528 1241#define side_define_enum_bitmap(_identifier, _mappings, _attr) \
66cff328
MD		 1242 const struct side_enum_bitmap_mappings _identifier = { \
1243 .mappings = _mappings, \
d4328528 1244 .attr = _attr, \
66cff328 1245 .nr_mappings = SIDE_ARRAY_SIZE(SIDE_PARAM(_mappings)), \
d4328528 1246 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
66cff328
MD		 1247 }
1248
1249#define side_enum_bitmap_mapping_list(...) \
1250 SIDE_COMPOUND_LITERAL(const struct side_enum_bitmap_mapping, __VA_ARGS__)
1251
1252#define side_enum_bitmap_mapping_range(_label, _begin, _end) \
1253 { \
1254 .range_begin = _begin, \
1255 .range_end = _end, \
1256 .label = _label, \
1257 }
1258
1259#define side_enum_bitmap_mapping_value(_label, _value) \
1260 { \
1261 .range_begin = _value, \
1262 .range_end = _value, \
1263 .label = _label, \
1264 }
1265
f85b7f8b
MD		 1266#define side_event_cond(_identifier) \
1267 if (side_unlikely(__atomic_load_n(&side_event_enable__##_identifier, \
1268 __ATOMIC_RELAXED)))
e24949fa 1269
89747802 1270#define side_event_call(_identifier, _sav) \
e24949fa
MD		 1271 { \
1272 const struct side_arg_vec side_sav[] = { _sav }; \
1273 const struct side_arg_vec_description sav_desc = { \
1274 .sav = side_sav, \
1275 .len = SIDE_ARRAY_SIZE(side_sav), \
1276 }; \
89747802 1277 side_call(&(_identifier), &sav_desc); \
e24949fa
MD		 1278 }
1279
89747802
MD		 1280#define side_event(_identifier, _sav) \
1281 side_event_cond(_identifier) \
1282 side_event_call(_identifier, SIDE_PARAM(_sav))
e24949fa 1283
89747802 1284#define side_event_call_variadic(_identifier, _sav, _var_fields, _attr) \
e24949fa
MD		 1285 { \
1286 const struct side_arg_vec side_sav[] = { _sav }; \
1287 const struct side_arg_vec_description sav_desc = { \
1288 .sav = side_sav, \
1289 .len = SIDE_ARRAY_SIZE(side_sav), \
1290 }; \
1291 const struct side_arg_dynamic_event_field side_fields[] = { _var_fields }; \
1292 const struct side_arg_dynamic_event_struct var_struct = { \
1293 .fields = side_fields, \
1294 .attr = _attr, \
1295 .len = SIDE_ARRAY_SIZE(side_fields), \
1296 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
1297 }; \
89747802 1298 side_call_variadic(&(_identifier), &sav_desc, &var_struct); \
e24949fa
MD		 1299 }
1300
89747802
MD		 1301#define side_event_variadic(_identifier, _sav, _var, _attr) \
1302 side_event_cond(_identifier) \
1303 side_event_call_variadic(_identifier, SIDE_PARAM(_sav), SIDE_PARAM(_var), SIDE_PARAM(_attr))
e24949fa 1304
89747802 1305#define _side_define_event(_linkage, _identifier, _provider, _event, _loglevel, _fields, _attr, _flags) \
83a72806 1306 _linkage uintptr_t side_event_enable__##_identifier __attribute__((section("side_event_enable"))); \
89747802
MD		 1307 _linkage struct side_event_description __attribute__((section("side_event_description"))) \
1308 _identifier = { \
89747802 1309 .enabled = &(side_event_enable__##_identifier), \
f611d0c3
MD		 1310 .provider_name = _provider, \
1311 .event_name = _event, \
1312 .fields = _fields, \
65010f43 1313 .attr = _attr, \
054b7b5c 1314 .callbacks = &side_empty_callback, \
352df610
MD		 1315 .flags = (_flags), \
1316 .version = 0, \
1317 .loglevel = _loglevel, \
1318 .nr_fields = SIDE_ARRAY_SIZE(SIDE_PARAM(_fields)), \
1319 .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
1320 .nr_callbacks = 0, \
b5b67ff2 1321 }; \
89747802
MD		 1322 static const struct side_event_description *side_event_ptr__##_identifier \
1323 __attribute__((section("side_event_description_ptr"), used)) = &(_identifier);
1324
1325#define side_static_event(_identifier, _provider, _event, _loglevel, _fields, _attr) \
1326 _side_define_event(static, _identifier, _provider, _event, _loglevel, SIDE_PARAM(_fields), \
1327 SIDE_PARAM(_attr), 0)
1328
1329#define side_static_event_variadic(_identifier, _provider, _event, _loglevel, _fields, _attr) \
1330 _side_define_event(static, _identifier, _provider, _event, _loglevel, SIDE_PARAM(_fields), \
1331 SIDE_PARAM(_attr), SIDE_EVENT_FLAG_VARIADIC)
1332
1333#define side_hidden_event(_identifier, _provider, _event, _loglevel, _fields, _attr) \
1334 _side_define_event(__attribute__((visibility("hidden"))), _identifier, _provider, _event, _loglevel, SIDE_PARAM(_fields), \
1335 SIDE_PARAM(_attr), 0)
1336
1337#define side_hidden_event_variadic(_identifier, _provider, _event, _loglevel, _fields, _attr) \
1338 _side_define_event(__attribute__((visibility("hidden"))), _identifier, _provider, _event, _loglevel, SIDE_PARAM(_fields), \
1339 SIDE_PARAM(_attr), SIDE_EVENT_FLAG_VARIADIC)
f611d0c3 1340
89747802
MD		 1341#define side_export_event(_identifier, _provider, _event, _loglevel, _fields, _attr) \
1342 _side_define_event(__attribute__((visibility("default"))), _identifier, _provider, _event, _loglevel, SIDE_PARAM(_fields), \
399c836b 1343 SIDE_PARAM(_attr), 0)
8a25ce77 1344
89747802
MD		 1345#define side_export_event_variadic(_identifier, _provider, _event, _loglevel, _fields, _attr) \
1346 _side_define_event(__attribute__((visibility("default"))), _identifier, _provider, _event, _loglevel, SIDE_PARAM(_fields), \
399c836b 1347 SIDE_PARAM(_attr), SIDE_EVENT_FLAG_VARIADIC)
8a25ce77 1348
f611d0c3 1349#define side_declare_event(_identifier) \
83a72806 1350 extern uintptr_t side_event_enable_##_identifier; \
89747802 1351 extern struct side_event_description _identifier
f611d0c3 1352
a3f36db7
MD		 1353extern const struct side_callback side_empty_callback;
1354
6841ae81
MD		 1355void side_call(const struct side_event_description *desc,
1356 const struct side_arg_vec_description *sav_desc);
1357void side_call_variadic(const struct side_event_description *desc,
1358 const struct side_arg_vec_description *sav_desc,
1359 const struct side_arg_dynamic_event_struct *var_struct);
1360
a3f36db7
MD		 1361int side_tracer_callback_register(struct side_event_description *desc,
1362 void (*call)(const struct side_event_description *desc,
1363 const struct side_arg_vec_description *sav_desc,
1364 void *priv),
1365 void *priv);
1366int side_tracer_callback_variadic_register(struct side_event_description *desc,
1367 void (*call_variadic)(const struct side_event_description *desc,
1368 const struct side_arg_vec_description *sav_desc,
1369 const struct side_arg_dynamic_event_struct *var_struct,
1370 void *priv),
1371 void *priv);
1372int side_tracer_callback_unregister(struct side_event_description *desc,
1373 void (*call)(const struct side_event_description *desc,
1374 const struct side_arg_vec_description *sav_desc,
1375 void *priv),
1376 void *priv);
1377int side_tracer_callback_variadic_unregister(struct side_event_description *desc,
1378 void (*call_variadic)(const struct side_event_description *desc,
1379 const struct side_arg_vec_description *sav_desc,
1380 const struct side_arg_dynamic_event_struct *var_struct,
1381 void *priv),
1382 void *priv);
054b7b5c 1383
6e46f5e6
MD		 1384struct side_events_register_handle *side_events_register(struct side_event_description **events, uint32_t nr_events);
1385void side_events_unregister(struct side_events_register_handle *handle);
1386
a13c9d2e
MD		 1387enum side_tracer_notification {
1388 SIDE_TRACER_NOTIFICATION_INSERT_EVENTS,
1389 SIDE_TRACER_NOTIFICATION_REMOVE_EVENTS,
1390};
1391
1392/* Callback is invoked with side library internal lock held. */
1393struct side_tracer_handle *side_tracer_event_notification_register(
1394 void (*cb)(enum side_tracer_notification notif,
1395 struct side_event_description **events, uint32_t nr_events, void *priv),
1396 void *priv);
1397void side_tracer_event_notification_unregister(struct side_tracer_handle *handle);
1398
6e46f5e6
MD		 1399void side_init(void);
1400void side_exit(void);
1401
314c22c3
MD		 1402/*
1403 * These weak symbols, the constructor, and destructor take care of
1404 * registering only _one_ instance of the side instrumentation per
1405 * shared-ojbect (or for the whole main program).
1406 */
1407extern struct side_event_description * __start_side_event_description_ptr[]
1408 __attribute__((weak, visibility("hidden")));
1409extern struct side_event_description * __stop_side_event_description_ptr[]
1410 __attribute__((weak, visibility("hidden")));
1411int side_event_description_ptr_registered
1412 __attribute__((weak, visibility("hidden")));
1413struct side_events_register_handle *side_events_handle
1414 __attribute__((weak, visibility("hidden")));
1415
1416static void
1417side_event_description_ptr_init(void)
1418 __attribute__((no_instrument_function))
1419 __attribute__((constructor));
1420static void
1421side_event_description_ptr_init(void)
1422{
1423 if (side_event_description_ptr_registered++)
1424 return;
1425 side_events_handle = side_events_register(__start_side_event_description_ptr,
1426 __stop_side_event_description_ptr - __start_side_event_description_ptr);
1427}
1428
1429static void
1430side_event_description_ptr_exit(void)
1431 __attribute__((no_instrument_function))
1432 __attribute__((destructor));
1433static void
1434side_event_description_ptr_exit(void)
1435{
1436 if (--side_event_description_ptr_registered)
1437 return;
1438 side_events_unregister(side_events_handle);
1439 side_events_handle = NULL;
1440}
1441
f611d0c3 1442#endif /* _SIDE_TRACE_H */
Software Instrumentation Dynamically Enabled
This page took 0.140946 seconds and 4 git commands to generate.