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