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