sys/contrib/cloudabi/cloudabi32_types.h

   1 // Copyright (c) 2016 Nuxi (https://nuxi.nl/) and contributors.
   2 //
   3 // Redistribution and use in source and binary forms, with or without
   4 // modification, are permitted provided that the following conditions
   5 // are met:
   6 // 1. Redistributions of source code must retain the above copyright
   7 //    notice, this list of conditions and the following disclaimer.
   8 // 2. Redistributions in binary form must reproduce the above copyright
   9 //    notice, this list of conditions and the following disclaimer in the
  10 //    documentation and/or other materials provided with the distribution.
  11 //
  12 // THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  13 // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  14 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  15 // ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  16 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  17 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  18 // OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  19 // HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  20 // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  21 // OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  22 // SUCH DAMAGE.
  23 //
  24 // This file is automatically generated. Do not edit.
  25 //
  26 // Source: https://github.com/NuxiNL/cloudabi
  27
  28 #ifndef CLOUDABI32_TYPES_H
  29 #define CLOUDABI32_TYPES_H
  30
  31 #include "cloudabi_types_common.h"
  32
  33 typedef struct {
  34   _Alignas(4) cloudabi_auxtype_t a_type;
  35   union {
  36     _Alignas(4) uint32_t a_val;
  37     _Alignas(4) uint32_t a_ptr;
  38   };
  39 } cloudabi32_auxv_t;
  40 _Static_assert(offsetof(cloudabi32_auxv_t, a_type) == 0, "Incorrect layout");
  41 _Static_assert(offsetof(cloudabi32_auxv_t, a_val) == 4, "Incorrect layout");
  42 _Static_assert(offsetof(cloudabi32_auxv_t, a_ptr) == 4, "Incorrect layout");
  43 _Static_assert(sizeof(cloudabi32_auxv_t) == 8, "Incorrect layout");
  44 _Static_assert(_Alignof(cloudabi32_auxv_t) == 4, "Incorrect layout");
  45
  46 typedef struct {
  47   _Alignas(4) uint32_t buf;
  48   _Alignas(4) uint32_t buf_len;
  49 } cloudabi32_ciovec_t;
  50 _Static_assert(offsetof(cloudabi32_ciovec_t, buf) == 0, "Incorrect layout");
  51 _Static_assert(offsetof(cloudabi32_ciovec_t, buf_len) == 4, "Incorrect layout");
  52 _Static_assert(sizeof(cloudabi32_ciovec_t) == 8, "Incorrect layout");
  53 _Static_assert(_Alignof(cloudabi32_ciovec_t) == 4, "Incorrect layout");
  54
  55 typedef struct {
  56   _Alignas(4) uint32_t buf;
  57   _Alignas(4) uint32_t buf_len;
  58 } cloudabi32_iovec_t;
  59 _Static_assert(offsetof(cloudabi32_iovec_t, buf) == 0, "Incorrect layout");
  60 _Static_assert(offsetof(cloudabi32_iovec_t, buf_len) == 4, "Incorrect layout");
  61 _Static_assert(sizeof(cloudabi32_iovec_t) == 8, "Incorrect layout");
  62 _Static_assert(_Alignof(cloudabi32_iovec_t) == 4, "Incorrect layout");
  63
  64 typedef void cloudabi32_processentry_t(uint32_t auxv);
  65
  66 typedef struct {
  67   _Alignas(4) uint32_t ri_data;
  68   _Alignas(4) uint32_t ri_data_len;
  69   _Alignas(4) uint32_t ri_fds;
  70   _Alignas(4) uint32_t ri_fds_len;
  71   _Alignas(2) cloudabi_riflags_t ri_flags;
  72 } cloudabi32_recv_in_t;
  73 _Static_assert(offsetof(cloudabi32_recv_in_t, ri_data) == 0, "Incorrect layout");
  74 _Static_assert(offsetof(cloudabi32_recv_in_t, ri_data_len) == 4, "Incorrect layout");
  75 _Static_assert(offsetof(cloudabi32_recv_in_t, ri_fds) == 8, "Incorrect layout");
  76 _Static_assert(offsetof(cloudabi32_recv_in_t, ri_fds_len) == 12, "Incorrect layout");
  77 _Static_assert(offsetof(cloudabi32_recv_in_t, ri_flags) == 16, "Incorrect layout");
  78 _Static_assert(sizeof(cloudabi32_recv_in_t) == 20, "Incorrect layout");
  79 _Static_assert(_Alignof(cloudabi32_recv_in_t) == 4, "Incorrect layout");
  80
  81 typedef struct {
  82   _Alignas(4) uint32_t ro_datalen;
  83   _Alignas(4) uint32_t ro_fdslen;
  84   _Alignas(1) char ro_unused[40];
  85   _Alignas(2) cloudabi_roflags_t ro_flags;
  86 } cloudabi32_recv_out_t;
  87 _Static_assert(offsetof(cloudabi32_recv_out_t, ro_datalen) == 0, "Incorrect layout");
  88 _Static_assert(offsetof(cloudabi32_recv_out_t, ro_fdslen) == 4, "Incorrect layout");
  89 _Static_assert(offsetof(cloudabi32_recv_out_t, ro_unused) == 8, "Incorrect layout");
  90 _Static_assert(offsetof(cloudabi32_recv_out_t, ro_flags) == 48, "Incorrect layout");
  91 _Static_assert(sizeof(cloudabi32_recv_out_t) == 52, "Incorrect layout");
  92 _Static_assert(_Alignof(cloudabi32_recv_out_t) == 4, "Incorrect layout");
  93
  94 typedef struct {
  95   _Alignas(4) uint32_t si_data;
  96   _Alignas(4) uint32_t si_data_len;
  97   _Alignas(4) uint32_t si_fds;
  98   _Alignas(4) uint32_t si_fds_len;
  99   _Alignas(2) cloudabi_siflags_t si_flags;
 100 } cloudabi32_send_in_t;
 101 _Static_assert(offsetof(cloudabi32_send_in_t, si_data) == 0, "Incorrect layout");
 102 _Static_assert(offsetof(cloudabi32_send_in_t, si_data_len) == 4, "Incorrect layout");
 103 _Static_assert(offsetof(cloudabi32_send_in_t, si_fds) == 8, "Incorrect layout");
 104 _Static_assert(offsetof(cloudabi32_send_in_t, si_fds_len) == 12, "Incorrect layout");
 105 _Static_assert(offsetof(cloudabi32_send_in_t, si_flags) == 16, "Incorrect layout");
 106 _Static_assert(sizeof(cloudabi32_send_in_t) == 20, "Incorrect layout");
 107 _Static_assert(_Alignof(cloudabi32_send_in_t) == 4, "Incorrect layout");
 108
 109 typedef struct {
 110   _Alignas(4) uint32_t so_datalen;
 111 } cloudabi32_send_out_t;
 112 _Static_assert(offsetof(cloudabi32_send_out_t, so_datalen) == 0, "Incorrect layout");
 113 _Static_assert(sizeof(cloudabi32_send_out_t) == 4, "Incorrect layout");
 114 _Static_assert(_Alignof(cloudabi32_send_out_t) == 4, "Incorrect layout");
 115
 116 typedef struct {
 117   _Alignas(8) cloudabi_userdata_t userdata;
 118   _Alignas(2) uint16_t unused;
 119   _Alignas(1) cloudabi_eventtype_t type;
 120   union {
 121     struct {
 122       _Alignas(8) cloudabi_userdata_t identifier;
 123       _Alignas(4) cloudabi_clockid_t clock_id;
 124       _Alignas(8) cloudabi_timestamp_t timeout;
 125       _Alignas(8) cloudabi_timestamp_t precision;
 126       _Alignas(2) cloudabi_subclockflags_t flags;
 127     } clock;
 128     struct {
 129       _Alignas(4) uint32_t condvar;
 130       _Alignas(4) uint32_t lock;
 131       _Alignas(1) cloudabi_scope_t condvar_scope;
 132       _Alignas(1) cloudabi_scope_t lock_scope;
 133     } condvar;
 134     struct {
 135       _Alignas(4) cloudabi_fd_t fd;
 136       _Alignas(2) cloudabi_subrwflags_t flags;
 137     } fd_readwrite;
 138     struct {
 139       _Alignas(4) uint32_t lock;
 140       _Alignas(1) cloudabi_scope_t lock_scope;
 141     } lock;
 142     struct {
 143       _Alignas(4) cloudabi_fd_t fd;
 144     } proc_terminate;
 145   };
 146 } cloudabi32_subscription_t;
 147 _Static_assert(offsetof(cloudabi32_subscription_t, userdata) == 0, "Incorrect layout");
 148 _Static_assert(offsetof(cloudabi32_subscription_t, unused) == 8, "Incorrect layout");
 149 _Static_assert(offsetof(cloudabi32_subscription_t, type) == 10, "Incorrect layout");
 150 _Static_assert(offsetof(cloudabi32_subscription_t, clock.identifier) == 16, "Incorrect layout");
 151 _Static_assert(offsetof(cloudabi32_subscription_t, clock.clock_id) == 24, "Incorrect layout");
 152 _Static_assert(offsetof(cloudabi32_subscription_t, clock.timeout) == 32, "Incorrect layout");
 153 _Static_assert(offsetof(cloudabi32_subscription_t, clock.precision) == 40, "Incorrect layout");
 154 _Static_assert(offsetof(cloudabi32_subscription_t, clock.flags) == 48, "Incorrect layout");
 155 _Static_assert(offsetof(cloudabi32_subscription_t, condvar.condvar) == 16, "Incorrect layout");
 156 _Static_assert(offsetof(cloudabi32_subscription_t, condvar.lock) == 20, "Incorrect layout");
 157 _Static_assert(offsetof(cloudabi32_subscription_t, condvar.condvar_scope) == 24, "Incorrect layout");
 158 _Static_assert(offsetof(cloudabi32_subscription_t, condvar.lock_scope) == 25, "Incorrect layout");
 159 _Static_assert(offsetof(cloudabi32_subscription_t, fd_readwrite.fd) == 16, "Incorrect layout");
 160 _Static_assert(offsetof(cloudabi32_subscription_t, fd_readwrite.flags) == 20, "Incorrect layout");
 161 _Static_assert(offsetof(cloudabi32_subscription_t, lock.lock) == 16, "Incorrect layout");
 162 _Static_assert(offsetof(cloudabi32_subscription_t, lock.lock_scope) == 20, "Incorrect layout");
 163 _Static_assert(offsetof(cloudabi32_subscription_t, proc_terminate.fd) == 16, "Incorrect layout");
 164 _Static_assert(sizeof(cloudabi32_subscription_t) == 56, "Incorrect layout");
 165 _Static_assert(_Alignof(cloudabi32_subscription_t) == 8, "Incorrect layout");
 166
 167 typedef struct {
 168   _Alignas(4) uint32_t parent;
 169 } cloudabi32_tcb_t;
 170 _Static_assert(offsetof(cloudabi32_tcb_t, parent) == 0, "Incorrect layout");
 171 _Static_assert(sizeof(cloudabi32_tcb_t) == 4, "Incorrect layout");
 172 _Static_assert(_Alignof(cloudabi32_tcb_t) == 4, "Incorrect layout");
 173
 174 typedef void cloudabi32_threadentry_t(cloudabi_tid_t tid, uint32_t aux);
 175
 176 typedef struct {
 177   _Alignas(4) uint32_t entry_point;
 178   _Alignas(4) uint32_t stack;
 179   _Alignas(4) uint32_t stack_len;
 180   _Alignas(4) uint32_t argument;
 181 } cloudabi32_threadattr_t;
 182 _Static_assert(offsetof(cloudabi32_threadattr_t, entry_point) == 0, "Incorrect layout");
 183 _Static_assert(offsetof(cloudabi32_threadattr_t, stack) == 4, "Incorrect layout");
 184 _Static_assert(offsetof(cloudabi32_threadattr_t, stack_len) == 8, "Incorrect layout");
 185 _Static_assert(offsetof(cloudabi32_threadattr_t, argument) == 12, "Incorrect layout");
 186 _Static_assert(sizeof(cloudabi32_threadattr_t) == 16, "Incorrect layout");
 187 _Static_assert(_Alignof(cloudabi32_threadattr_t) == 4, "Incorrect layout");
 188
 189 #endif