include/side/type-description-abi.h

   1 // SPDX-License-Identifier: MIT
   2 /*
   3  * Copyright 2022-2023 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   4  */
   5
   6 #ifndef SIDE_TYPE_DESCRIPTION_ABI_H
   7 #define SIDE_TYPE_DESCRIPTION_ABI_H
   8
   9 #include <stdint.h>
  10 #include <side/macros.h>
  11 #include <side/endian.h>
  12
  13 #include <side/type-value-abi.h>
  14 #include <side/attribute-abi.h>
  15 #include <side/visitor-abi.h>
  16
  17 enum side_type_label {
  18         /* Stack-copy basic types */
  19         SIDE_TYPE_NULL,
  20         SIDE_TYPE_BOOL,
  21         SIDE_TYPE_U8,
  22         SIDE_TYPE_U16,
  23         SIDE_TYPE_U32,
  24         SIDE_TYPE_U64,
  25         SIDE_TYPE_S8,
  26         SIDE_TYPE_S16,
  27         SIDE_TYPE_S32,
  28         SIDE_TYPE_S64,
  29         SIDE_TYPE_BYTE,
  30         SIDE_TYPE_POINTER,
  31         SIDE_TYPE_FLOAT_BINARY16,
  32         SIDE_TYPE_FLOAT_BINARY32,
  33         SIDE_TYPE_FLOAT_BINARY64,
  34         SIDE_TYPE_FLOAT_BINARY128,
  35         SIDE_TYPE_STRING_UTF8,
  36         SIDE_TYPE_STRING_UTF16,
  37         SIDE_TYPE_STRING_UTF32,
  38
  39         /* Stack-copy compound types */
  40         SIDE_TYPE_STRUCT,
  41         SIDE_TYPE_VARIANT,
  42         SIDE_TYPE_ARRAY,
  43         SIDE_TYPE_VLA,
  44         SIDE_TYPE_VLA_VISITOR,
  45
  46         /* Stack-copy enumeration types */
  47         SIDE_TYPE_ENUM,
  48         SIDE_TYPE_ENUM_BITMAP,
  49
  50         /* Stack-copy place holder for dynamic types */
  51         SIDE_TYPE_DYNAMIC,
  52
  53         /* Gather basic types */
  54         SIDE_TYPE_GATHER_BOOL,
  55         SIDE_TYPE_GATHER_INTEGER,
  56         SIDE_TYPE_GATHER_BYTE,
  57         SIDE_TYPE_GATHER_POINTER,
  58         SIDE_TYPE_GATHER_FLOAT,
  59         SIDE_TYPE_GATHER_STRING,
  60
  61         /* Gather compound types */
  62         SIDE_TYPE_GATHER_STRUCT,
  63         SIDE_TYPE_GATHER_ARRAY,
  64         SIDE_TYPE_GATHER_VLA,
  65
  66         /* Gather enumeration types */
  67         SIDE_TYPE_GATHER_ENUM,
  68
  69         /* Dynamic basic types */
  70         SIDE_TYPE_DYNAMIC_NULL,
  71         SIDE_TYPE_DYNAMIC_BOOL,
  72         SIDE_TYPE_DYNAMIC_INTEGER,
  73         SIDE_TYPE_DYNAMIC_BYTE,
  74         SIDE_TYPE_DYNAMIC_POINTER,
  75         SIDE_TYPE_DYNAMIC_FLOAT,
  76         SIDE_TYPE_DYNAMIC_STRING,
  77
  78         /* Dynamic compound types */
  79         SIDE_TYPE_DYNAMIC_STRUCT,
  80         SIDE_TYPE_DYNAMIC_STRUCT_VISITOR,
  81         SIDE_TYPE_DYNAMIC_VLA,
  82         SIDE_TYPE_DYNAMIC_VLA_VISITOR,
  83
  84         _NR_SIDE_TYPE_LABEL,    /* Last entry. */
  85 };
  86
  87 enum side_visitor_status {
  88         SIDE_VISITOR_STATUS_OK = 0,
  89         SIDE_VISITOR_STATUS_ERROR = -1,
  90 };
  91
  92 enum side_type_gather_access_mode {
  93         SIDE_TYPE_GATHER_ACCESS_DIRECT,
  94         SIDE_TYPE_GATHER_ACCESS_POINTER,        /* Pointer dereference */
  95 };
  96
  97 /* Type descriptions */
  98 struct side_type_null {
  99         side_ptr_t(const struct side_attr) attr;
 100         uint32_t nr_attr;
 101 } SIDE_PACKED;
 102 side_check_size(struct side_type_null, 20);
 103
 104 struct side_type_bool {
 105         side_ptr_t(const struct side_attr) attr;
 106         uint32_t nr_attr;
 107         uint16_t bool_size;             /* bytes */
 108         uint16_t len_bits;              /* bits. 0 for (bool_size * CHAR_BITS) */
 109         side_enum_t(enum side_type_label_byte_order, uint8_t) byte_order;
 110 } SIDE_PACKED;
 111 side_check_size(struct side_type_bool, 25);
 112
 113 struct side_type_byte {
 114         side_ptr_t(const struct side_attr) attr;
 115         uint32_t nr_attr;
 116 } SIDE_PACKED;
 117 side_check_size(struct side_type_byte, 20);
 118
 119 struct side_type_string {
 120         side_ptr_t(const struct side_attr) attr;
 121         uint32_t nr_attr;
 122         uint8_t unit_size;              /* 1, 2, or 4 bytes */
 123         side_enum_t(enum side_type_label_byte_order, uint8_t) byte_order;
 124 } SIDE_PACKED;
 125 side_check_size(struct side_type_string, 22);
 126
 127 struct side_type_integer {
 128         side_ptr_t(const struct side_attr) attr;
 129         uint32_t nr_attr;
 130         uint16_t integer_size;          /* bytes */
 131         uint16_t len_bits;              /* bits. 0 for (integer_size * CHAR_BITS) */
 132         uint8_t signedness;             /* true/false */
 133         side_enum_t(enum side_type_label_byte_order, uint8_t) byte_order;
 134 } SIDE_PACKED;
 135 side_check_size(struct side_type_integer, 26);
 136
 137 struct side_type_float {
 138         side_ptr_t(const struct side_attr) attr;
 139         uint32_t nr_attr;
 140         uint16_t float_size;            /* bytes */
 141         side_enum_t(enum side_type_label_byte_order, uint8_t) byte_order;
 142 } SIDE_PACKED;
 143 side_check_size(struct side_type_float, 23);
 144
 145 struct side_enum_mapping {
 146         int64_t range_begin;
 147         int64_t range_end;
 148         struct side_type_raw_string label;
 149 } SIDE_PACKED;
 150 side_check_size(struct side_enum_mapping, 16 + sizeof(struct side_type_raw_string));
 151
 152 struct side_enum_mappings {
 153         side_ptr_t(const struct side_enum_mapping) mappings;
 154         side_ptr_t(const struct side_attr) attr;
 155         uint32_t nr_mappings;
 156         uint32_t nr_attr;
 157 } SIDE_PACKED;
 158 side_check_size(struct side_enum_mappings, 40);
 159
 160 struct side_enum_bitmap_mapping {
 161         uint64_t range_begin;
 162         uint64_t range_end;
 163         struct side_type_raw_string label;
 164 } SIDE_PACKED;
 165 side_check_size(struct side_enum_bitmap_mapping, 16 + sizeof(struct side_type_raw_string));
 166
 167 struct side_enum_bitmap_mappings {
 168         side_ptr_t(const struct side_enum_bitmap_mapping) mappings;
 169         side_ptr_t(const struct side_attr) attr;
 170         uint32_t nr_mappings;
 171         uint32_t nr_attr;
 172 } SIDE_PACKED;
 173 side_check_size(struct side_enum_bitmap_mappings, 40);
 174
 175 struct side_type_struct {
 176         side_ptr_t(const struct side_event_field) fields;
 177         side_ptr_t(const struct side_attr) attr;
 178         uint32_t nr_fields;
 179         uint32_t nr_attr;
 180 } SIDE_PACKED;
 181 side_check_size(struct side_type_struct, 40);
 182
 183 struct side_type_array {
 184         side_ptr_t(const struct side_type) elem_type;
 185         side_ptr_t(const struct side_attr) attr;
 186         uint32_t length;
 187         uint32_t nr_attr;
 188 } SIDE_PACKED;
 189 side_check_size(struct side_type_array, 40);
 190
 191 struct side_type_vla {
 192         side_ptr_t(const struct side_type) elem_type;
 193         side_ptr_t(const struct side_attr) attr;
 194         uint32_t nr_attr;
 195 } SIDE_PACKED;
 196 side_check_size(struct side_type_vla, 36);
 197
 198 struct side_type_vla_visitor {
 199         side_ptr_t(const struct side_type) elem_type;
 200         side_func_ptr_t(side_visitor_func) visitor;
 201         side_ptr_t(const struct side_attr) attr;
 202         uint32_t nr_attr;
 203 } SIDE_PACKED;
 204 side_check_size(struct side_type_vla_visitor, 52);
 205
 206 struct side_type_enum {
 207         side_ptr_t(const struct side_enum_mappings) mappings;
 208         side_ptr_t(const struct side_type) elem_type;
 209 } SIDE_PACKED;
 210 side_check_size(struct side_type_enum, 32);
 211
 212 struct side_type_enum_bitmap {
 213         side_ptr_t(const struct side_enum_bitmap_mappings) mappings;
 214         side_ptr_t(const struct side_type) elem_type;
 215 } SIDE_PACKED;
 216 side_check_size(struct side_type_enum_bitmap, 32);
 217
 218 struct side_type_gather_bool {
 219         uint64_t offset;        /* bytes */
 220         uint16_t offset_bits;   /* bits */
 221         uint8_t access_mode;    /* enum side_type_gather_access_mode */
 222         struct side_type_bool type;
 223 } SIDE_PACKED;
 224 side_check_size(struct side_type_gather_bool, 11 + sizeof(struct side_type_bool));
 225
 226 struct side_type_gather_byte {
 227         uint64_t offset;        /* bytes */
 228         uint8_t access_mode;    /* enum side_type_gather_access_mode */
 229         struct side_type_byte type;
 230 } SIDE_PACKED;
 231 side_check_size(struct side_type_gather_byte, 9 + sizeof(struct side_type_byte));
 232
 233 struct side_type_gather_integer {
 234         uint64_t offset;        /* bytes */
 235         uint16_t offset_bits;   /* bits */
 236         uint8_t access_mode;    /* enum side_type_gather_access_mode */
 237         struct side_type_integer type;
 238 } SIDE_PACKED;
 239 side_check_size(struct side_type_gather_integer, 11 + sizeof(struct side_type_integer));
 240
 241 struct side_type_gather_float {
 242         uint64_t offset;        /* bytes */
 243         uint8_t access_mode;    /* enum side_type_gather_access_mode */
 244         struct side_type_float type;
 245 } SIDE_PACKED;
 246 side_check_size(struct side_type_gather_float, 9 + sizeof(struct side_type_float));
 247
 248 struct side_type_gather_string {
 249         uint64_t offset;        /* bytes */
 250         uint8_t access_mode;    /* enum side_type_gather_access_mode */
 251         struct side_type_string type;
 252 } SIDE_PACKED;
 253 side_check_size(struct side_type_gather_string, 9 + sizeof(struct side_type_string));
 254
 255 struct side_type_gather_enum {
 256         side_ptr_t(const struct side_enum_mappings) mappings;
 257         side_ptr_t(const struct side_type) elem_type;
 258 } SIDE_PACKED;
 259 side_check_size(struct side_type_gather_enum, 32);
 260
 261 struct side_type_gather_struct {
 262         side_ptr_t(const struct side_type_struct) type;
 263         uint64_t offset;        /* bytes */
 264         uint8_t access_mode;    /* enum side_type_gather_access_mode */
 265         uint32_t size;          /* bytes */
 266 } SIDE_PACKED;
 267 side_check_size(struct side_type_gather_struct, 29);
 268
 269 struct side_type_gather_array {
 270         uint64_t offset;        /* bytes */
 271         uint8_t access_mode;    /* enum side_type_gather_access_mode */
 272         struct side_type_array type;
 273 } SIDE_PACKED;
 274 side_check_size(struct side_type_gather_array, 9 + sizeof(struct side_type_array));
 275
 276 struct side_type_gather_vla {
 277         side_ptr_t(const struct side_type) length_type; /* side_length() */
 278         uint64_t offset;        /* bytes */
 279         uint8_t access_mode;    /* enum side_type_gather_access_mode */
 280         struct side_type_vla type;
 281 } SIDE_PACKED;
 282 side_check_size(struct side_type_gather_vla, 25 + sizeof(struct side_type_vla));
 283
 284 struct side_type_gather {
 285         union {
 286                 struct side_type_gather_bool side_bool;
 287                 struct side_type_gather_byte side_byte;
 288                 struct side_type_gather_integer side_integer;
 289                 struct side_type_gather_float side_float;
 290                 struct side_type_gather_string side_string;
 291                 struct side_type_gather_enum side_enum;
 292                 struct side_type_gather_array side_array;
 293                 struct side_type_gather_vla side_vla;
 294                 struct side_type_gather_struct side_struct;
 295                 side_padding(61);
 296         } SIDE_PACKED u;
 297 } SIDE_PACKED;
 298 side_check_size(struct side_type_gather, 61);
 299
 300 struct side_type {
 301         side_enum_t(enum side_type_label, uint16_t) type;
 302         union {
 303                 /* Stack-copy basic types */
 304                 struct side_type_null side_null;
 305                 struct side_type_bool side_bool;
 306                 struct side_type_byte side_byte;
 307                 struct side_type_string side_string;
 308                 struct side_type_integer side_integer;
 309                 struct side_type_float side_float;
 310
 311                 /* Stack-copy compound types */
 312                 struct side_type_array side_array;
 313                 struct side_type_vla side_vla;
 314                 struct side_type_vla_visitor side_vla_visitor;
 315                 side_ptr_t(const struct side_type_struct) side_struct;
 316                 side_ptr_t(const struct side_type_variant) side_variant;
 317
 318                 /* Stack-copy enumeration types */
 319                 struct side_type_enum side_enum;
 320                 struct side_type_enum_bitmap side_enum_bitmap;
 321
 322                 /* Gather types */
 323                 struct side_type_gather side_gather;
 324                 side_padding(62);
 325         } SIDE_PACKED u;
 326 } SIDE_PACKED;
 327 side_check_size(struct side_type, 64);
 328
 329 struct side_variant_option {
 330         int64_t range_begin;
 331         int64_t range_end;
 332         const struct side_type side_type;
 333 } SIDE_PACKED;
 334 side_check_size(struct side_variant_option, 16 + sizeof(const struct side_type));
 335
 336 struct side_type_variant {
 337         side_ptr_t(const struct side_variant_option) options;
 338         side_ptr_t(const struct side_attr) attr;
 339         uint32_t nr_options;
 340         uint32_t nr_attr;
 341         const struct side_type selector;
 342 } SIDE_PACKED;
 343 side_check_size(struct side_type_variant, 40 + sizeof(const struct side_type));
 344
 345 struct side_event_field {
 346         side_ptr_t(const char) field_name;
 347         struct side_type side_type;
 348 } SIDE_PACKED;
 349 side_check_size(struct side_event_field, 16 + sizeof(struct side_type));
 350
 351 #endif /* SIDE_TYPE_DESCRIPTION_ABI_H */