ipret.h

   1 /*
   2  * Copyright (C) 2024 Mikulas Patocka
   3  *
   4  * This file is part of Ajla.
   5  *
   6  * Ajla is free software: you can redistribute it and/or modify it under the
   7  * terms of the GNU General Public License as published by the Free Software
   8  * Foundation, either version 3 of the License, or (at your option) any later
   9  * version.
  10  *
  11  * Ajla is distributed in the hope that it will be useful, but WITHOUT ANY
  12  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  13  * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along with
  16  * Ajla. If not, see <https://www.gnu.org/licenses/>.
  17  */
  18
  19 #ifndef AJLA_IPRET_H
  20 #define AJLA_IPRET_H
  21
  22 #include "data.h"
  23
  24 #define run                     name(run)
  25 #define cg_upcall_vector        name(cg_upcall_vector)
  26
  27 /*#define DEBUG_UPCALL*/
  28
  29 #ifdef POINTER_COMPRESSION
  30 #define pointer_t_upcall        uintptr_t
  31 #define int_default_t_upcall    intptr_t
  32 #else
  33 #define pointer_t_upcall        pointer_t
  34 #define int_default_t_upcall    int_default_t
  35 #endif
  36
  37 void attr_fastcall run(frame_s *, ip_t);
  38
  39 struct cg_upcall_vector_s {
  40         atomic_type tick_stamp_t ts;
  41 #ifdef HAVE_CODEGEN
  42         void (*mem_copy)(void *dest, const void *src, size_t size);
  43         void (*mem_clear)(void *ptr, size_t size);
  44         void (*cg_upcall_pointer_dereference)(pointer_t_upcall ptr);
  45         void (*cg_upcall_pointer_reference_owned)(pointer_t_upcall ptr);
  46         pointer_t (*cg_upcall_flat_to_data)(frame_s *fp, uintptr_t slot, const unsigned char *flat);
  47         unsigned char *(*cg_upcall_data_alloc_function_reference_mayfail)(uintptr_t n_curried_arguments);
  48         unsigned char *(*cg_upcall_data_alloc_record_mayfail)(frame_s *fp, uintptr_t slot);
  49         unsigned char *(*cg_upcall_data_alloc_option_mayfail)(void);
  50         unsigned char *(*cg_upcall_data_alloc_array_flat_tag_mayfail)(uintptr_t t, int_default_t_upcall n_entries);
  51         unsigned char *(*cg_upcall_data_alloc_array_flat_slot_mayfail)(frame_s *fp, uintptr_t slot, int_default_t_upcall n_entries);
  52         unsigned char *(*cg_upcall_data_alloc_array_flat_types_ptr_mayfail)(frame_s *fp, uintptr_t local_type, int_default_t_upcall n_entries);
  53         unsigned char *(*cg_upcall_data_alloc_array_pointers_mayfail)(int_default_t_upcall n_allocated, int_default_t_upcall n_used);
  54         pointer_t (*cg_upcall_array_create_flat)(frame_s *fp, int_default_t_upcall length, uintptr_t content_slot);
  55         pointer_t (*cg_upcall_array_create_pointers)(frame_s *fp, uintptr_t ip_offset, uintptr_t length_slot, pointer_t_upcall ptr);
  56         pointer_t (*cg_upcall_array_create_sparse)(int_default_t_upcall length, pointer_t_upcall ptr);
  57         pointer_t (*cg_upcall_array_sub)(pointer_t_upcall array, int_default_t_upcall start, int_default_t_upcall end, bool deref);
  58         pointer_t (*cg_upcall_array_skip)(pointer_t_upcall array, int_default_t_upcall start, bool deref);
  59         pointer_t (*cg_upcall_array_join)(pointer_t_upcall ptr1, pointer_t_upcall ptr2);
  60         void *(*cg_upcall_ipret_io)(frame_s *fp, uintptr_t ip_offset, uintptr_t code_params);
  61         pointer_t (*cg_upcall_ipret_copy_variable_to_pointer)(frame_s *src_fp, uintptr_t src_slot, bool deref);
  62         int_default_t (*ipret_system_property)(int_default_t_upcall idx);
  63         bool (*cat(FIXED_binary_add_,TYPE_INT_MAX))(const uintbig_t *v1, const uintbig_t *v2, uintbig_t *r);
  64         bool (*cat(FIXED_binary_subtract_,TYPE_INT_MAX))(const uintbig_t *v1, const uintbig_t *v2, uintbig_t *r);
  65 #define f(n, s, u, sz, bits) \
  66         bool (*cat(FIXED_binary_multiply_,s))(const u *v1, const u *v2, u *r);
  67         for_all_fixed(f)
  68 #undef f
  69 #define f(n, s, u, sz, bits) \
  70         bool (*cat(FIXED_binary_divide_,s))(const u *v1, const u *v2, u *r);
  71         for_all_fixed(f)
  72 #undef f
  73 #define f(n, s, u, sz, bits) \
  74         bool (*cat(FIXED_binary_udivide_,s))(const u *v1, const u *v2, u *r);
  75         for_all_fixed(f)
  76 #undef f
  77 #define f(n, s, u, sz, bits) \
  78         bool (*cat(FIXED_binary_modulo_,s))(const u *v1, const u *v2, u *r);
  79         for_all_fixed(f)
  80 #undef f
  81 #define f(n, s, u, sz, bits) \
  82         bool (*cat(FIXED_binary_umodulo_,s))(const u *v1, const u *v2, u *r);
  83         for_all_fixed(f)
  84 #undef f
  85 #define f(n, s, u, sz, bits) \
  86         bool (*cat(FIXED_binary_power_,s))(const u *v1, const u *v2, u *r);
  87         for_all_fixed(f)
  88 #undef f
  89         bool (*cat(FIXED_binary_shl_,TYPE_INT_MAX))(const uintbig_t *v1, const uintbig_t *v2, uintbig_t *r);
  90         bool (*cat(FIXED_binary_shr_,TYPE_INT_MAX))(const uintbig_t *v1, const uintbig_t *v2, uintbig_t *r);
  91         bool (*cat(FIXED_binary_ushr_,TYPE_INT_MAX))(const uintbig_t *v1, const uintbig_t *v2, uintbig_t *r);
  92         bool (*cat(FIXED_binary_rol_,TYPE_INT_MAX))(const uintbig_t *v1, const uintbig_t *v2, uintbig_t *r);
  93         bool (*cat(FIXED_binary_ror_,TYPE_INT_MAX))(const uintbig_t *v1, const uintbig_t *v2, uintbig_t *r);
  94         bool (*cat(FIXED_binary_bts_,TYPE_INT_MAX))(const uintbig_t *v1, const uintbig_t *v2, uintbig_t *r);
  95         bool (*cat(FIXED_binary_btr_,TYPE_INT_MAX))(const uintbig_t *v1, const uintbig_t *v2, uintbig_t *r);
  96         bool (*cat(FIXED_binary_btc_,TYPE_INT_MAX))(const uintbig_t *v1, const uintbig_t *v2, uintbig_t *r);
  97         bool (*cat(FIXED_binary_less_,TYPE_INT_MAX))(const uintbig_t *v1, const uintbig_t *v2, ajla_flat_option_t *r);
  98         bool (*cat(FIXED_binary_less_equal_,TYPE_INT_MAX))(const uintbig_t *v1, const uintbig_t *v2, ajla_flat_option_t *r);
  99         bool (*cat(FIXED_binary_uless_,TYPE_INT_MAX))(const uintbig_t *v1, const uintbig_t *v2, ajla_flat_option_t *r);
 100         bool (*cat(FIXED_binary_uless_equal_,TYPE_INT_MAX))(const uintbig_t *v1, const uintbig_t *v2, ajla_flat_option_t *r);
 101         bool (*cat(FIXED_binary_bt_,TYPE_INT_MAX))(const uintbig_t *v1, const uintbig_t *v2, ajla_flat_option_t *r);
 102         void (*cat(FIXED_unary_neg_,TYPE_INT_MAX))(const uintbig_t *v1, uintbig_t *r);
 103         void (*cat(FIXED_unary_inc_,TYPE_INT_MAX))(const uintbig_t *v1, uintbig_t *r);
 104         void (*cat(FIXED_unary_dec_,TYPE_INT_MAX))(const uintbig_t *v1, uintbig_t *r);
 105 #define f(n, s, u, sz, bits) \
 106         void (*cat(FIXED_unary_bswap_,s))(const u *v1, u *r);
 107         for_all_fixed(f)
 108 #undef f
 109 #define f(n, s, u, sz, bits) \
 110         void (*cat(FIXED_unary_brev_,s))(const u *v1, u *r);
 111         for_all_fixed(f)
 112 #undef f
 113 #define f(n, s, u, sz, bits) \
 114         void (*cat(FIXED_unary_bsf_,s))(const u *v1, u *r);
 115         for_all_fixed(f)
 116 #undef f
 117 #define f(n, s, u, sz, bits) \
 118         void (*cat(FIXED_unary_bsr_,s))(const u *v1, u *r);
 119         for_all_fixed(f)
 120 #undef f
 121 #define f(n, s, u, sz, bits) \
 122         void (*cat(FIXED_unary_popcnt_,s))(const u *v1, u *r);
 123         for_all_fixed(f)
 124 #undef f
 125 #define f(n, s, u, sz, bits) \
 126         bool (*cat(FIXED_uto_int_,s))(const u *v1, int_default_t *r);
 127         for_all_fixed(f)
 128 #undef f
 129 #define f(n, s, u, sz, bits) \
 130         bool (*cat(FIXED_ufrom_int_,s))(const int_default_t *v1, u *r);
 131         for_all_fixed(f)
 132 #undef f
 133         bool (*cat(INT_binary_add_,TYPE_INT_MAX))(const intbig_t *v1, const intbig_t *v2, intbig_t *r);
 134         bool (*cat(INT_binary_subtract_,TYPE_INT_MAX))(const intbig_t *v1, const intbig_t *v2, intbig_t *r);
 135 #define f(n, s, u, sz, bits) \
 136         bool (*cat(INT_binary_multiply_,s))(const s *v1, const s *v2, s *r);
 137         for_all_int(f, for_all_empty)
 138 #undef f
 139 #define f(n, s, u, sz, bits) \
 140         bool (*cat(INT_binary_divide_,s))(const s *v1, const s *v2, s *r);
 141         for_all_int(f, for_all_empty)
 142 #undef f
 143 #define f(n, s, u, sz, bits) \
 144         bool (*cat(INT_binary_modulo_,s))(const s *v1, const s *v2, s *r);
 145         for_all_int(f, for_all_empty)
 146 #undef f
 147 #define f(n, s, u, sz, bits) \
 148         bool (*cat(INT_binary_power_,s))(const s *v1, const s *v2, s *r);
 149         for_all_int(f, for_all_empty)
 150 #undef f
 151         bool (*cat(INT_binary_shl_,TYPE_INT_MAX))(const intbig_t *v1, const intbig_t *v2, intbig_t *r);
 152         bool (*cat(INT_binary_shr_,TYPE_INT_MAX))(const intbig_t *v1, const intbig_t *v2, intbig_t *r);
 153         bool (*cat(INT_binary_bts_,TYPE_INT_MAX))(const intbig_t *v1, const intbig_t *v2, intbig_t *r);
 154         bool (*cat(INT_binary_btr_,TYPE_INT_MAX))(const intbig_t *v1, const intbig_t *v2, intbig_t *r);
 155         bool (*cat(INT_binary_btc_,TYPE_INT_MAX))(const intbig_t *v1, const intbig_t *v2, intbig_t *r);
 156         bool (*cat(INT_binary_bt_,TYPE_INT_MAX))(const intbig_t *v1, const intbig_t *v2, ajla_flat_option_t *r);
 157         bool (*cat(INT_unary_neg_,TYPE_INT_MAX))(const intbig_t *v1, intbig_t *r);
 158         bool (*cat(INT_unary_inc_,TYPE_INT_MAX))(const intbig_t *v1, intbig_t *r);
 159         bool (*cat(INT_unary_dec_,TYPE_INT_MAX))(const intbig_t *v1, intbig_t *r);
 160 #define f(n, s, u, sz, bits) \
 161         bool (*cat(INT_unary_bsf_,s))(const s *v1, s *r);
 162         for_all_int(f, for_all_empty)
 163 #undef f
 164 #define f(n, s, u, sz, bits) \
 165         bool (*cat(INT_unary_bsr_,s))(const s *v1, s *r);
 166         for_all_int(f, for_all_empty)
 167 #undef f
 168 #define f(n, s, u, sz, bits) \
 169         bool (*cat(INT_unary_popcnt_,s))(const s *v1, s *r);
 170         for_all_int(f, for_all_empty)
 171 #undef f
 172 #define f(n, t, nt, pack, unpack) \
 173         bool (*cat(REAL_binary_add_,t))(const t *v1, const t *v2, t *r);
 174 #define nf(n, t) \
 175         void (*cat(REAL_binary_add_,t))(void);
 176         for_all_real(f, nf)
 177 #undef f
 178 #undef nf
 179 #define f(n, t, nt, pack, unpack) \
 180         bool (*cat(REAL_binary_subtract_,t))(const t *v1, const t *v2, t *r);
 181 #define nf(n, t) \
 182         void (*cat(REAL_binary_subtract_,t))(void);
 183         for_all_real(f, nf)
 184 #undef f
 185 #undef nf
 186 #define f(n, t, nt, pack, unpack) \
 187         bool (*cat(REAL_binary_multiply_,t))(const t *v1, const t *v2, t *r);
 188 #define nf(n, t) \
 189         void (*cat(REAL_binary_multiply_,t))(void);
 190         for_all_real(f, nf)
 191 #undef f
 192 #undef nf
 193 #define f(n, t, nt, pack, unpack) \
 194         bool (*cat(REAL_binary_divide_,t))(const t *v1, const t *v2, t *r);
 195 #define nf(n, t) \
 196         void (*cat(REAL_binary_divide_,t))(void);
 197         for_all_real(f, nf)
 198 #undef f
 199 #undef nf
 200 #define f(n, t, nt, pack, unpack) \
 201         bool (*cat(REAL_binary_modulo_,t))(const t *v1, const t *v2, t *r);
 202 #define nf(n, t) \
 203         void (*cat(REAL_binary_modulo_,t))(void);
 204         for_all_real(f, nf)
 205 #undef f
 206 #undef nf
 207 #define f(n, t, nt, pack, unpack) \
 208         bool (*cat(REAL_binary_power_,t))(const t *v1, const t *v2, t *r);
 209 #define nf(n, t) \
 210         void (*cat(REAL_binary_power_,t))(void);
 211         for_all_real(f, nf)
 212 #undef f
 213 #undef nf
 214 #define f(n, t, nt, pack, unpack) \
 215         bool (*cat(REAL_binary_ldexp_,t))(const t *v1, const t *v2, t *r);
 216 #define nf(n, t) \
 217         void (*cat(REAL_binary_ldexp_,t))(void);
 218         for_all_real(f, nf)
 219 #undef f
 220 #undef nf
 221 #define f(n, t, nt, pack, unpack) \
 222         bool (*cat(REAL_binary_atan2_,t))(const t *v1, const t *v2, t *r);
 223 #define nf(n, t) \
 224         void (*cat(REAL_binary_atan2_,t))(void);
 225         for_all_real(f, nf)
 226 #undef f
 227 #undef nf
 228 #define f(n, t, nt, pack, unpack) \
 229         bool (*cat(REAL_binary_equal_,t))(const t *v1, const t *v2, ajla_flat_option_t *r);
 230 #define nf(n, t) \
 231         void (*cat(REAL_binary_equal_,t))(void);
 232         for_all_real(f, nf)
 233 #undef f
 234 #undef nf
 235 #define f(n, t, nt, pack, unpack) \
 236         bool (*cat(REAL_binary_not_equal_,t))(const t *v1, const t *v2, ajla_flat_option_t *r);
 237 #define nf(n, t) \
 238         void (*cat(REAL_binary_not_equal_,t))(void);
 239         for_all_real(f, nf)
 240 #undef f
 241 #undef nf
 242 #define f(n, t, nt, pack, unpack) \
 243         bool (*cat(REAL_binary_less_,t))(const t *v1, const t *v2, ajla_flat_option_t *r);
 244 #define nf(n, t) \
 245         void (*cat(REAL_binary_less_,t))(void);
 246         for_all_real(f, nf)
 247 #undef f
 248 #undef nf
 249 #define f(n, t, nt, pack, unpack) \
 250         bool (*cat(REAL_binary_less_equal_,t))(const t *v1, const t *v2, ajla_flat_option_t *r);
 251 #define nf(n, t) \
 252         void (*cat(REAL_binary_less_equal_,t))(void);
 253         for_all_real(f, nf)
 254 #undef f
 255 #undef nf
 256 #define f(n, t, nt, pack, unpack) \
 257         void (*cat(REAL_unary_neg_,t))(const t *v1, t *r);
 258 #define nf(n, t) \
 259         void (*cat(REAL_unary_neg_,t))(void);
 260         for_all_real(f, nf)
 261 #undef f
 262 #undef nf
 263 #define f(n, t, nt, pack, unpack) \
 264         void (*cat(REAL_unary_sqrt_,t))(const t *v1, t *r);
 265 #define nf(n, t) \
 266         void (*cat(REAL_unary_sqrt_,t))(void);
 267         for_all_real(f, nf)
 268 #undef f
 269 #undef nf
 270 #define f(n, t, nt, pack, unpack) \
 271         void (*cat(REAL_unary_cbrt_,t))(const t *v1, t *r);
 272 #define nf(n, t) \
 273         void (*cat(REAL_unary_cbrt_,t))(void);
 274         for_all_real(f, nf)
 275 #undef f
 276 #undef nf
 277 #define f(n, t, nt, pack, unpack) \
 278         void (*cat(REAL_unary_sin_,t))(const t *v1, t *r);
 279 #define nf(n, t) \
 280         void (*cat(REAL_unary_sin_,t))(void);
 281         for_all_real(f, nf)
 282 #undef f
 283 #undef nf
 284 #define f(n, t, nt, pack, unpack) \
 285         void (*cat(REAL_unary_cos_,t))(const t *v1, t *r);
 286 #define nf(n, t) \
 287         void (*cat(REAL_unary_cos_,t))(void);
 288         for_all_real(f, nf)
 289 #undef f
 290 #undef nf
 291 #define f(n, t, nt, pack, unpack) \
 292         void (*cat(REAL_unary_tan_,t))(const t *v1, t *r);
 293 #define nf(n, t) \
 294         void (*cat(REAL_unary_tan_,t))(void);
 295         for_all_real(f, nf)
 296 #undef f
 297 #undef nf
 298 #define f(n, t, nt, pack, unpack) \
 299         void (*cat(REAL_unary_asin_,t))(const t *v1, t *r);
 300 #define nf(n, t) \
 301         void (*cat(REAL_unary_asin_,t))(void);
 302         for_all_real(f, nf)
 303 #undef f
 304 #undef nf
 305 #define f(n, t, nt, pack, unpack) \
 306         void (*cat(REAL_unary_acos_,t))(const t *v1, t *r);
 307 #define nf(n, t) \
 308         void (*cat(REAL_unary_acos_,t))(void);
 309         for_all_real(f, nf)
 310 #undef f
 311 #undef nf
 312 #define f(n, t, nt, pack, unpack) \
 313         void (*cat(REAL_unary_atan_,t))(const t *v1, t *r);
 314 #define nf(n, t) \
 315         void (*cat(REAL_unary_atan_,t))(void);
 316         for_all_real(f, nf)
 317 #undef f
 318 #undef nf
 319 #define f(n, t, nt, pack, unpack) \
 320         void (*cat(REAL_unary_sinh_,t))(const t *v1, t *r);
 321 #define nf(n, t) \
 322         void (*cat(REAL_unary_sinh_,t))(void);
 323         for_all_real(f, nf)
 324 #undef f
 325 #undef nf
 326 #define f(n, t, nt, pack, unpack) \
 327         void (*cat(REAL_unary_cosh_,t))(const t *v1, t *r);
 328 #define nf(n, t) \
 329         void (*cat(REAL_unary_cosh_,t))(void);
 330         for_all_real(f, nf)
 331 #undef f
 332 #undef nf
 333 #define f(n, t, nt, pack, unpack) \
 334         void (*cat(REAL_unary_tanh_,t))(const t *v1, t *r);
 335 #define nf(n, t) \
 336         void (*cat(REAL_unary_tanh_,t))(void);
 337         for_all_real(f, nf)
 338 #undef f
 339 #undef nf
 340 #define f(n, t, nt, pack, unpack) \
 341         void (*cat(REAL_unary_asinh_,t))(const t *v1, t *r);
 342 #define nf(n, t) \
 343         void (*cat(REAL_unary_asinh_,t))(void);
 344         for_all_real(f, nf)
 345 #undef f
 346 #undef nf
 347 #define f(n, t, nt, pack, unpack) \
 348         void (*cat(REAL_unary_acosh_,t))(const t *v1, t *r);
 349 #define nf(n, t) \
 350         void (*cat(REAL_unary_acosh_,t))(void);
 351         for_all_real(f, nf)
 352 #undef f
 353 #undef nf
 354 #define f(n, t, nt, pack, unpack) \
 355         void (*cat(REAL_unary_atanh_,t))(const t *v1, t *r);
 356 #define nf(n, t) \
 357         void (*cat(REAL_unary_atanh_,t))(void);
 358         for_all_real(f, nf)
 359 #undef f
 360 #undef nf
 361 #define f(n, t, nt, pack, unpack) \
 362         void (*cat(REAL_unary_exp2_,t))(const t *v1, t *r);
 363 #define nf(n, t) \
 364         void (*cat(REAL_unary_exp2_,t))(void);
 365         for_all_real(f, nf)
 366 #undef f
 367 #undef nf
 368 #define f(n, t, nt, pack, unpack) \
 369         void (*cat(REAL_unary_exp_,t))(const t *v1, t *r);
 370 #define nf(n, t) \
 371         void (*cat(REAL_unary_exp_,t))(void);
 372         for_all_real(f, nf)
 373 #undef f
 374 #undef nf
 375 #define f(n, t, nt, pack, unpack) \
 376         void (*cat(REAL_unary_exp10_,t))(const t *v1, t *r);
 377 #define nf(n, t) \
 378         void (*cat(REAL_unary_exp10_,t))(void);
 379         for_all_real(f, nf)
 380 #undef f
 381 #undef nf
 382 #define f(n, t, nt, pack, unpack) \
 383         void (*cat(REAL_unary_log2_,t))(const t *v1, t *r);
 384 #define nf(n, t) \
 385         void (*cat(REAL_unary_log2_,t))(void);
 386         for_all_real(f, nf)
 387 #undef f
 388 #undef nf
 389 #define f(n, t, nt, pack, unpack) \
 390         void (*cat(REAL_unary_log_,t))(const t *v1, t *r);
 391 #define nf(n, t) \
 392         void (*cat(REAL_unary_log_,t))(void);
 393         for_all_real(f, nf)
 394 #undef f
 395 #undef nf
 396 #define f(n, t, nt, pack, unpack) \
 397         void (*cat(REAL_unary_log10_,t))(const t *v1, t *r);
 398 #define nf(n, t) \
 399         void (*cat(REAL_unary_log10_,t))(void);
 400         for_all_real(f, nf)
 401 #undef f
 402 #undef nf
 403 #define f(n, t, nt, pack, unpack) \
 404         void (*cat(REAL_unary_round_,t))(const t *v1, t *r);
 405 #define nf(n, t) \
 406         void (*cat(REAL_unary_round_,t))(void);
 407         for_all_real(f, nf)
 408 #undef f
 409 #undef nf
 410 #define f(n, t, nt, pack, unpack) \
 411         void (*cat(REAL_unary_ceil_,t))(const t *v1, t *r);
 412 #define nf(n, t) \
 413         void (*cat(REAL_unary_ceil_,t))(void);
 414         for_all_real(f, nf)
 415 #undef f
 416 #undef nf
 417 #define f(n, t, nt, pack, unpack) \
 418         void (*cat(REAL_unary_floor_,t))(const t *v1, t *r);
 419 #define nf(n, t) \
 420         void (*cat(REAL_unary_floor_,t))(void);
 421         for_all_real(f, nf)
 422 #undef f
 423 #undef nf
 424 #define f(n, t, nt, pack, unpack) \
 425         void (*cat(REAL_unary_trunc_,t))(const t *v1, t *r);
 426 #define nf(n, t) \
 427         void (*cat(REAL_unary_trunc_,t))(void);
 428         for_all_real(f, nf)
 429 #undef f
 430 #undef nf
 431 #define f(n, t, nt, pack, unpack) \
 432         void (*cat(REAL_unary_fract_,t))(const t *v1, t *r);
 433 #define nf(n, t) \
 434         void (*cat(REAL_unary_fract_,t))(void);
 435         for_all_real(f, nf)
 436 #undef f
 437 #undef nf
 438 #define f(n, t, nt, pack, unpack) \
 439         void (*cat(REAL_unary_mantissa_,t))(const t *v1, t *r);
 440 #define nf(n, t) \
 441         void (*cat(REAL_unary_mantissa_,t))(void);
 442         for_all_real(f, nf)
 443 #undef f
 444 #undef nf
 445 #define f(n, t, nt, pack, unpack) \
 446         void (*cat(REAL_unary_exponent_,t))(const t *v1, t *r);
 447 #define nf(n, t) \
 448         void (*cat(REAL_unary_exponent_,t))(void);
 449         for_all_real(f, nf)
 450 #undef f
 451 #undef nf
 452 #define f(n, t, nt, pack, unpack) \
 453         void (*cat(REAL_unary_next_number_,t))(const t *v1, t *r);
 454 #define nf(n, t) \
 455         void (*cat(REAL_unary_next_number_,t))(void);
 456         for_all_real(f, nf)
 457 #undef f
 458 #undef nf
 459 #define f(n, t, nt, pack, unpack) \
 460         void (*cat(REAL_unary_prev_number_,t))(const t *v1, t *r);
 461 #define nf(n, t) \
 462         void (*cat(REAL_unary_prev_number_,t))(void);
 463         for_all_real(f, nf)
 464 #undef f
 465 #undef nf
 466 #define f(n, t, nt, pack, unpack) \
 467         bool (*cat(REAL_unary_to_int_,t))(const t *val, int_default_t *r);
 468 #define nf(n, t) \
 469         void (*cat(REAL_unary_to_int_,t))(void);
 470         for_all_real(f, nf)
 471 #undef f
 472 #undef nf
 473 #define f(n, t, nt, pack, unpack) \
 474         void (*cat(REAL_unary_from_int_,t))(const int_default_t *val, t *r);
 475 #define nf(n, t) \
 476         void (*cat(REAL_unary_from_int_,t))(void);
 477         for_all_real(f, nf)
 478 #undef f
 479 #undef nf
 480 #define f(n, t, nt, pack, unpack) \
 481         void (*cat(REAL_unary_is_exception_,t))(const t *v1, ajla_flat_option_t *r);
 482 #define nf(n, t) \
 483         void (*cat(REAL_unary_is_exception_,t))(void);
 484         for_all_real(f, nf)
 485 #undef f
 486 #undef nf
 487 #endif
 488 #ifdef DEBUG_UPCALL
 489         void (*cg_upcall_debug)(unsigned long x1, unsigned long x2, unsigned long x3, unsigned long x4);
 490 #endif
 491 };
 492
 493 #undef nf
 494
 495 extern struct cg_upcall_vector_s cg_upcall_vector;
 496
 497 #define tick_stamp      (cg_upcall_vector.ts)
 498
 499 #endif