000 core.h`

1765 public symbols.

#Definition / Code Generation Macros

#`FIO_DEF_GET_FUNC_DEC`

#define FIO_DEF_GET_FUNC_DEC(static, namespace, T_type, F_type, field_name)   \
  /** Returns current value of property within the struct / union. */   \
  static F_type FIO_NAME(namespace, field_name)(T_type * o);

Declares (names) a get function for a field within a struct / union.

Note: this MACRO defines or declares code.

Symbol type: macro

#`FIO_DEF_GET_FUNC`

#define FIO_DEF_GET_FUNC(static, namespace, T_type, F_type, field_name)   \
  /** Returns current value of property within the struct / union. */   \
  static F_type FIO_NAME(namespace, field_name)(T_type * o) {   \
    FIO_ASSERT_DEBUG(o, "NULL " FIO_MACRO2STR(namespace) " pointer @ `get`!");   \
    return o->field_name;   \
  }

Defines a get function for a field within a struct / union.

Note: this MACRO defines or declares code.

Symbol type: macro

#`FIO_DEF_SET_FUNC_DEC`

#define FIO_DEF_SET_FUNC_DEC(static, namespace, T_type, F_type, F_name)   \
  /** Sets a new value, returning the old one */   \
  static F_type FIO_NAME(FIO_NAME(namespace, F_name), set)(T_type * o,   \
                                                           F_type new_value);

Declares (names) a set function for a field within a struct / union.

Note: this MACRO defines or declares code.

Symbol type: macro

#`FIO_DEF_SET_FUNC`

#define FIO_DEF_SET_FUNC(static, namespace, T_type, F_type, F_name, on_set)   \
  /** Sets a new value, returning the old one */   \
  static F_type FIO_NAME(FIO_NAME(namespace, F_name), set)(T_type * o,   \
                                                           F_type new_value) {   \
    FIO_ASSERT_DEBUG(o, "NULL " FIO_MACRO2STR(namespace) " pointer @ `set`!");   \
    F_type old_value = o->F_name;   \
    o->F_name = new_value;   \
    on_set(o);   \
    return old_value;   \
  }

Defines a set function for a field within a struct / union.

Note: this MACRO defines or declares code.

Symbol type: macro

#`FIO_DEF_GETSET_FUNC`

#define FIO_DEF_GETSET_FUNC(static, namespace, T_type, F_type, F_name, on_set)   \
  FIO_DEF_GET_FUNC(static, namespace, T_type, F_type, F_name)   \
  FIO_DEF_SET_FUNC(static, namespace, T_type, F_type, F_name, on_set)

Defines get/set functions for a field within a struct / union.

Note: this MACRO defines or declares code.

Symbol type: macro

#`FIO_DEF_GETSET_FUNC_DEC`

#define FIO_DEF_GETSET_FUNC_DEC(static, namespace, T_type, F_type, F_name)   \
  FIO_DEF_GET_FUNC_DEC(static, namespace, T_type, F_type, F_name)   \
  FIO_DEF_SET_FUNC_DEC(static, namespace, T_type, F_type, F_name)

Declares (names) get/set functions for a field within a struct / union.

Note: this MACRO defines or declares code.

Symbol type: macro

#`FIO_IFUNC_DEF_GET`

#define FIO_IFUNC_DEF_GET(namespace, T_type, F_type, field_name)   \
  FIO_DEF_GET_FUNC(FIO_IFUNC, namespace, T_type, F_type, field_name)

Defines a get function for a field within a struct / union.

Note: this MACRO defines or declares code.

Symbol type: macro

#`FIO_IFUNC_DEF_SET`

#define FIO_IFUNC_DEF_SET(namespace, T_type, F_type, F_name, on_set)   \
  FIO_DEF_SET_FUNC(FIO_IFUNC, namespace, T_type, F_type, F_name, on_set)

Defines a set function for a field within a struct / union.

Note: this MACRO defines or declares code.

Symbol type: macro

#`FIO_IFUNC_DEF_GETSET`

#define FIO_IFUNC_DEF_GETSET(namespace, T_type, F_type, F_name, on_set)   \
  FIO_IFUNC_DEF_GET(namespace, T_type, F_type, F_name)   \
  FIO_IFUNC_DEF_SET(namespace, T_type, F_type, F_name, on_set)

Defines get/set functions for a field within a struct / union.

Note: this MACRO defines or declares code.

Symbol type: macro

#`FIO_STATIC_ALLOC_DEF`

#define FIO_STATIC_ALLOC_DEF(name,   \
                             type_T,   \
                             units_per_allocation,   \
                             max_concurrent_allocations)   \
  /** Returns a slot from the `name` static arena. */   \
  FIO_SFUNC FIO_WARN_UNUSED type_T *name(size_t count) {   \
    static type_T name##buffer[sizeof(type_T) * (max_concurrent_allocations) *   \
                               (units_per_allocation)];   \
    static size_t pos;   \
    if (!count)   \
      return name##buffer;   \
    size_t at = fio_atomic_add(&pos, count);   \
    at %= (max_concurrent_allocations);   \
    return (at * (units_per_allocation)) + name##buffer;   \
  }   \
  /** Returns the logical arena capacity in `type_T` units. */   \
  FIO_IFUNC size_t name##_size(void) {   \
    return (size_t)((max_concurrent_allocations) * (units_per_allocation));   \
  }

Defines a statically backed, round-robin allocator named name.

This defines the following functions:

static type_T *name(size_t count);
static inline size_t name##_size(void);

The allocator has max_concurrent_allocations slots, each containing units_per_allocation type_T elements. name(count) returns a pointer to the slot selected by the atomic round-robin position. count advances that position by the requested number of slots; it does not change the size of the returned slot. Passing 0 returns the first slot without advancing.

The memory is static, correctly aligned for type_T, and must not be freed. name##_size() returns the logical arena capacity in type_T units:

max_concurrent_allocations * units_per_allocation

A returned slot remains valid until the allocator wraps and reuses it. Set max_concurrent_allocations for the maximum number of outstanding slots, including concurrent callers.

Example use:

// defines a static allocator for 19-character strings
FIO_STATIC_ALLOC_DEF(numer2hex_allocator,
                     char,
                     19,
                     FIO_STATIC_ALLOC_SAFE_CONCURRENCY_MAX);
// a function that returns an unsigned number as a 16 digit hex string
char *ntos16(uint16_t n) {
  char *buf = numer2hex_allocator(1);
  buf[0] = '0'; buf[1] = 'x';
  fio_ltoa16u(buf + 2, n, 16);
  buf[18] = 0;
  return buf;
}

A similar approach is used by fiobj_num2cstr for temporary FIOBJ-to-string conversions that do not require memory management.

Note: this MACRO defines or declares code.

Symbol type: macro

#`FIO_STATIC_SAFE_ALLOC_DEF`

#define FIO_STATIC_SAFE_ALLOC_DEF(name,   \
                                  type_T,   \
                                  units_per_allocation,   \
                                  max_concurrent_allocations)   \
  enum { name##__hdr_ = (int)((sizeof(type_T) < 16) ? sizeof(type_T) : 16) };   \
  typedef struct FIO_ALIGN(16) name##__slot_s {   \
    unsigned char busy_;   \
    char reserved_[name##__hdr_ - 1];   \
    type_T data_[(units_per_allocation)];   \
  } name##__slot_s;   \
  FIO_ASSERT_STATIC(offsetof(name##__slot_s, data_) == (size_t)name##__hdr_,   \
                    "FIO_STATIC_SAFE_ALLOC_DEF: slot metadata header must be"   \
                    " min(sizeof(type_T), 16) bytes");   \
  /** Checks out a slot; returns its data block, or NULL when all are busy. */   \
  FIO_SFUNC FIO_WARN_UNUSED type_T *name##_try(void) {   \
    static name##__slot_s name##buffer[(max_concurrent_allocations)];   \
    static size_t hint;   \
    size_t start = fio_atomic_add(&hint, 1);   \
    for (size_t i = 0; i < (size_t)(max_concurrent_allocations); ++i) {   \
      size_t at = (start + i) % (size_t)(max_concurrent_allocations);   \
      if (!(fio_atomic_or(&name##buffer[at].busy_, 1) & 1))   \
        return name##buffer[at].data_;   \
    }   \
    return NULL;   \
  }   \
  /** Releases a slot previously returned by name##_try. */   \
  FIO_SFUNC void name##_free(type_T *ptr) {   \
    name##__slot_s *slot =   \
        (name##__slot_s *)(void *)((char *)ptr - name##__hdr_);   \
    fio_atomic_and(&slot->busy_, 0);   \
  }   \
  /** Returns the logical arena capacity in `type_T` units. */   \
  FIO_IFUNC size_t name##_size(void) {   \
    return (size_t)((max_concurrent_allocations) * (units_per_allocation));   \
  }

FIO_STATIC_SAFE_ALLOC_DEF(name, type_T, units_per_allocation, max_concurrent_allocations)

A contention-safe variant of FIO_STATIC_ALLOC_DEF for short-lived scratch slots with an explicit checkout lifecycle. Unlike the round-robin variant (which silently reuses slots past max_concurrent_allocations), this allocator returns NULL when every slot is busy, letting callers fall back gracefully instead of corrupting an in-flight user of the slot.

Each slot carries a small metadata header holding the busy byte. The header is min(sizeof(type_T), 16) bytes: one element for small types (data naturally aligned for type_T), capped at 16 bytes for larger types (data 16-byte aligned). type_T alignment must be <= 16 (enforced at compile time).

Generated API: type_T *name##_try(void); - checkout a slot, or NULL if all busy. void name##_free(type_T *); - release a slot returned by name##_try. size_t name##_size(void); - logical arena capacity in type_T units.

Note: this MACRO defines or declares code.

Symbol type: macro

#`FIO_UXXX_X64_DEF`

#define FIO_UXXX_X64_DEF(name, bits)   \
  uint64x2_t name[(bits / 128) + (bits < 128)]

Defines a bits long vector using unsigned 64bit words

Note: this MACRO defines or declares code.

Symbol type: macro

#`FIO_UXXX_X32_DEF`

#define FIO_UXXX_X32_DEF(name, bits)   \
  uint32x4_t name[(bits / 128) + (bits < 128)]

Defines a bits long vector using unsigned 32bit words

Note: this MACRO defines or declares code.

Symbol type: macro

#`FIO_UXXX_X16_DEF`

#define FIO_UXXX_X16_DEF(name, bits)   \
  uint16x8_t name[(bits / 128) + (bits < 128)]

Defines a bits long vector using unsigned 16bit words

Note: this MACRO defines or declares code.

Symbol type: macro

#`FIO_UXXX_X8_DEF`

#define FIO_UXXX_X8_DEF(name, bits) uint8x16_t name[(bits / 128) + (bits < 128)]

Defines a bits long vector using unsigned 8bit words

Note: this MACRO defines or declares code.

Symbol type: macro

#Macros

#`FIO_NOOP`

#define FIO_NOOP

An empty macro, adding white space. Used to avoid function like macros.

Symbol type: macro

#`FIO_NOOP_FN`

#define FIO_NOOP_FN(...)

A no-op macro that takes arguments. i.e., for use in FIO_DEF_SET_FUNC

Symbol type: macro

#`FIO_NOOP_FN_NAME`

#define FIO_NOOP_FN_NAME (void)

Macro for a No-Op function name (void).

Symbol type: macro

#`FIO_VERSION_MAJOR`

#define FIO_VERSION_MAJOR 0

MAJOR version: API/ABI breaking changes.

Symbol type: macro

#`FIO_VERSION_MINOR`

#define FIO_VERSION_MINOR 8

MINOR version: Deprecation, or significant features added. May break ABI.

Symbol type: macro

#`FIO_VERSION_PATCH`

#define FIO_VERSION_PATCH 0

PATCH version: Bug fixes, minor features may be added.

Symbol type: macro

#`FIO_VERSION_BUILD`

#define FIO_VERSION_BUILD "rc.03"

Build version: optional build info (string), i.e. "beta.02"

Symbol type: macro

#`FIO_VERSION_STRING`

#define FIO_VERSION_STRING   \
  FIO_MACRO2STR(FIO_VERSION_MAJOR)   \
  "." FIO_MACRO2STR(FIO_VERSION_MINOR) "." FIO_MACRO2STR(   \
      FIO_VERSION_PATCH) "-" FIO_VERSION_BUILD

Version as a String literal (MACRO).

Symbol type: macro

#`FIO_LEAK_COUNTER`

#define FIO_LEAK_COUNTER 1

Enables memory leak detection. Disable by setting this to zero.

Symbol type: macro

#`FIO_USE_THREAD_MUTEX`

#define FIO_USE_THREAD_MUTEX 0

Selects between facio.io's spinlocks (false) and OS mutexes (true)

Symbol type: macro

#`FIO_UNALIGNED_ACCESS`

#define FIO_UNALIGNED_ACCESS 1

Allows facil.io to attempt unaligned memory access on some CPU systems.

Symbol type: macro

#`FIO_LIMIT_INTRINSIC_BUFFER`

#define FIO_LIMIT_INTRINSIC_BUFFER 1

Limits register consumption on some pseudo-intrinsics, using more loops

Symbol type: macro

#`FIO_MEMORY_INITIALIZE_ALLOCATIONS_DEFAULT`

#define FIO_MEMORY_INITIALIZE_ALLOCATIONS_DEFAULT 1

Memory allocations should be secure by default (facil.io allocators only)

Symbol type: macro

#`FIO_MEM_PAGE_SIZE_LOG`

#define FIO_MEM_PAGE_SIZE_LOG 12 /* assumes 4096 bytes per page */

Compile-time memory page size log (12 == 4096 bytes).

Symbol type: macro

#`FIO_MAP_WARNING_BITSIZE`

#define FIO_MAP_WARNING_BITSIZE ((size_t)24)

iMap and Map allocation size warning (log2), 24 == 16Mb.

Symbol type: macro

#`FIO_ALIGN`

#define FIO_ALIGN(bytes) __attribute__((aligned(bytes)))

Sets alignment is supported by compiler.

Symbol type: macro

#`FIO_COMPILER_GUARD`

#define FIO_COMPILER_GUARD __asm__ volatile("" ::: "memory")

Clobber CPU registers and prevent compiler reordering optimizations.

Symbol type: macro

#`FIO_COMPILER_GUARD_INSTRUCTION`

#define FIO_COMPILER_GUARD_INSTRUCTION __asm__ volatile("" :::)

Prevent compiler reordering optimizations.

Symbol type: macro

#`FIO_UNALIGNED_MEMORY_ACCESS_ENABLED`

#define FIO_UNALIGNED_MEMORY_ACCESS_ENABLED 1

True when unaligned memory is allowed.

Symbol type: macro

#`FIO_OS_POSIX`

#define FIO_OS_POSIX 0

Always defined, true on POSIX systems.

Symbol type: macro

#`FIO_OS_WIN`

#define FIO_OS_WIN 0

Always defined, true on Windows systems.

Symbol type: macro

#`FIO_KILL_SELF`

#define FIO_KILL_SELF() GenerateConsoleCtrlEvent(CTRL_C_EVENT, 0)

Sends a signal to kill the current process (emulates CTRL + C).

Symbol type: macro

#`FIO_HAVE_UNIX_TOOLS`

#define FIO_HAVE_UNIX_TOOLS    2

True if POSIX headers are available.

Symbol type: macro

#`FIO_SIZE_T_ERROR`

#define FIO_SIZE_T_ERROR (~(size_t)0)

The -1 value for a size_t type, often used as an error value.

Symbol type: macro

#`FIO_MAYBE_UNUSED`

#define FIO_MAYBE_UNUSED __attribute__((unused))

Marks a variable / function as possibly unused (if compiler supported).

Symbol type: macro

#`FIO_SFUNC`

#define FIO_SFUNC static FIO_MAYBE_UNUSED

static, possibly unused, function.

Symbol type: macro

#`FIO_IFUNC`

#define FIO_IFUNC FIO_SFUNC inline

Marks a function as static, inline and possibly unused.

Symbol type: macro

#`FIO_WARN_UNUSED`

#define FIO_WARN_UNUSED __attribute__((warn_unused_result))

Attribute for functions whose return value should not be ignored.

Symbol type: macro

#`FIO_MIFN`

#define FIO_MIFN FIO_IFUNC FIO_WARN_UNUSED

Marks a function as inline with warn_unused_result (for math functions).

Symbol type: macro

#`FIO_CONST`

#define FIO_CONST __attribute__((const))

Marks a function as const (no side effects, result depends only on args)

Symbol type: macro

#`FIO_PURE`

#define FIO_PURE __attribute__((pure))

Marks a function as pure (no side effects, may read global memory)

Symbol type: macro

#`FIO_WEAK`

#define FIO_WEAK __attribute__((weak))

Marks a function as weak

Symbol type: macro

#`FIO_WEAK_VAR`

#define FIO_WEAK_VAR __declspec(selectany)

Marks a global variable as weak

Symbol type: macro

#`FIO_CONSTRUCTOR`

#define FIO_CONSTRUCTOR(fname)   \
  static __attribute__((constructor)) void fname(void)

Marks a function as a constructor - if supported.

Symbol type: macro

#`FIO_DESTRUCTOR`

#define FIO_DESTRUCTOR(fname)   \
  static __attribute__((destructor)) void fname(void)

Marks a function as a destructor - if supported. Consider using atexit()

Symbol type: macro

#`FIO_LIKELY`

#define FIO_LIKELY(cond) __builtin_expect((cond), 1)

Provides a compiler hint for value likelihood, if possible.

Symbol type: macro

#`FIO_UNLIKELY`

#define FIO_UNLIKELY(cond) __builtin_expect((cond), 0)

Provides a compiler hint for value likelihood, if possible.

Symbol type: macro

#`FIO_PREFETCH`

#define FIO_PREFETCH(ptr) __builtin_prefetch((ptr), 0, 3)

Prefetch data for reading into all cache levels.

Symbol type: macro

#`FIO_PREFETCH_W`

#define FIO_PREFETCH_W(ptr) __builtin_prefetch((ptr), 1, 3)

Prefetch data for writing (exclusive cache line ownership).

Symbol type: macro

#`FIO_PREFETCH_NT`

#define FIO_PREFETCH_NT(ptr) __builtin_prefetch((ptr), 0, 0)

Prefetch non-temporal (streaming data, minimize cache pollution).

Symbol type: macro

#`FIO_MACRO2STR`

#define FIO_MACRO2STR(macro) FIO___MACRO2STR_STEP2(macro)

Converts a macro's content to a string literal.

Symbol type: macro

#`FIO_NAME`

#define FIO_NAME(prefix, postfix)   \
  FIO___NAME_FROM_MACRO_STEP1(prefix, postfix, _)

Used for naming functions and variables resulting in: prefix_postfix

Symbol type: macro

#`FIO_NAME2`

#define FIO_NAME2(prefix, postfix)   \
  FIO___NAME_FROM_MACRO_STEP1(prefix, postfix, 2)

Sets naming convention for conversion functions, i.e.: foo2bar

Symbol type: macro

#`FIO_NAME_BL`

#define FIO_NAME_BL(prefix, postfix)   \
  FIO___NAME_FROM_MACRO_STEP1(prefix, postfix, _is_)

Sets naming convention for boolean testing functions, i.e.: foo_is_true

Symbol type: macro

#`FIO_NAME_TEST`

#define FIO_NAME_TEST(prefix, postfix)   \
  FIO_NAME(fio___test, FIO_NAME(prefix, postfix))

Used internally to name test functions.

Symbol type: macro

#`FIO_PTR_MATH_LMASK`

#define FIO_PTR_MATH_LMASK(T_type, ptr, bits)   \
  ((T_type *)(((uintptr_t)(ptr)) & (((uintptr_t)1ULL << (bits)) - 1)))

Masks a pointer's left-most bits, returning the right bits.

Symbol type: macro

#`FIO_PTR_MATH_RMASK`

#define FIO_PTR_MATH_RMASK(T_type, ptr, bits)   \
  ((T_type *)(((uintptr_t)(ptr)) & ((~(uintptr_t)0ULL) << (bits))))

Masks a pointer's right-most bits, returning the left bits.

Symbol type: macro

#`FIO_PTR_MATH_ADD`

#define FIO_PTR_MATH_ADD(T_type, ptr, offset)   \
  ((T_type *)((uintptr_t)(ptr) + (uintptr_t)(offset)))

Add offset bytes to pointer, updating the pointer's type.

Symbol type: macro

#`FIO_PTR_MATH_SUB`

#define FIO_PTR_MATH_SUB(T_type, ptr, offset)   \
  ((T_type *)((uintptr_t)(ptr) - (uintptr_t)(offset)))

Subtract X bytes from pointer, updating the pointer's type.

Symbol type: macro

#`FIO_PTR_FIELD_OFFSET`

#define FIO_PTR_FIELD_OFFSET(T_type, field)   \
  ((uintptr_t)((&((T_type *)0xFF00)->field)) - 0xFF00)

Find the root object (of a struct) from it's field (with sanitizer fix).

Symbol type: macro

#`FIO_PTR_FROM_FIELD`

#define FIO_PTR_FROM_FIELD(T_type, field, ptr)   \
  FIO_PTR_MATH_SUB(T_type, ptr, FIO_PTR_FIELD_OFFSET(T_type, field))

Find the root object (of a struct) from it's field (with sanitizer fix).

Symbol type: macro

#`FIO_THREAD_WAIT`

#define FIO_THREAD_WAIT(nano_sec)   \
  do {   \
    Sleep(((nano_sec) / 1000000) ? ((nano_sec) / 1000000) : 1);   \
  } while (0)

Calls NtDelayExecution with the requested nano-second count.

Symbol type: macro

#`FIO_THREAD_YIELD`

#define FIO_THREAD_YIELD() __asm__ __volatile__("pause" ::: "memory")

Yields the thread, hinting to the processor about spinlock loop.

Symbol type: macro

#`FIO_THREAD_RESCHEDULE`

#define FIO_THREAD_RESCHEDULE() FIO_THREAD_WAIT(4)

Reschedules the thread by calling nanosleeps for nano-seconds.

In practice, the thread will probably sleep for 60ns or more.

Seems to be faster then thread_yield, perhaps it prevents de-prioritization of the thread.

Symbol type: macro

#`FIO_LOCK_INIT`

#define FIO_LOCK_INIT 0

Initialization value for a spin lock.

Symbol type: macro

#`FIO_LOCK_SUBLOCK`

#define FIO_LOCK_SUBLOCK(sub) ((uint8_t)(1U) << ((sub)&7))

A numbered sub-lock index, must be less than 8. Zero == the master lock.

Symbol type: macro

#`FIO_STATIC_ALLOC_SAFE_CONCURRENCY_MAX`

#define FIO_STATIC_ALLOC_SAFE_CONCURRENCY_MAX 256

Default slot count used by selected internal static allocators.

Symbol type: macro

#`FIO_LOG_LEVEL_NONE`

#define FIO_LOG_LEVEL_NONE 0

Logging level of zero (no logging).

Symbol type: macro

#`FIO_LOG_LEVEL_FATAL`

#define FIO_LOG_LEVEL_FATAL 1

Log fatal errors.

Symbol type: macro

#`FIO_LOG_LEVEL_ERROR`

#define FIO_LOG_LEVEL_ERROR 2

Log errors and fatal errors.

Symbol type: macro

#`FIO_LOG_LEVEL_WARNING`

#define FIO_LOG_LEVEL_WARNING 3

Log warnings, errors and fatal errors.

Symbol type: macro

#`FIO_LOG_LEVEL_INFO`

#define FIO_LOG_LEVEL_INFO 4

Log every message (info, warnings, errors and fatal errors).

Symbol type: macro

#`FIO_LOG_LEVEL_DEBUG`

#define FIO_LOG_LEVEL_DEBUG 5

Log everything, including debug messages.

Symbol type: macro

#`FIO_LOG_LEVEL_SET`

#define FIO_LOG_LEVEL_SET(new_level) (0)

Sets the Logging Level

Symbol type: macro

#`FIO_LOG_LEVEL_GET`

#define FIO_LOG_LEVEL_GET() (0)

Returns the Logging Level

Symbol type: macro

#`FIO_LOG_WRITE`

#define FIO_LOG_WRITE(...)    FIO_LOG2STDERR("(" FIO___FILE__ ":" FIO_MACRO2STR(__LINE__) "): " __VA_ARGS__)

Writes a message to the log, including the file name and line number.

Symbol type: macro

#`FIO_LOG_FATAL`

#define FIO_LOG_FATAL(...)    FIO___LOG_PRINT_LEVEL(FIO_LOG_LEVEL_FATAL, "\x1B[1m\x1B[7mFATAL:\x1B[0m    " __VA_ARGS__)

Writes a Fatal message to the log.

Symbol type: macro

#`FIO_LOG_ERROR`

#define FIO_LOG_ERROR(...)    FIO___LOG_PRINT_LEVEL(FIO_LOG_LEVEL_ERROR, "\x1B[1mERROR:\x1B[0m    " __VA_ARGS__)

Writes a Error message to the log.

Symbol type: macro

#`FIO_LOG_SECURITY`

#define FIO_LOG_SECURITY(...) FIO___LOG_PRINT_LEVEL(FIO_LOG_LEVEL_ERROR, "\x1B[1mSECURITY:\x1B[0m " __VA_ARGS__)

Writes a Security message to the log.

Symbol type: macro

#`FIO_LOG_WARNING`

#define FIO_LOG_WARNING(...)  FIO___LOG_PRINT_LEVEL(FIO_LOG_LEVEL_WARNING, "\x1B[2mWARNING:\x1B[0m  " __VA_ARGS__)

Writes a Warning message to the log.

Symbol type: macro

#`FIO_LOG_INFO`

#define FIO_LOG_INFO(...)     FIO___LOG_PRINT_LEVEL(FIO_LOG_LEVEL_INFO, "INFO:     " __VA_ARGS__)

Writes a Info message to the log.

Symbol type: macro

#`FIO_LOG_DEBUG`

#define FIO_LOG_DEBUG(...)    FIO___LOG_PRINT_LEVEL(FIO_LOG_LEVEL_DEBUG,"DEBUG:    (" FIO___FILE__ ":" FIO_MACRO2STR(__LINE__) ") " __VA_ARGS__)

Writes a Debug message to the log, including the file name and line number.

Symbol type: macro

#`FIO_LOG_DEBUG2`

#define FIO_LOG_DEBUG2(...)   FIO___LOG_PRINT_LEVEL(FIO_LOG_LEVEL_DEBUG, "DEBUG:    " __VA_ARGS__)

Writes a Debug message to the log.

Symbol type: macro

#`FIO_LOG_DDEBUG`

#define FIO_LOG_DDEBUG(...) FIO_LOG_DEBUG(__VA_ARGS__)

Writes a Debug message to the log only if DEBUG was defined.

Symbol type: macro

#`FIO_LOG_DDEBUG2`

#define FIO_LOG_DDEBUG2(...) FIO_LOG_DEBUG2(__VA_ARGS__)

Writes a Debug2 message to the log only if DEBUG was defined.

Symbol type: macro

#`FIO_LOG_DERROR`

#define FIO_LOG_DERROR(...) FIO_LOG_ERROR(__VA_ARGS__)

Writes a Error message to the log only if DEBUG was defined.

Symbol type: macro

#`FIO_LOG_DSECURITY`

#define FIO_LOG_DSECURITY(...) FIO_LOG_SECURITY(__VA_ARGS__)

Writes a Security message to the log only if DEBUG was defined.

Symbol type: macro

#`FIO_LOG_DWARNING`

#define FIO_LOG_DWARNING(...) FIO_LOG_WARNING(__VA_ARGS__)

Writes a Warning message to the log only if DEBUG was defined.

Symbol type: macro

#`FIO_LOG_DINFO`

#define FIO_LOG_DINFO(...)            FIO_LOG_INFO(__VA_ARGS__)

Writes a Info message to the log only if DEBUG was defined.

Symbol type: macro

#`FIO_LOG_LENGTH_LIMIT`

#define FIO_LOG_LENGTH_LIMIT 1024

Defines a point at which logging truncates (limits stack memory use)

Symbol type: macro

#`FIO_LOG2STDERR`

#define FIO_LOG2STDERR(...)

Prints to STDERR, attempting to use only stack allocated memory.

Symbol type: macro

#`FIO_STDERR_FILE`

#define FIO_STDERR_FILE stderr

Symbol type: macro

#`FIO_ASSERT`

#define FIO_ASSERT(cond, ...)   \
  do {   \
    if (FIO_UNLIKELY(!(cond))) {   \
      FIO_LOG_FATAL(__VA_ARGS__);   \
      FIO_LOG_FATAL("     errno(%d): %s\n", errno, strerror(errno));   \
      fflush(FIO_STDERR_FILE);   \
      FIO___ASSERT_PERFORM_SIGNAL();   \
      exit(-1);   \
    }   \
  } while (0)

Asserts a condition is true, or kills the application using SIGINT.

Symbol type: macro

#`FIO_ASSERT_ALLOC`

#define FIO_ASSERT_ALLOC(ptr) FIO_ASSERT((ptr), "memory allocation failed.")

Tests for an allocation failure. The behavior can be overridden.

Symbol type: macro

#`FIO_ASSERT_DEBUG`

#define FIO_ASSERT_DEBUG(cond, ...)   \
  do {   \
    if (!(cond)) {   \
      FIO_LOG_FATAL("(" FIO___FILE__   \
                    ":" FIO_MACRO2STR(__LINE__) ") " __VA_ARGS__);   \
      FIO_LOG_FATAL("     errno(%d): %s\n", errno, strerror(errno));   \
      fflush(FIO_STDERR_FILE);   \
      FIO___ASSERT_PERFORM_SIGNAL();   \
      exit(-1);   \
    }   \
  } while (0)

If DEBUG is defined, raises SIGINT if assertion fails, otherwise NOOP.

Symbol type: macro

#`FIO_ASSERT_STATIC`

#define FIO_ASSERT_STATIC(cond, msg) _Static_assert((cond), msg)

Perform a static (build time) assertion.

Symbol type: macro

#`FIO_MEM_STACK_WIPE`

#define FIO_MEM_STACK_WIPE(pages)   \
  do {   \
    volatile char stack_mem[(pages) << 12] = {0};   \
    (void)stack_mem;   \
  } while (0)

Places pages x 4096 bytes of zero (0) on the stack.

Symbol type: macro

#`FIO_MEMCPY`

#define FIO_MEMCPY fio_memcpy

Use this macro instead of memcpy, for easy implementation overriding.

Symbol type: macro

#`FIO_MEMMOVE`

#define FIO_MEMMOVE fio_memcpy

Use this macro instead of memmove, for easy implementation overriding.

Symbol type: macro

#`FIO_MEMCMP`

#define FIO_MEMCMP fio_memcmp

Use this macro instead of memcmp, for easy implementation overriding.

Symbol type: macro

#`FIO_MEMCHR`

#define FIO_MEMCHR fio_memchr

Use this macro instead of memchr, for easy implementation overriding.

Symbol type: macro

#`FIO_MEMSET`

#define FIO_MEMSET fio_memset

Use this macro instead of memset, for easy implementation overriding.

Symbol type: macro

#`FIO_STRLEN`

#define FIO_STRLEN fio_strlen

Use this macro instead of strlen, for easy implementation overriding.

Symbol type: macro

#`FIO_FOR`

#define FIO_FOR(i, count) for (size_t i = 0; i < (count); ++i)

Helper for simple for loops, where i is the variable name to use.

Symbol type: macro

#`FIO_FOR_UNROLL_GROUP_SIZE`

#define FIO_FOR_UNROLL_GROUP_SIZE ((size_t)256U)

The byte stride used by FIO_FOR_UNROLL for compiler-friendly batches.

Most CPUs should be able to hold at least 512 bytes in their registers. The default value assumes half that is available for the optimized loop, as the action within each loop will likely require some available registers.

Symbol type: macro

#`FIO_FOR_UNROLL`

#define FIO_FOR_UNROLL(iterations, size_of_loop, i, action)   \
  do {   \
    size_t i = 0;   \
    const size_t fio___unroll_remainder__ =   \
        ((iterations) & ((FIO_FOR_UNROLL_GROUP_SIZE / (size_of_loop)) - 1));   \
    /* handle odd length vectors, not multiples of FIO___LOG2V */   \
    if (fio___unroll_remainder__ && ((iterations) + 1))   \
      for (; i < fio___unroll_remainder__; ++i)   \
        action;   \
    if (iterations)   \
      for (; !((iterations) + 1) || (i < (iterations));) {   \
        for (size_t j__loop__ = 0;   \
             j__loop__ < (FIO_FOR_UNROLL_GROUP_SIZE / (size_of_loop));   \
             ++j__loop__, ++i) /* dear compiler, please vectorize */   \
          action;   \
      }   \
  } while (0)

Unrolled for loop - separates for loops to make it easier for the compiler to optimize.

Parameters:

iterations - the number of loop iterations to perform
size_of_loop - the number of bytes consumed by each action
i - the loop index variable name to use (accessible by action)
action - an action to be performed each iteration (can be a macro)

Note that action is NOT guarded. In the following strlen example, the if statement will run only after each SIMD loop has ended, allowing the compiler to unroll the loops:

  size_t has_zero = 0;
  const size_t iterations = ((~(uintptr_t)str) + 1) | (1ULL << 31);
#define FIO___STRLEN_ACTION
  has_zero += (!str[i] | !!has_zero);
  if (has_zero)
    return i - has_zero;
  FIO_FOR_UNROLL(iterations, 1, i, FIO___STRLEN_ACTION);
#undef FIO___STRLEN_ACTION
  return ~(size_t)0;

Symbol type: macro

#`FIO_LEAK_COUNTER_SKIP_EXIT`

#define FIO_LEAK_COUNTER_SKIP_EXIT 0

If set, no FIO_CALL_AFTER_EXIT leak reporting event is registered.

Symbol type: macro

#`FIO_SHIFT_FORWARDS`

#define FIO_SHIFT_FORWARDS(i, bits) ((i) >> (bits))

An endianess dependent shift operation, moves bits forwards.

Symbol type: macro

#`FIO_SHIFT_BACKWARDS`

#define FIO_SHIFT_BACKWARDS(i, bits) ((i) << (bits))

An endianess dependent shift operation, moves bits backwards.

Symbol type: macro

#`FIO_LIST_NODE`

#define FIO_LIST_NODE fio_list_node_s

A linked list node type

Symbol type: macro

#`FIO_LIST_HEAD`

#define FIO_LIST_HEAD fio_list_node_s

A linked list head type

Symbol type: macro

#`FIO_LIST_INIT`

#define FIO_LIST_INIT(obj)   \
  (fio_list_node_s) { .next = &(obj), .prev = &(obj) }

Allows initialization of FIO_LIST_HEAD objects.

Symbol type: macro

#`FIO_LIST_EACH`

#define FIO_LIST_EACH(type, node_name, head, pos)   \
  for (type *pos = FIO_PTR_FROM_FIELD(type, node_name, (head)->next),   \
            *next____p_ls_##pos =   \
                FIO_PTR_FROM_FIELD(type, node_name, (head)->next->next);   \
       pos != FIO_PTR_FROM_FIELD(type, node_name, (head));   \
       (pos = next____p_ls_##pos),   \
            (next____p_ls_##pos =   \
                 FIO_PTR_FROM_FIELD(type,   \
                                    node_name,   \
                                    next____p_ls_##pos->node_name.next)))

Loops through every node in the linked list except the head.

Symbol type: macro

#`FIO_LIST_EACH_REVERSED`

#define FIO_LIST_EACH_REVERSED(type, node_name, head, pos)   \
  for (type *pos = FIO_PTR_FROM_FIELD(type, node_name, (head)->prev),   \
            *next____p_ls_##pos =   \
                FIO_PTR_FROM_FIELD(type, node_name, (head)->next->prev);   \
       pos != FIO_PTR_FROM_FIELD(type, node_name, (head));   \
       (pos = next____p_ls_##pos),   \
            (next____p_ls_##pos =   \
                 FIO_PTR_FROM_FIELD(type,   \
                                    node_name,   \
                                    next____p_ls_##pos->node_name.prev)))

Loops through every node in the linked list except the head.

Symbol type: macro

#`FIO_LIST_PUSH`

#define FIO_LIST_PUSH(head, n)   \
  do {   \
    (n)->prev = (head)->prev;   \
    (n)->next = (head);   \
    (head)->prev->next = (n);   \
    (head)->prev = (n);   \
  } while (0)

UNSAFE macro for pushing a node to a list.

Symbol type: macro

#`FIO_LIST_REMOVE`

#define FIO_LIST_REMOVE(n)   \
  do {   \
    (n)->prev->next = (n)->next;   \
    (n)->next->prev = (n)->prev;   \
  } while (0)

UNSAFE macro for removing a node from a list.

Symbol type: macro

#`FIO_LIST_REMOVE_RESET`

#define FIO_LIST_REMOVE_RESET(n)   \
  do {   \
    (n)->prev->next = (n)->next;   \
    (n)->next->prev = (n)->prev;   \
    (n)->next = (n)->prev = (n);   \
  } while (0)

UNSAFE macro for removing a node from a list. Resets node data.

Symbol type: macro

#`FIO_LIST_POP`

#define FIO_LIST_POP(type, node_name, dest_ptr, head)   \
  do {   \
    (dest_ptr) = FIO_PTR_FROM_FIELD(type, node_name, ((head)->next));   \
    FIO_LIST_REMOVE(&(dest_ptr)->node_name);   \
  } while (0)

UNSAFE macro for popping a node to a list.

Symbol type: macro

#`FIO_LIST_IS_EMPTY`

#define FIO_LIST_IS_EMPTY(head)   \
  ((!(head)) || ((!(head)->next) | ((head)->next == (head))))

UNSAFE macro for testing if a list is empty.

Symbol type: macro

#`FIO_INDEXED_LIST32_NODE`

#define FIO_INDEXED_LIST32_NODE fio_index32_node_s

A 32 bit indexed linked list node type

Symbol type: macro

#`FIO_INDEXED_LIST32_HEAD`

#define FIO_INDEXED_LIST32_HEAD uint32_t

Symbol type: macro

#`FIO_INDEXED_LIST16_NODE`

#define FIO_INDEXED_LIST16_NODE fio_index16_node_s

A 16 bit indexed linked list node type

Symbol type: macro

#`FIO_INDEXED_LIST16_HEAD`

#define FIO_INDEXED_LIST16_HEAD uint16_t

Symbol type: macro

#`FIO_INDEXED_LIST8_NODE`

#define FIO_INDEXED_LIST8_NODE fio_index8_node_s

An 8 bit indexed linked list node type

Symbol type: macro

#`FIO_INDEXED_LIST8_HEAD`

#define FIO_INDEXED_LIST8_HEAD uint8_t

Symbol type: macro

#`FIO_INDEXED_LIST_PUSH`

#define FIO_INDEXED_LIST_PUSH(root, node_name, head, i)   \
  do {   \
    register const size_t n__ = (i);   \
    (root)[n__].node_name.prev = (root)[(head)].node_name.prev;   \
    (root)[n__].node_name.next = (head);   \
    (root)[(root)[(head)].node_name.prev].node_name.next = (n__);   \
    (root)[(head)].node_name.prev = (n__);   \
  } while (0)

UNSAFE macro for pushing a node to a list.

Symbol type: macro

#`FIO_INDEXED_LIST_UNSHIFT`

#define FIO_INDEXED_LIST_UNSHIFT(root, node_name, head, i)   \
  do {   \
    register const size_t n__ = (i);   \
    (root)[n__].node_name.next = (root)[(head)].node_name.next;   \
    (root)[n__].node_name.prev = (head);   \
    (root)[(root)[(head)].node_name.next].node_name.prev = (n__);   \
    (root)[(head)].node_name.next = (n__);   \
    (head) = (n__);   \
  } while (0)

UNSAFE macro for adding a node to the begging of the list.

Symbol type: macro

#`FIO_INDEXED_LIST_REMOVE`

#define FIO_INDEXED_LIST_REMOVE(root, node_name, i)   \
  do {   \
    register const size_t n__ = (i);   \
    (root)[(root)[n__].node_name.prev].node_name.next =   \
        (root)[n__].node_name.next;   \
    (root)[(root)[n__].node_name.next].node_name.prev =   \
        (root)[n__].node_name.prev;   \
  } while (0)

UNSAFE macro for removing a node from a list.

Symbol type: macro

#`FIO_INDEXED_LIST_REMOVE_RESET`

#define FIO_INDEXED_LIST_REMOVE_RESET(root, node_name, i)   \
  do {   \
    register const size_t n__ = (i);   \
    (root)[(root)[n__].node_name.prev].node_name.next =   \
        (root)[n__].node_name.next;   \
    (root)[(root)[n__].node_name.next].node_name.prev =   \
        (root)[n__].node_name.prev;   \
    (root)[n__].node_name.next = (root)[n__].node_name.prev = (n__);   \
  } while (0)

UNSAFE macro for removing a node from a list. Resets node data.

Symbol type: macro

#`FIO_INDEXED_LIST_EACH`

#define FIO_INDEXED_LIST_EACH(root, node_name, head, pos)   \
  for (size_t pos = (head),   \
              stooper___hd = (head),   \
              stopper___ils___ = 0,   \
              pos##___nxt = (root)[(head)].node_name.next;   \
       !stopper___ils___;   \
       (stopper___ils___ = ((pos = pos##___nxt) == stooper___hd)),   \
              pos##___nxt = (root)[pos].node_name.next)

Loops through every index in the indexed list, assuming head is valid.

Symbol type: macro

#`FIO_INDEXED_LIST_EACH_REVERSED`

#define FIO_INDEXED_LIST_EACH_REVERSED(root, node_name, head, pos)   \
  for (size_t pos = ((root)[(head)].node_name.prev),   \
              pos##___nxt =   \
                  ((root)[((root)[(head)].node_name.prev)].node_name.prev),   \
              stooper___hd = (head),   \
              stopper___ils___ = 0;   \
       !stopper___ils___;   \
       ((stopper___ils___ = (pos == stooper___hd)),   \
        (pos = pos##___nxt),   \
        (pos##___nxt = (root)[pos##___nxt].node_name.prev)))

Loops through every index in the indexed list, assuming head is valid.

Symbol type: macro

#`FIO_LROT`

#define FIO_LROT(i, bits)   \
  (((i) << ((bits) & ((sizeof((i)) << 3) - 1))) |   \
   ((i) >> (((uint8_t)(-(bits))) & ((sizeof((i)) << 3) - 1))))

Left rotation for an unknown size element, inlined.

Symbol type: macro

#`FIO_RROT`

#define FIO_RROT(i, bits)   \
  (((i) >> ((bits) & ((sizeof((i)) << 3) - 1))) |   \
   ((i) << (((uint8_t)(-(bits))) & ((sizeof((i)) << 3) - 1))))

Right rotation for an unknown size element, inlined.

Symbol type: macro

#`FIO_HAS_ZERO_BYTE64`

#define FIO_HAS_ZERO_BYTE64(row)   \
  (((row)-UINT64_C(0x0101010101010101)) &   \
   ((~(row)) & UINT64_C(0x8080808080808080)))

Symbol type: macro

#`FIO_HAS_FULL_BYTE64`

#define FIO_HAS_FULL_BYTE64(row)   \
  ((((row)&UINT64_C(0x7F7F7F7F7F7F7F7F)) + UINT64_C(0x0101010101010101)) &   \
   (row)&UINT64_C(0x8080808080808080))

Symbol type: macro

#`FIO_HAS_BYTE2BITMAP`

#define FIO_HAS_BYTE2BITMAP(result, bit_index)   \
  do {   \
    (result) = fio_ltole64((result)); /* map little endian to bitmap */   \
    (result) >>= bit_index;           /* move bit index to 0x01 */   \
    (result) |= (result) >> 7;        /* pack all 0x80 bits into one byte */   \
    (result) |= (result) >> 14;   \
    (result) |= (result) >> 28;   \
    (result) &= 0xFFU;   \
  } while (0)

Converts a FIO_HAS_FULL_BYTE64 result to relative position bitmap.

Symbol type: macro

#`FIO_U8_HASH_PRIME0`

#define FIO_U8_HASH_PRIME0   0x17U   /* (4/6) 00010111 */

Symbol type: macro

#`FIO_U8_HASH_PRIME1`

#define FIO_U8_HASH_PRIME1   0x1DU   /* (4/6) 00011101 */

Symbol type: macro

#`FIO_U8_HASH_PRIME2`

#define FIO_U8_HASH_PRIME2   0x25U   /* (3/6) 00100101 */

Symbol type: macro

#`FIO_U8_HASH_PRIME3`

#define FIO_U8_HASH_PRIME3   0x29U   /* (3/6) 00101001 */

Symbol type: macro

#`FIO_U8_HASH_PRIME4`

#define FIO_U8_HASH_PRIME4   0x2BU   /* (4/6) 00101011 */

Symbol type: macro

#`FIO_U8_HASH_PRIME5`

#define FIO_U8_HASH_PRIME5   0x35U   /* (4/6) 00110101 */

Symbol type: macro

#`FIO_U8_HASH_PRIME6`

#define FIO_U8_HASH_PRIME6   0x3BU   /* (5/6) 00111011 */

Symbol type: macro

#`FIO_U8_HASH_PRIME7`

#define FIO_U8_HASH_PRIME7   0x43U   /* (3/8) 01000011 */

Symbol type: macro

#`FIO_U8_HASH_PRIME8`

#define FIO_U8_HASH_PRIME8   0x47U   /* (4/8) 01000111 */

Symbol type: macro

#`FIO_U8_HASH_PRIME9`

#define FIO_U8_HASH_PRIME9   0x49U   /* (3/8) 01001001 */

Symbol type: macro

#`FIO_U8_HASH_PRIME10`

#define FIO_U8_HASH_PRIME10  0x53U   /* (4/8) 01010011 */

Symbol type: macro

#`FIO_U8_HASH_PRIME11`

#define FIO_U8_HASH_PRIME11  0x59U   /* (4/8) 01011001 */

Symbol type: macro

#`FIO_U8_HASH_PRIME12`

#define FIO_U8_HASH_PRIME12  0x61U   /* (3/8) 01100001 */

Symbol type: macro

#`FIO_U8_HASH_PRIME13`

#define FIO_U8_HASH_PRIME13  0x65U   /* (4/8) 01100101 */

Symbol type: macro

#`FIO_U8_HASH_PRIME14`

#define FIO_U8_HASH_PRIME14  0x67U   /* (5/8) 01100111 */

Symbol type: macro

#`FIO_U8_HASH_PRIME15`

#define FIO_U8_HASH_PRIME15  0x6BU   /* (5/8) 01101011 */

Symbol type: macro

#`FIO_U8_HASH_PRIME16`

#define FIO_U8_HASH_PRIME16  0x6DU   /* (5/8) 01101101 */

Symbol type: macro

#`FIO_U8_HASH_PRIME17`

#define FIO_U8_HASH_PRIME17  0x83U   /* (3/8) 10000011 */

Symbol type: macro

#`FIO_U8_HASH_PRIME18`

#define FIO_U8_HASH_PRIME18  0x89U   /* (3/8) 10001001 */

Symbol type: macro

#`FIO_U8_HASH_PRIME19`

#define FIO_U8_HASH_PRIME19  0x8BU   /* (4/8) 10001011 */

Symbol type: macro

#`FIO_U8_HASH_PRIME20`

#define FIO_U8_HASH_PRIME20  0x95U   /* (4/8) 10010101 */

Symbol type: macro

#`FIO_U8_HASH_PRIME21`

#define FIO_U8_HASH_PRIME21  0x97U   /* (5/8) 10010111 */

Symbol type: macro

#`FIO_U8_HASH_PRIME22`

#define FIO_U8_HASH_PRIME22  0x9DU   /* (5/8) 10011101 */

Symbol type: macro

#`FIO_U8_HASH_PRIME23`

#define FIO_U8_HASH_PRIME23  0xA3U   /* (4/8) 10100011 */

Symbol type: macro

#`FIO_U8_HASH_PRIME24`

#define FIO_U8_HASH_PRIME24  0xA7U   /* (5/8) 10100111 */

Symbol type: macro

#`FIO_U8_HASH_PRIME25`

#define FIO_U8_HASH_PRIME25  0xADU   /* (5/8) 10101101 */

Symbol type: macro

#`FIO_U8_HASH_PRIME26`

#define FIO_U8_HASH_PRIME26  0xB3U   /* (5/8) 10110011 */

Symbol type: macro

#`FIO_U8_HASH_PRIME27`

#define FIO_U8_HASH_PRIME27  0xB5U   /* (5/8) 10110101 */

Symbol type: macro

#`FIO_U8_HASH_PRIME28`

#define FIO_U8_HASH_PRIME28  0xC1U   /* (3/8) 11000001 */

Symbol type: macro

#`FIO_U8_HASH_PRIME29`

#define FIO_U8_HASH_PRIME29  0xC5U   /* (4/8) 11000101 */

Symbol type: macro

#`FIO_U8_HASH_PRIME30`

#define FIO_U8_HASH_PRIME30  0xC7U   /* (5/8) 11000111 */

Symbol type: macro

#`FIO_U8_HASH_PRIME31`

#define FIO_U8_HASH_PRIME31  0xD3U   /* (5/8) 11010011 */

Symbol type: macro

#`FIO_U16_HASH_PRIME0`

#define FIO_U16_HASH_PRIME0  0x631DU /* 0110001100011101 */

Symbol type: macro

#`FIO_U16_HASH_PRIME1`

#define FIO_U16_HASH_PRIME1  0x4F19U /* 0100111100011001 */

Symbol type: macro

#`FIO_U16_HASH_PRIME2`

#define FIO_U16_HASH_PRIME2  0xA91BU /* 1010100100011011 */

Symbol type: macro

#`FIO_U16_HASH_PRIME3`

#define FIO_U16_HASH_PRIME3  0xDF01U /* 1101111100000001 */

Symbol type: macro

#`FIO_U16_HASH_PRIME4`

#define FIO_U16_HASH_PRIME4  0x8C5DU /* 1000110001011101 */

Symbol type: macro

#`FIO_U16_HASH_PRIME5`

#define FIO_U16_HASH_PRIME5  0xF941U /* 1111100101000001 */

Symbol type: macro

#`FIO_U16_HASH_PRIME6`

#define FIO_U16_HASH_PRIME6  0xC49DU /* 1100010010011101 */

Symbol type: macro

#`FIO_U16_HASH_PRIME7`

#define FIO_U16_HASH_PRIME7  0xA32BU /* 1010001100101011 */

Symbol type: macro

#`FIO_U16_HASH_PRIME8`

#define FIO_U16_HASH_PRIME8  0x7859U /* 0111100001011001 */

Symbol type: macro

#`FIO_U16_HASH_PRIME9`

#define FIO_U16_HASH_PRIME9  0xC4F1U /* 1100010011110001 */

Symbol type: macro

#`FIO_U16_HASH_PRIME10`

#define FIO_U16_HASH_PRIME10 0x74E1U /* 0111010011100001 */

Symbol type: macro

#`FIO_U16_HASH_PRIME11`

#define FIO_U16_HASH_PRIME11 0xD433U /* 1101010000110011 */

Symbol type: macro

#`FIO_U16_HASH_PRIME12`

#define FIO_U16_HASH_PRIME12 0xCB29U /* 1100101100101001 */

Symbol type: macro

#`FIO_U16_HASH_PRIME13`

#define FIO_U16_HASH_PRIME13 0xC2A7U /* 1100001010100111 */

Symbol type: macro

#`FIO_U16_HASH_PRIME14`

#define FIO_U16_HASH_PRIME14 0xC317U /* 1100001100010111 */

Symbol type: macro

#`FIO_U16_HASH_PRIME15`

#define FIO_U16_HASH_PRIME15 0x92B9U /* 1001001010111001 */

Symbol type: macro

#`FIO_U16_HASH_PRIME16`

#define FIO_U16_HASH_PRIME16 0x7D03U /* 0111110100000011 */

Symbol type: macro

#`FIO_U16_HASH_PRIME17`

#define FIO_U16_HASH_PRIME17 0x5CD1U /* 0101110011010001 */

Symbol type: macro

#`FIO_U16_HASH_PRIME18`

#define FIO_U16_HASH_PRIME18 0x73C1U /* 0111001111000001 */

Symbol type: macro

#`FIO_U16_HASH_PRIME19`

#define FIO_U16_HASH_PRIME19 0x69A3U /* 0110100110100011 */

Symbol type: macro

#`FIO_U16_HASH_PRIME20`

#define FIO_U16_HASH_PRIME20 0xA2B3U /* 1010001010110011 */

Symbol type: macro

#`FIO_U16_HASH_PRIME21`

#define FIO_U16_HASH_PRIME21 0x521FU /* 0101001000011111 */

Symbol type: macro

#`FIO_U16_HASH_PRIME22`

#define FIO_U16_HASH_PRIME22 0x4E53U /* 0100111001010011 */

Symbol type: macro

#`FIO_U16_HASH_PRIME23`

#define FIO_U16_HASH_PRIME23 0xFC41U /* 1111110001000001 */

Symbol type: macro

#`FIO_U16_HASH_PRIME24`

#define FIO_U16_HASH_PRIME24 0x5F09U /* 0101111100001001 */

Symbol type: macro

#`FIO_U16_HASH_PRIME25`

#define FIO_U16_HASH_PRIME25 0x605FU /* 0110000001011111 */

Symbol type: macro

#`FIO_U16_HASH_PRIME26`

#define FIO_U16_HASH_PRIME26 0xA715U /* 1010011100010101 */

Symbol type: macro

#`FIO_U16_HASH_PRIME27`

#define FIO_U16_HASH_PRIME27 0x6C65U /* 0110110001100101 */

Symbol type: macro

#`FIO_U16_HASH_PRIME28`

#define FIO_U16_HASH_PRIME28 0x65C5U /* 0110010111000101 */

Symbol type: macro

#`FIO_U16_HASH_PRIME29`

#define FIO_U16_HASH_PRIME29 0x85D3U /* 1000010111010011 */

Symbol type: macro

#`FIO_U16_HASH_PRIME30`

#define FIO_U16_HASH_PRIME30 0xDE41U /* 1101111001000001 */

Symbol type: macro

#`FIO_U16_HASH_PRIME31`

#define FIO_U16_HASH_PRIME31 0xCA8DU /* 1100101010001101 */

Symbol type: macro

#`FIO_U32_HASH_PRIME0`

#define FIO_U32_HASH_PRIME0  0x618E9735 /* 01100001100011101001011100110101 */

Symbol type: macro

#`FIO_U32_HASH_PRIME1`

#define FIO_U32_HASH_PRIME1  0xD9E8E033 /* 11011001111010001110000000110011 */

Symbol type: macro

#`FIO_U32_HASH_PRIME2`

#define FIO_U32_HASH_PRIME2  0x50F116F9 /* 01010000111100010001011011111001 */

Symbol type: macro

#`FIO_U32_HASH_PRIME3`

#define FIO_U32_HASH_PRIME3  0x6E098F4B /* 01101110000010011000111101001011 */

Symbol type: macro

#`FIO_U32_HASH_PRIME4`

#define FIO_U32_HASH_PRIME4  0x8CC87A6B /* 10001100110010000111101001101011 */

Symbol type: macro

#`FIO_U32_HASH_PRIME5`

#define FIO_U32_HASH_PRIME5  0x59E16F03 /* 01011001111000010110111100000011 */

Symbol type: macro

#`FIO_U32_HASH_PRIME6`

#define FIO_U32_HASH_PRIME6  0xBB838C63 /* 10111011100000111000110001100011 */

Symbol type: macro

#`FIO_U32_HASH_PRIME7`

#define FIO_U32_HASH_PRIME7  0x8532FF05 /* 10000101001100101111111100000101 */

Symbol type: macro

#`FIO_U32_HASH_PRIME8`

#define FIO_U32_HASH_PRIME8  0x44FEC4A5 /* 01000100111111101100010010100101 */

Symbol type: macro

#`FIO_U32_HASH_PRIME9`

#define FIO_U32_HASH_PRIME9  0x9B3350D5 /* 10011011001100110101000011010101 */

Symbol type: macro

#`FIO_U32_HASH_PRIME10`

#define FIO_U32_HASH_PRIME10 0x64BE6287 /* 01100100101111100110001010000111 */

Symbol type: macro

#`FIO_U32_HASH_PRIME11`

#define FIO_U32_HASH_PRIME11 0x57C2370B /* 01010111110000100011011100001011 */

Symbol type: macro

#`FIO_U32_HASH_PRIME12`

#define FIO_U32_HASH_PRIME12 0x9E724F41 /* 10011110011100100100111101000001 */

Symbol type: macro

#`FIO_U32_HASH_PRIME13`

#define FIO_U32_HASH_PRIME13 0xF4A8A173 /* 11110100101010001010000101110011 */

Symbol type: macro

#`FIO_U32_HASH_PRIME14`

#define FIO_U32_HASH_PRIME14 0x6C4560FD /* 01101100010001010110000011111101 */

Symbol type: macro

#`FIO_U32_HASH_PRIME15`

#define FIO_U32_HASH_PRIME15 0xD8558C3D /* 11011000010101011000110000111101 */

Symbol type: macro

#`FIO_U32_HASH_PRIME16`

#define FIO_U32_HASH_PRIME16 0xC2F29157 /* 11000010111100101001000101010111 */

Symbol type: macro

#`FIO_U32_HASH_PRIME17`

#define FIO_U32_HASH_PRIME17 0xF4D03789 /* 11110100110100000011011110001001 */

Symbol type: macro

#`FIO_U32_HASH_PRIME18`

#define FIO_U32_HASH_PRIME18 0x9FB01857 /* 10011111101100000001100001010111 */

Symbol type: macro

#`FIO_U32_HASH_PRIME19`

#define FIO_U32_HASH_PRIME19 0xE9513C0F /* 11101001010100010011110000001111 */

Symbol type: macro

#`FIO_U32_HASH_PRIME20`

#define FIO_U32_HASH_PRIME20 0x89862FD3 /* 10001001100001100010111111010011 */

Symbol type: macro

#`FIO_U32_HASH_PRIME21`

#define FIO_U32_HASH_PRIME21 0xB742A51D /* 10110111010000101010010100011101 */

Symbol type: macro

#`FIO_U32_HASH_PRIME22`

#define FIO_U32_HASH_PRIME22 0xB3A681B9 /* 10110011101001101000000110111001 */

Symbol type: macro

#`FIO_U32_HASH_PRIME23`

#define FIO_U32_HASH_PRIME23 0xC44899F7 /* 11000100010010001001100111110111 */

Symbol type: macro

#`FIO_U32_HASH_PRIME24`

#define FIO_U32_HASH_PRIME24 0x67DE8341 /* 01100111110111101000001101000001 */

Symbol type: macro

#`FIO_U32_HASH_PRIME25`

#define FIO_U32_HASH_PRIME25 0xF453213B /* 11110100010100110010000100111011 */

Symbol type: macro

#`FIO_U32_HASH_PRIME26`

#define FIO_U32_HASH_PRIME26 0xD22F9855 /* 11010010001011111001100001010101 */

Symbol type: macro

#`FIO_U32_HASH_PRIME27`

#define FIO_U32_HASH_PRIME27 0x8B3E807D /* 10001011001111101000000001111101 */

Symbol type: macro

#`FIO_U32_HASH_PRIME28`

#define FIO_U32_HASH_PRIME28 0x59DD1C23 /* 01011001110111010001110000100011 */

Symbol type: macro

#`FIO_U32_HASH_PRIME29`

#define FIO_U32_HASH_PRIME29 0xEE548C8B /* 11101110010101001000110010001011 */

Symbol type: macro

#`FIO_U32_HASH_PRIME30`

#define FIO_U32_HASH_PRIME30 0xD2E74E05 /* 11010010111001110100111000000101 */

Symbol type: macro

#`FIO_U32_HASH_PRIME31`

#define FIO_U32_HASH_PRIME31 0x4E55788D /* 01001110010101010111100010001101 */

Symbol type: macro

#`FIO_U64_HASH_PRIME0`

#define FIO_U64_HASH_PRIME0  ((uint64_t)0x39664DEECA23D825) /* 0011100101100110010011011110111011001010001000111101100000100101 */

Symbol type: macro

#`FIO_U64_HASH_PRIME1`

#define FIO_U64_HASH_PRIME1  ((uint64_t)0x48644F7B3959621F) /* 0100100001100100010011110111101100111001010110010110001000011111 */

Symbol type: macro

#`FIO_U64_HASH_PRIME2`

#define FIO_U64_HASH_PRIME2  ((uint64_t)0x613A19F5CB0D98D5) /* 0110000100111010000110011111010111001011000011011001100011010101 */

Symbol type: macro

#`FIO_U64_HASH_PRIME3`

#define FIO_U64_HASH_PRIME3  ((uint64_t)0x84B56B93C869EA0F) /* 1000010010110101011010111001001111001000011010011110101000001111 */

Symbol type: macro

#`FIO_U64_HASH_PRIME4`

#define FIO_U64_HASH_PRIME4  ((uint64_t)0x8EE38D13E0D95A8D) /* 1000111011100011100011010001001111100000110110010101101010001101 */

Symbol type: macro

#`FIO_U64_HASH_PRIME5`

#define FIO_U64_HASH_PRIME5  ((uint64_t)0x92E99EC981F0E279) /* 1001001011101001100111101100100110000001111100001110001001111001 */

Symbol type: macro

#`FIO_U64_HASH_PRIME6`

#define FIO_U64_HASH_PRIME6  ((uint64_t)0xDDC3100BEF158BB1) /* 1101110111000011000100000000101111101111000101011000101110110001 */

Symbol type: macro

#`FIO_U64_HASH_PRIME7`

#define FIO_U64_HASH_PRIME7  ((uint64_t)0x918F4D38049F78BD) /* 1001000110001111010011010011100000000100100111110111100010111101 */

Symbol type: macro

#`FIO_U64_HASH_PRIME8`

#define FIO_U64_HASH_PRIME8  ((uint64_t)0xB6C9F8032A35E2D9) /* 1011011011001001111110000000001100101010001101011110001011011001 */

Symbol type: macro

#`FIO_U64_HASH_PRIME9`

#define FIO_U64_HASH_PRIME9  ((uint64_t)0xFA2A5F16D2A128D5) /* 1111101000101010010111110001011011010010101000010010100011010101 */

Symbol type: macro

#`FIO_U64_HASH_PRIME10`

#define FIO_U64_HASH_PRIME10 ((uint64_t)0x5823C958ED5547D9) /* 0101100000100011110010010101100011101101010101010100011111011001 */

Symbol type: macro

#`FIO_U64_HASH_PRIME11`

#define FIO_U64_HASH_PRIME11 ((uint64_t)0xE8AB702EEE09CB43) /* 1110100010101011011100000010111011101110000010011100101101000011 */

Symbol type: macro

#`FIO_U64_HASH_PRIME12`

#define FIO_U64_HASH_PRIME12 ((uint64_t)0xEBD609356421F13D) /* 1110101111010110000010010011010101100100001000011111000100111101 */

Symbol type: macro

#`FIO_U64_HASH_PRIME13`

#define FIO_U64_HASH_PRIME13 ((uint64_t)0x43D0C330AF5B1F17) /* 0100001111010000110000110011000010101111010110110001111100010111 */

Symbol type: macro

#`FIO_U64_HASH_PRIME14`

#define FIO_U64_HASH_PRIME14 ((uint64_t)0xFEAE66D234871807) /* 1111111010101110011001101101001000110100100001110001100000000111 */

Symbol type: macro

#`FIO_U64_HASH_PRIME15`

#define FIO_U64_HASH_PRIME15 ((uint64_t)0xEE54B43A52941D6B) /* 1110111001010100101101000011101001010010100101000001110101101011 */

Symbol type: macro

#`FIO_U64_HASH_PRIME16`

#define FIO_U64_HASH_PRIME16 ((uint64_t)0x874E9DE46F15E205) /* 1000011101001110100111011110010001101111000101011110001000000101 */

Symbol type: macro

#`FIO_U64_HASH_PRIME17`

#define FIO_U64_HASH_PRIME17 ((uint64_t)0xFC7CA51A8A2E9171) /* 1111110001111100101001010001101010001010001011101001000101110001 */

Symbol type: macro

#`FIO_U64_HASH_PRIME18`

#define FIO_U64_HASH_PRIME18 ((uint64_t)0x83A70617F71F3C21) /* 1000001110100111000001100001011111110111000111110011110000100001 */

Symbol type: macro

#`FIO_U64_HASH_PRIME19`

#define FIO_U64_HASH_PRIME19 ((uint64_t)0x50FA705D6D99C11D) /* 0101000011111010011100000101110101101101100110011100000100011101 */

Symbol type: macro

#`FIO_U64_HASH_PRIME20`

#define FIO_U64_HASH_PRIME20 ((uint64_t)0x5362B5E6CF64814B) /* 0101001101100010101101011110011011001111011001001000000101001011 */

Symbol type: macro

#`FIO_U64_HASH_PRIME21`

#define FIO_U64_HASH_PRIME21 ((uint64_t)0xA7A178389B0F3077) /* 1010011110100001011110000011100010011011000011110011000001110111 */

Symbol type: macro

#`FIO_U64_HASH_PRIME22`

#define FIO_U64_HASH_PRIME22 ((uint64_t)0x779D78921199BA45) /* 0111011110011101011110001001001000010001100110011011101001000101 */

Symbol type: macro

#`FIO_U64_HASH_PRIME23`

#define FIO_U64_HASH_PRIME23 ((uint64_t)0xB42FD16A9AE90F81) /* 1011010000101111110100010110101010011010111010010000111110000001 */

Symbol type: macro

#`FIO_U64_HASH_PRIME24`

#define FIO_U64_HASH_PRIME24 ((uint64_t)0xA2B4538A3C95576D) /* 1010001010110100010100111000101000111100100101010101011101101101 */

Symbol type: macro

#`FIO_U64_HASH_PRIME25`

#define FIO_U64_HASH_PRIME25 ((uint64_t)0x5E23D8E445F94E0D) /* 0101111000100011110110001110010001000101111110010100111000001101 */

Symbol type: macro

#`FIO_U64_HASH_PRIME26`

#define FIO_U64_HASH_PRIME26 ((uint64_t)0xE7CA493CD6444F07) /* 1110011111001010010010010011110011010110010001000100111100000111 */

Symbol type: macro

#`FIO_U64_HASH_PRIME27`

#define FIO_U64_HASH_PRIME27 ((uint64_t)0x734719A6A1873CB5) /* 0111001101000111000110011010011010100001100001110011110010110101 */

Symbol type: macro

#`FIO_U64_HASH_PRIME28`

#define FIO_U64_HASH_PRIME28 ((uint64_t)0x56CCB954143A3AB7) /* 0101011011001100101110010101010000010100001110100011101010110111 */

Symbol type: macro

#`FIO_U64_HASH_PRIME29`

#define FIO_U64_HASH_PRIME29 ((uint64_t)0xFA5BC5A72480BF81) /* 1111101001011011110001011010011100100100100000001011111110000001 */

Symbol type: macro

#`FIO_U64_HASH_PRIME30`

#define FIO_U64_HASH_PRIME30 ((uint64_t)0xD9B97D090C09F789) /* 1101100110111001011111010000100100001100000010011111011110001001 */

Symbol type: macro

#`FIO_U64_HASH_PRIME31`

#define FIO_U64_HASH_PRIME31 ((uint64_t)0x9F74D0B9972E404B) /* 1001111101110100110100001011100110010111001011100100000001001011 */

Symbol type: macro

#`FIO_PRIME_TABLE_LIMIT`

#define FIO_PRIME_TABLE_LIMIT 1024

Symbol type: macro

#`FIO_MATH_UXXX_OP`

#define FIO_MATH_UXXX_OP(t, a, b, bits, op)   \
  do {   \
    for (size_t i__ = 0; i__ < (sizeof((t)) / sizeof((t)[0])); ++i__)   \
      (t)[i__] = (a)[i__] op(b)[i__];   \
  } while (0)

Performs a op b (+,-, *, etc') using easily vectorized loop.

Symbol type: macro

#`FIO_MATH_UXXX_COP`

#define FIO_MATH_UXXX_COP(t, a, b, bits, op)   \
  do {   \
    for (size_t i__ = 0; i__ < (sizeof((t)) / sizeof((t)[0])); ++i__)   \
      (t)[i__] = (a)[i__] op(b);   \
  } while (0)

Performs a op b (+,-, *, etc'), where b is a constant.

Symbol type: macro

#`FIO_MATH_UXXX_SOP`

#define FIO_MATH_UXXX_SOP(t, a, bits, op)   \
  do {   \
    for (size_t i__ = 0; i__ < (sizeof((t)) / sizeof((t)[0])); ++i__)   \
      (t)[i__] = op(a)[i__];   \
  } while (0)

Performs t = op (a).

Symbol type: macro

#`FIO_MATH_UXXX_OP_RROT`

#define FIO_MATH_UXXX_OP_RROT(t, a, b, bits)   \
  do {   \
    for (size_t i__ = 0; i__ < (sizeof((t)) / sizeof((t)[0])); ++i__)   \
      (t)[i__] =   \
          ((a)[i__] >> ((b)[i__] & ((bits)-1))) |   \
          ((a)[i__] << (((bits) - ((b)[i__] & ((bits)-1))) & ((bits)-1)));   \
  } while (0)

Performs (a >> b) | (a << (bits - b)) (right rotation) in a loop.

Symbol type: macro

#`FIO_MATH_UXXX_OP_CRROT`

#define FIO_MATH_UXXX_OP_CRROT(t, a, c, bits)   \
  do {   \
    for (size_t i__ = 0; i__ < (sizeof((t)) / sizeof((t)[0])); ++i__)   \
      (t)[i__] = ((a)[i__] >> ((c) & ((bits)-1))) |   \
                 ((a)[i__] << (((bits) - ((c) & ((bits)-1))) & ((bits)-1)));   \
  } while (0)

Performs (a >> c) | (a << (bits - c)) (const right rotation) in a loop.

Symbol type: macro

#`FIO_MATH_UXXX_OP_LROT`

#define FIO_MATH_UXXX_OP_LROT(t, a, b, bits)   \
  do {   \
    for (size_t i__ = 0; i__ < (sizeof((t)) / sizeof((t)[0])); ++i__)   \
      (t)[i__] =   \
          ((a)[i__] << ((b)[i__] & ((bits)-1))) |   \
          ((a)[i__] >> (((bits) - ((b)[i__] & ((bits)-1))) & ((bits)-1)));   \
  } while (0)

Performs (a << b) | (a >> (bits - b)) (left rotation) in a loop.

Symbol type: macro

#`FIO_MATH_UXXX_OP_CLROT`

#define FIO_MATH_UXXX_OP_CLROT(t, a, c, bits)   \
  do {   \
    for (size_t i__ = 0; i__ < (sizeof((t)) / sizeof((t)[0])); ++i__)   \
      (t)[i__] = ((a)[i__] << ((c) & ((bits)-1))) |   \
                 ((a)[i__] >> (((bits) - ((c) & ((bits)-1))) & ((bits)-1)));   \
  } while (0)

Performs (a << c) | (a >> (bits - c)) (const left rotation) in a loop.

Symbol type: macro

#`FIO_MATH_UXXX_TOP`

#define FIO_MATH_UXXX_TOP(t, a, b, c, bits, expr)   \
  do {   \
    for (size_t i__ = 0; i__ < (sizeof((t)) / sizeof((t)[0])); ++i__)   \
      (t)[i__] = expr((a)[i__], (b)[i__], (c)[i__]);   \
  } while (0)

Performs ternary t = f(a, b, c) lane-wise using easily vectorized loop.

Symbol type: macro

#`FIO_MATH_UXXX_REDUCE`

#define FIO_MATH_UXXX_REDUCE(t, a, bits, op)   \
  do {   \
    t = (a)[0];   \
    for (size_t i__ = 1; i__ < (sizeof((a)) / sizeof((a)[0])); ++i__)   \
      (t) = (t)op(a)[i__];   \
  } while (0)

Performs vector reduction for using op (+,-, *, etc'), storing to t.

Symbol type: macro

#`FIO_MATH_UXXX_SUFFLE`

#define FIO_MATH_UXXX_SUFFLE(var, bits, ...)   \
  do {   \
    uint##bits##_t t____[sizeof((var)) / sizeof((var)[0])];   \
    const uint8_t shuf____[sizeof((var)) / sizeof((var)[0])] = {__VA_ARGS__};   \
    for (size_t i___ = 0; i___ < (sizeof((var)) / sizeof((var)[0])); ++i___)   \
      t____[i___] = (var)[shuf____[i___]];   \
    for (size_t i___ = 0; i___ < (sizeof((var)) / sizeof((var)[0])); ++i___)   \
      (var)[i___] = t____[i___];   \
  } while (0)

Performs vector shuffling (reordering) of var.

Symbol type: macro

#`FIO_VEC_SIMPLE_OP`

#define FIO_VEC_SIMPLE_OP(result, a, b, len, op)   \
  FIO_FOR_UNROLL(len, sizeof(*a), i__, result[i__] = a[i__] op b[i__])

A math operation op between correlating vector positions of same length

Symbol type: macro

#`FIO_VEC_SCALAR_OP`

#define FIO_VEC_SCALAR_OP(result, v, sclr, len, op)   \
  FIO_FOR_UNROLL(len, sizeof(*(v)), i__, (result)[i__] = (v)[i__] op(sclr))

A math operation op between a scalar and a vector

Symbol type: macro

#`FIO_VEC_REDUCE_OP`

#define FIO_VEC_REDUCE_OP(result, vec, len, op)   \
  FIO_FOR_UNROLL(len, sizeof(*vec), i__, result = result op vec[i__])

A math operation op between all vector members

Symbol type: macro

#`FIO_VEC_DOT`

#define FIO_VEC_DOT(result, a, b, len)   \
  FIO_FOR_UNROLL(len, sizeof(*a), i__, result += a[i__] * b[i__])

The dot product of two vectors (sum(a[i]*b[i])).

Symbol type: macro

#`FIO_VEC_ADD`

#define FIO_VEC_ADD(result, a, b, len) FIO_VEC_SIMPLE_OP(result, a, b, len, +)

Add two vectors of same length (adding corresponding positions)

Symbol type: macro

#`FIO_VEC_SUB`

#define FIO_VEC_SUB(result, a, b, len) FIO_VEC_SIMPLE_OP(result, a, b, len, -)

Subtracting two vectors of same length

Symbol type: macro

#`FIO_VEC_MUL`

#define FIO_VEC_MUL(result, a, b, len) FIO_VEC_SIMPLE_OP(result, a, b, len, *)

Multiplying two vectors (multiplying corresponding positions - half dot)

Symbol type: macro

#`FIO_VEC_SCALAR_ADD`

#define FIO_VEC_SCALAR_ADD(result, vec, scalar, vlen)   \
  FIO_VEC_SCALAR_OP(result, vec, scalar, vlen, +)

Add scalar to vector

Symbol type: macro

#`FIO_VEC_SCALAR_SUB`

#define FIO_VEC_SCALAR_SUB(result, vec, scalar, vlen)   \
  FIO_VEC_SCALAR_OP(result, vec, scalar, vlen, -)

Subtract scalar from vector

Symbol type: macro

#`FIO_VEC_SCALAR_MUL`

#define FIO_VEC_SCALAR_MUL(result, vec, scalar, vlen)   \
  FIO_VEC_SCALAR_OP(result, vec, scalar, vlen, *)

Multiply scalar from vector

Symbol type: macro

#`FIO_VEC_REDUCE_ADD`

#define FIO_VEC_REDUCE_ADD(result, vec, vlen)   \
  FIO_VEC_REDUCE_OP(result, vec, vlen, +)

Add all members of a vector

Symbol type: macro

#`FIO_VEC_REDUCE_SUB`

#define FIO_VEC_REDUCE_SUB(result, vec, vlen)   \
  FIO_VEC_REDUCE_OP(result, vec, vlen, -)

Subtract all members of a vector

Symbol type: macro

#`FIO_VEC_REDUCE_MUL`

#define FIO_VEC_REDUCE_MUL(result, vec, vlen)   \
  FIO_VEC_REDUCE_OP(result, vec, vlen, *)

Multiply all members of a vector

Symbol type: macro

#`FIO_DEFINE_RANDOM128_FN`

#define FIO_DEFINE_RANDOM128_FN(extern, name, reseed_log, seed_offset)   \
  static uint64_t name##___state[9] FIO_ALIGN(64) = {   \
      0x9c65875be1fce7b9ULL + seed_offset,   \
      0x7cc568e838f6a40dULL,   \
      0x4bb8d885a0fe47d5ULL + seed_offset,   \
      0x95561f0927ad7ecdULL,   \
      0};   \
  extern FIO_MAYBE_UNUSED void name##_reset(void) {   \
    name##___state[0] = 0x9c65875be1fce7b9ULL + seed_offset;   \
    name##___state[1] = 0x7cc568e838f6a40dULL;   \
    name##___state[2] = 0x4bb8d885a0fe47d5ULL + seed_offset;   \
    name##___state[3] = 0x95561f0927ad7ecdULL;   \
    name##___state[8] = name##___state[4] = 0;   \
  }   \
  extern void name##_reseed(void) {   \
    const size_t jitter_samples = 16 | (name##___state[0] & 15);   \
    for (size_t i = 0; i < jitter_samples; ++i) {   \
      struct timespec t;   \
      clock_gettime(CLOCK_MONOTONIC, &t);   \
      uint64_t clk[2] = {(uint64_t)(uintptr_t)&clk + (uint64_t)(uintptr_t) &   \
                             (name##_reseed),   \
                         0};   \
      clk[0] += (uint64_t)((t.tv_sec << 30) + (int64_t)t.tv_nsec);   \
      clk[0] = fio_math_mulc64(clk[0], FIO_U64_HASH_PRIME0, clk + 1);   \
      clk[1] += FIO_U64_HASH_PRIME0;   \
      clk[0] += fio_lrot64(clk[0], 27);   \
      clk[0] += fio_lrot64(clk[0], 49);   \
      clk[1] += fio_lrot64(clk[1], 27);   \
      clk[1] += fio_lrot64(clk[1], 49);   \
      name##___state[0] += clk[0] + fio_cycle_counter();   \
      name##___state[1] += clk[1] + fio_cycle_counter();   \
      name##___state[2] += clk[0] + fio_cycle_counter();   \
      name##___state[3] += clk[1] + fio_cycle_counter();   \
    }   \
    name##___state[8] += ((name##___state[8] & 7) + (name##___state[0] & 30));   \
  }   \
  /** Re-seeds the PNGR so forked processes don't match. */   \
  extern FIO_MAYBE_UNUSED void name##_on_fork(void *is_null) {   \
    (void)is_null;   \
    name##_reseed();   \
  }   \
  /** Returns a 128 bit pseudo-random number. */   \
  extern FIO_MAYBE_UNUSED fio_u128 name##128(void) {   \
    fio_u256 r;   \
    if (!(fio_atomic_add(name##___state + 4, 1) &   \
          ((1ULL << reseed_log) - 1)) &&   \
        ((size_t)(reseed_log - 1) < 63))   \
      name##_reseed();   \
    uint64_t s1[4];   \
    { /* load state to registers and roll, mul, add */   \
      const uint64_t cycles =   \
          reseed_log ? fio_cycle_counter() + (uint64_t)(uintptr_t)&cycles   \
                     : 0xB5ULL;   \
      const uint64_t variation =   \
          0x4E55788DULL +   \
          (reseed_log ? (uint64_t)(uintptr_t)&name##_reseed : 0);   \
      const uint64_t s0[] = {(name##___state[0] + cycles),   \
                             (name##___state[1] + cycles),   \
                             (name##___state[2] + cycles),   \
                             (name##___state[3] + cycles)};   \
      const uint64_t mulp[] = {0x37701261ED6C16C7ULL,   \
                               0x764DBBB75F3B3E0DULL,   \
                               ~(0x37701261ED6C16C7ULL),   \
                               ~(0x764DBBB75F3B3E0DULL)};   \
      const uint64_t addc[] = {name##___state[4],   \
                               seed_offset + 0x59DD1C23ULL,   \
                               name##___state[4] + cycles,   \
                               variation};   \
      for (size_t i = 0; i < 4; ++i) {   \
        s1[i] = fio_lrot64(s0[i], 33);   \
        s1[i] += addc[i];   \
        s1[i] *= mulp[i];   \
        s1[i] += s0[i];   \
      }   \
    }   \
    for (size_t i = 0; i < 4; ++i) /* store to memory */   \
      name##___state[i] = s1[i];   \
    {   \
      const uint8_t rotc[] = {31, 29, 27, 30};   \
      for (size_t i = 0; i < 4; ++i)   \
        r.u64[i] = fio_lrot64(s1[i], rotc[i]);   \
    }   \
    r.u64[0] += r.u64[2];   \
    r.u64[1] += r.u64[3];   \
    return r.u128[0];   \
  }   \
  /** Returns a 64 bit pseudo-random number. */   \
  extern FIO_MAYBE_UNUSED uint64_t name##64(void) {   \
    static fio_u128 r;   \
    size_t counter = fio_atomic_add(name##___state + 8, 1);   \
    if (!(counter & 1))   \
      r = name##128();   \
    return r.u64[counter & 1];   \
  }   \
  /** Fills the `dest` buffer with pseudo-random noise. */   \
  extern FIO_MAYBE_UNUSED void name##_bytes(void *dest, size_t len) {   \
    if (!dest || !len)   \
      return;   \
    uint8_t *d = (uint8_t *)dest;   \
    for (unsigned i = 15; i < len; i += 16) {   \
      fio_u128 r = name##128();   \
      fio_memcpy16(d, r.u8);   \
      d += 16;   \
    }   \
    if (len & 15) {   \
      fio_u128 r = name##128();   \
      fio_memcpy15x(d, r.u8, len);   \
    }   \
  }

Defines a semi-deterministic Pseudo-Random 128 bit Number Generator function.

The following functions will be defined:

extern fio_u128 name##128(void); // returns 128 bits
extern uint64_t name##64(void); // returns 64 bits (simply half the result)
extern void name##_bytes(void *buffer, size_t len); // fills a buffer
extern void name##_reset(void); // resets the state of the PRNG
extern void name##_on_fork(void * is_null); // reseeds the PRNG

If reseed_log is non-zero and less than 64, the PNGR is no longer deterministic, as it will automatically re-seeds itself every 2^reseed_log iterations.

If extern is static or FIO_SFUNC, static function will be defined.

Symbol type: macro

#`FIO_STR_INFO_IS_EQ`

#define FIO_STR_INFO_IS_EQ(s1, s2)   \
  ((s1).len == (s2).len &&   \
   (!(s1).len || (s1).buf == (s2).buf ||   \
    ((s1).buf && (s2).buf && (s1).buf[0] == (s2).buf[0] &&   \
     !FIO_MEMCMP((s1).buf, (s2).buf, (s1).len))))

Compares two fio_str_info_s objects for content equality.

Symbol type: macro

#`FIO_BUF_INFO_IS_EQ`

#define FIO_BUF_INFO_IS_EQ(s1, s2) FIO_STR_INFO_IS_EQ((s1), (s2))

Compares two fio_buf_info_s objects for content equality.

Symbol type: macro

#`FIO_STR_INFO0`

#define FIO_STR_INFO0 ((fio_str_info_s){0})

A NULL fio_str_info_s.

Symbol type: macro

#`FIO_STR_INFO1`

#define FIO_STR_INFO1(str)   \
  ((fio_str_info_s){.len = ((str) ? FIO_STRLEN((str)) : 0), .buf = (str)})

Converts a C String into a fio_str_info_s.

Symbol type: macro

#`FIO_STR_INFO2`

#define FIO_STR_INFO2(str, length)   \
  ((fio_str_info_s){.len = (length), .buf = (str)})

Converts a String with a known length into a fio_str_info_s.

Symbol type: macro

#`FIO_STR_INFO3`

#define FIO_STR_INFO3(str, length, capacity)   \
  ((fio_str_info_s){.len = (length), .buf = (str), .capa = (capacity)})

Converts a String with a known length and capacity into a fio_str_info_s.

Symbol type: macro

#`FIO_BUF_INFO0`

#define FIO_BUF_INFO0 ((fio_buf_info_s){0})

A NULL fio_buf_info_s.

Symbol type: macro

#`FIO_BUF_INFO1`

#define FIO_BUF_INFO1(str)   \
  ((fio_buf_info_s){.len = ((str) ? FIO_STRLEN((str)) : 0), .buf = (str)})

Converts a C String into a fio_buf_info_s.

Symbol type: macro

#`FIO_BUF_INFO2`

#define FIO_BUF_INFO2(str, length)   \
  ((fio_buf_info_s){.len = (length), .buf = (str)})

Converts a String with a known length into a fio_buf_info_s.

Symbol type: macro

#`FIO_UBUF_INFO0`

#define FIO_UBUF_INFO0 ((fio_ubuf_info_s){0})

A NULL fio_ubuf_info_s.

Symbol type: macro

#`FIO_UBUF_INFO1`

#define FIO_UBUF_INFO1(str)   \
  ((fio_ubuf_info_s){.len = ((str) ? FIO_STRLEN((str)) : 0), .buf = (str)})

Converts a C String into a fio_ubuf_info_s.

Symbol type: macro

#`FIO_UBUF_INFO2`

#define FIO_UBUF_INFO2(str, length)   \
  ((fio_ubuf_info_s){.len = (length), .buf = (str)})

Converts a String with a known length into a fio_ubuf_info_s.

Symbol type: macro

#`FIO_BUF2STR_INFO`

#define FIO_BUF2STR_INFO(buf_info)   \
  ((fio_str_info_s){.len = (buf_info).len, .buf = (buf_info).buf})

Converts a fio_buf_info_s into a fio_str_info_s.

Symbol type: macro

#`FIO_STR2BUF_INFO`

#define FIO_STR2BUF_INFO(str_info)   \
  ((fio_buf_info_s){.len = (str_info).len, .buf = (str_info).buf})

Converts a fio_buf_info_s into a fio_str_info_s.

Symbol type: macro

#`FIO_STR_INFO_TMP_VAR`

#define FIO_STR_INFO_TMP_VAR(name, capacity)   \
  char fio___stack_mem___##name[(capacity) + 1];   \
  fio___stack_mem___##name[0] = 0; /* guard */   \
  fio_str_info_s name = (fio_str_info_s) {   \
    .buf = fio___stack_mem___##name, .capa = (capacity)   \
  }

Creates a stack fio_str_info_s variable name with capacity bytes.

Symbol type: macro

#`FIO_STR_INFO_TMP_IS_REALLOCATED`

#define FIO_STR_INFO_TMP_IS_REALLOCATED(name)   \
  (fio___stack_mem___##name != name.buf)

Tests to see if memory reallocation happened.

Symbol type: macro

#`FIO_UTF8_ALLOW_IF`

#define FIO_UTF8_ALLOW_IF 1

Symbol type: macro

#Types

#`fio_lock_i`

typedef volatile unsigned char fio_lock_i

A spin lock type, must be initialized to FIO_LOCK_INIT before use.

Symbol type: type

#`fio_list_node_s`

struct fio_list_node_s {
struct fio_list_node_s *next;
struct fio_list_node_s *prev;
}

A linked list arch-type

Symbol type: type

#`fio_index32_node_s`

struct fio_index32_node_s {
uint32_t next;
uint32_t prev;
}

A 32 bit indexed linked list node type

Symbol type: type

#`fio_index16_node_s`

struct fio_index16_node_s {
uint16_t next;
uint16_t prev;
}

A 16 bit indexed linked list node type

Symbol type: type

#`fio_index8_node_s`

struct fio_index8_node_s {
uint8_t next;
uint8_t prev;
}

An 8 bit indexed linked list node type

Symbol type: type

#`fio_u128`

union fio_u128 {
FIO___UXXX_UGRP_DEF(128);
#if defined(__SIZEOF_INT128__)
__uint128_t alignment_for_u128_[1];
#endif
}

An unsigned 128bit union type.

Symbol type: type

#`fio_u256`

union fio_u256 {
fio_u128 u128[2];
FIO___UXXX_UGRP_DEF(256);
#if defined(__SIZEOF_INT256__)
__uint256_t alignment_for_u256_[1];
#endif
}

An unsigned 256bit union type.

Symbol type: type

#`fio_u512`

union fio_u512 {
fio_u128 u128[4];
fio_u256 u256[2];
FIO___UXXX_UGRP_DEF(512);
}

An unsigned 512bit union type.

Symbol type: type

#`fio_u1024`

union fio_u1024 {
fio_u128 u128[8];
fio_u256 u256[4];
fio_u512 u512[2];
FIO___UXXX_UGRP_DEF(1024);
}

An unsigned 1024bit union type.

Symbol type: type

#`fio_u2048`

union fio_u2048 {
fio_u128 u128[16];
fio_u256 u256[8];
fio_u512 u512[4];
fio_u1024 u1024[2];
FIO___UXXX_UGRP_DEF(2048);
}

An unsigned 2048bit union type.

Symbol type: type

#`fio_u4096`

union fio_u4096 {
fio_u128 u128[32];
fio_u256 u256[16];
fio_u512 u512[8];
fio_u1024 u1024[4];
fio_u2048 u2048[2];
FIO___UXXX_UGRP_DEF(4096);
}

An unsigned 4096bit union type.

Symbol type: type

#`fio_str_info_s`

struct fio_str_info_s {
/** The string's length, if any. */
size_t len;
/** The string's buffer (pointer to first byte) or NULL on error. */
char *buf;
/** The buffer's capacity. Zero (0) indicates the buffer is read-only. */
size_t capa;
}

An information type for reporting the string's state.

Symbol type: type

#`fio_buf_info_s`

struct fio_buf_info_s {
/** The buffer's length, if any. */
size_t len;
/** The buffer's address (may be NULL if no buffer). */
char *buf;
}

An information type for reporting/storing buffer data (no capa).

Symbol type: type

#`fio_ubuf_info_s`

struct fio_ubuf_info_s {
/** The buffer's length, if any. */
size_t len;
/** The buffer's address (may be NULL if no buffer). */
unsigned char *buf;
}

An information type for reporting/storing unsigned buffer data.

Symbol type: type

#Functions

#`fio_getpid`

#define fio_getpid _getpid

Calls the getpid provided by the system.

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_atomic_load`

#define fio_atomic_load(dest, p_obj)   \
  do {   \
    dest = __atomic_load_n((p_obj), __ATOMIC_SEQ_CST);   \
  } while (0)

An atomic load operation, returns value in pointer.

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_atomic_compare_exchange_p`

#define fio_atomic_compare_exchange_p(p_obj, p_expected, p_desired) __atomic_compare_exchange((p_obj), (p_expected), (p_desired), 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)

An atomic compare and exchange operation, returns true if an exchange occured. p_expected MAY be overwritten with the existing value (system specific).

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_atomic_exchange`

#define fio_atomic_exchange(p_obj, value) __atomic_exchange_n((p_obj), (value), __ATOMIC_SEQ_CST)

An atomic exchange operation, returns previous value

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_atomic_add`

#define fio_atomic_add(p_obj, value) __atomic_fetch_add((p_obj), (value), __ATOMIC_SEQ_CST)

An atomic addition operation, returns previous value

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_atomic_sub`

#define fio_atomic_sub(p_obj, value) __atomic_fetch_sub((p_obj), (value), __ATOMIC_SEQ_CST)

An atomic subtraction operation, returns previous value

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_atomic_and`

#define fio_atomic_and(p_obj, value) __atomic_fetch_and((p_obj), (value), __ATOMIC_SEQ_CST)

An atomic AND (&) operation, returns previous value

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_atomic_xor`

#define fio_atomic_xor(p_obj, value) __atomic_fetch_xor((p_obj), (value), __ATOMIC_SEQ_CST)

An atomic XOR (^) operation, returns previous value

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_atomic_or`

#define fio_atomic_or(p_obj, value) __atomic_fetch_or((p_obj), (value), __ATOMIC_SEQ_CST)

An atomic OR (|) operation, returns previous value

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_atomic_nand`

#define fio_atomic_nand(p_obj, value) __atomic_fetch_nand((p_obj), (value), __ATOMIC_SEQ_CST)

An atomic NOT AND ((~)&) operation, returns previous value

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_atomic_add_fetch`

#define fio_atomic_add_fetch(p_obj, value) __atomic_add_fetch((p_obj), (value), __ATOMIC_SEQ_CST)

An atomic addition operation, returns new value

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_atomic_sub_fetch`

#define fio_atomic_sub_fetch(p_obj, value) __atomic_sub_fetch((p_obj), (value), __ATOMIC_SEQ_CST)

An atomic subtraction operation, returns new value

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_atomic_and_fetch`

#define fio_atomic_and_fetch(p_obj, value) __atomic_and_fetch((p_obj), (value), __ATOMIC_SEQ_CST)

An atomic AND (&) operation, returns new value

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_atomic_xor_fetch`

#define fio_atomic_xor_fetch(p_obj, value) __atomic_xor_fetch((p_obj), (value), __ATOMIC_SEQ_CST)

An atomic XOR (^) operation, returns new value

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_atomic_or_fetch`

#define fio_atomic_or_fetch(p_obj, value) __atomic_or_fetch((p_obj), (value), __ATOMIC_SEQ_CST)

An atomic OR (|) operation, returns new value

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_atomic_nand_fetch`

#define fio_atomic_nand_fetch(p_obj, value) __atomic_nand_fetch((p_obj), (value), __ATOMIC_SEQ_CST)

An atomic NOT AND ((~)&) operation, returns new value

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_trylock_group`

inline uint8_t fio_trylock_group(fio_lock_i *lock, uint8_t group)

Tries to lock a group of sublocks.

Combine a number of sublocks using OR (|) and the FIO_LOCK_SUBLOCK(i) macro. i.e.:

if(!fio_trylock_group(&lock,
                      FIO_LOCK_SUBLOCK(1) | FIO_LOCK_SUBLOCK(2))) {
   // act in lock
}
fio_unlock_group(&lock, FIO_LOCK_SUBLOCK(1) | FIO_LOCK_SUBLOCK(2)));

Returns 0 on success and non-zero on failure.

Symbol type: function

#`fio_lock_group`

inline void fio_lock_group(fio_lock_i *lock, uint8_t group)

Busy waits for a group lock to become available - not recommended.

See fio_trylock_group for details.

Symbol type: function

#`fio_unlock_group`

inline void fio_unlock_group(fio_lock_i *lock, uint8_t group)

Unlocks a sublock group, no matter which thread owns which sublock.

Symbol type: function

#`fio_trylock_full`

inline uint8_t fio_trylock_full(fio_lock_i *lock)

Tries to lock all sublocks. Returns 0 on success and 1 on failure.

Symbol type: function

#`fio_lock_full`

inline void fio_lock_full(fio_lock_i *lock)

Busy waits for all sub lock to become available - not recommended.

Symbol type: function

#`fio_unlock_full`

inline void fio_unlock_full(fio_lock_i *lock)

Unlocks all sub locks, no matter which thread owns the lock.

Symbol type: function

#`fio_trylock`

inline uint8_t fio_trylock(fio_lock_i *lock)

Tries to acquire the default lock (sublock 0).

Returns 0 on success and 1 on failure.

Symbol type: function

#`fio_lock`

inline void fio_lock(fio_lock_i *lock)

Busy waits for the default lock to become available - not recommended.

Symbol type: function

#`fio_unlock`

inline void fio_unlock(fio_lock_i *lock)

Unlocks the default lock, no matter which thread owns the lock.

Symbol type: function

#`fio_is_locked`

inline uint8_t fio_is_locked(fio_lock_i *lock)

Returns 1 if the lock is locked, 0 otherwise.

Symbol type: function

#`fio_is_group_locked`

inline uint8_t fio_is_group_locked(fio_lock_i *lock, uint8_t group)

Returns 1 if the lock is locked, 0 otherwise.

Symbol type: function

#`fio_atomic_bit_get`

inline uint8_t fio_atomic_bit_get(void *map, size_t bit)

Gets the state of a bit in a bitmap.

Symbol type: function

#`fio_atomic_bit_set`

inline void fio_atomic_bit_set(void *map, size_t bit)

Sets the a bit in a bitmap (sets to 1).

Symbol type: function

#`fio_atomic_bit_unset`

inline void fio_atomic_bit_unset(void *map, size_t bit)

Unsets the a bit in a bitmap (sets to 0).

Symbol type: function

#`fio_atomic_bit_flip`

inline void fio_atomic_bit_flip(void *map, size_t bit)

Flips the a bit in a bitmap (sets to 0 if 1, sets to 1 if 0).

Symbol type: function

#`fio_is_little_endian`

inline unsigned int fio_is_little_endian(void)

Dynamically test if we are on a little endian machine.

Symbol type: function

#`fio_is_big_endian`

inline unsigned int fio_is_big_endian(void)

Dynamically test if we are on a big endian machine.

Symbol type: function

#`fio_memcpy0`

FIO_SFUNC void *fio_memcpy0(void *restrict d, const void *restrict s)

No-op (completes the name space).

Symbol type: function

#`fio_memcpy1`

void * fio_memcpy1(void *restrict d, const void *restrict s)

Copies 1 byte from src (s) to dest (d).

Symbol type: function

#`fio_memcpy2`

void * fio_memcpy2(void *restrict d, const void *restrict s)

Copies 2 bytes from src (s) to dest (d).

Symbol type: function

#`fio_memcpy3`

void * fio_memcpy3(void *restrict d, const void *restrict s)

Copies 3 bytes from src (s) to dest (d).

Symbol type: function

#`fio_memcpy4`

void * fio_memcpy4(void *restrict d, const void *restrict s)

Copies 4 bytes from src (s) to dest (d).

Symbol type: function

#`fio_memcpy5`

void * fio_memcpy5(void *restrict d, const void *restrict s)

Copies 5 bytes from src (s) to dest (d).

Symbol type: function

#`fio_memcpy6`

void * fio_memcpy6(void *restrict d, const void *restrict s)

Copies 6 bytes from src (s) to dest (d).

Symbol type: function

#`fio_memcpy7`

void * fio_memcpy7(void *restrict d, const void *restrict s)

Copies 7 bytes from src (s) to dest (d).

Symbol type: function

#`fio_memcpy8`

void * fio_memcpy8(void *restrict d, const void *restrict s)

Copies 8 bytes from src (s) to dest (d).

Symbol type: function

#`fio_memcpy16`

void * fio_memcpy16(void *restrict d, const void *restrict s)

Copies 16 bytes from src (s) to dest (d).

Symbol type: function

#`fio_memcpy32`

void * fio_memcpy32(void *restrict d, const void *restrict s)

Copies 32 bytes from src (s) to dest (d).

Symbol type: function

#`fio_memcpy64`

void * fio_memcpy64(void *restrict d, const void *restrict s)

Copies 64 bytes from src (s) to dest (d).

Symbol type: function

#`fio_memcpy128`

void * fio_memcpy128(void *restrict d, const void *restrict s)

Copies 128 bytes from src (s) to dest (d).

Symbol type: function

#`fio_memcpy256`

void * fio_memcpy256(void *restrict d, const void *restrict s)

Copies 256 bytes from src (s) to dest (d).

Symbol type: function

#`fio_memcpy512`

void * fio_memcpy512(void *restrict d, const void *restrict s)

Copies 512 bytes from src (s) to dest (d).

Symbol type: function

#`fio_memcpy1024`

void * fio_memcpy1024(void *restrict d, const void *restrict s)

Copies 1024 bytes from src (s) to dest (d).

Symbol type: function

#`fio_memcpy2048`

void * fio_memcpy2048(void *restrict d, const void *restrict s)

Copies 2048 bytes from src (s) to dest (d).

Symbol type: function

#`fio_memcpy4096`

void * fio_memcpy4096(void *restrict d, const void *restrict s)

Copies 4096 bytes from src (s) to dest (d).

Symbol type: function

#`fio_memcpy0x`

FIO_SFUNC void *fio_memcpy0x(void *d, const void *s, size_t l)

No-op (completes the name space).

Symbol type: function

#`fio_memcpy7x`

void * fio_memcpy7x(void *restrict d, const void *restrict s, size_t len)

Copies up to len & lim bytes from src (s) to dest (d).

Symbol type: function

#`fio_memcpy15x`

void * fio_memcpy15x(void *restrict d, const void *restrict s, size_t len)

Copies up to len & lim bytes from src (s) to dest (d).

Symbol type: function

#`fio_memcpy31x`

void * fio_memcpy31x(void *restrict d, const void *restrict s, size_t len)

Copies up to len & lim bytes from src (s) to dest (d).

Symbol type: function

#`fio_memcpy63x`

void * fio_memcpy63x(void *restrict d, const void *restrict s, size_t len)

Copies up to len & lim bytes from src (s) to dest (d).

Symbol type: function

#`fio_memcpy127x`

void * fio_memcpy127x(void *restrict d, const void *restrict s, size_t len)

Copies up to len & lim bytes from src (s) to dest (d).

Symbol type: function

#`fio_memcpy255x`

void * fio_memcpy255x(void *restrict d, const void *restrict s, size_t len)

Copies up to len & lim bytes from src (s) to dest (d).

Symbol type: function

#`fio_memcpy511x`

void * fio_memcpy511x(void *restrict d, const void *restrict s, size_t len)

Copies up to len & lim bytes from src (s) to dest (d).

Symbol type: function

#`fio_memcpy1023x`

void * fio_memcpy1023x(void *restrict d, const void *restrict s, size_t len)

Copies up to len & lim bytes from src (s) to dest (d).

Symbol type: function

#`fio_memcpy2047x`

void * fio_memcpy2047x(void *restrict d, const void *restrict s, size_t len)

Copies up to len & lim bytes from src (s) to dest (d).

Symbol type: function

#`fio_memcpy4095x`

void * fio_memcpy4095x(void *restrict d, const void *restrict s, size_t len)

Copies up to len & lim bytes from src (s) to dest (d).

Symbol type: function

#`fio_bswap8`

#define fio_bswap8(i) (i)

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_bswap16`

#define fio_bswap16(i) __builtin_bswap16((uint16_t)(i))

Byte swap a 16 bit integer, inlined.

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_bswap32`

#define fio_bswap32(i) __builtin_bswap32((uint32_t)(i))

Byte swap a 32 bit integer, inlined.

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_bswap64`

#define fio_bswap64(i) __builtin_bswap64((uint64_t)(i))

Byte swap a 64 bit integer, inlined.

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_bswap128`

#define fio_bswap128(i) __builtin_bswap128((__uint128_t)(i))

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_bswap128`

inline FIO_CONST __uint128_t fio_bswap128(__uint128_t i)

Symbol type: function

#`fio_ltole8`

#define fio_ltole8(i) (i) /* avoid special cases by defining for all sizes */

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_lton8`

#define fio_lton8(i)  (i) /* avoid special cases by defining for all sizes */

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_ntol8`

#define fio_ntol8(i)  (i) /* avoid special cases by defining for all sizes */

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_lton16`

#define fio_lton16(i) (i)

Local byte order to Network byte order, 16 bit integer

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_lton32`

#define fio_lton32(i) (i)

Local byte order to Network byte order, 32 bit integer

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_lton64`

#define fio_lton64(i) (i)

Local byte order to Network byte order, 62 bit integer

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_ltole16`

#define fio_ltole16(i) fio_bswap16((i))

Local byte order to Little Endian byte order, 16 bit integer

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_ltole32`

#define fio_ltole32(i) fio_bswap32((i))

Local byte order to Little Endian byte order, 32 bit integer

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_ltole64`

#define fio_ltole64(i) fio_bswap64((i))

Local byte order to Little Endian byte order, 62 bit integer

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_ntol16`

#define fio_ntol16(i) (i)

Network byte order to Local byte order, 16 bit integer

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_ntol32`

#define fio_ntol32(i) (i)

Network byte order to Local byte order, 32 bit integer

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_ntol64`

#define fio_ntol64(i) (i)

Network byte order to Local byte order, 62 bit integer

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_ntol128`

#define fio_ntol128(i) (i)

Network byte order to Local byte order, 128 bit integer

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_ltole128`

#define fio_ltole128(i) fio_bswap128((i))

Local byte order to Little Endian byte order, 128 bit integer

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_lton128`

#define fio_lton128(i)  fio_bswap128((i))

Local byte order to Network byte order, 128 bit integer

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_buf2u8u`

inline uint8_t fio_buf2u8u(const void *c)

Converts an unaligned byte stream to an 8 bit number.

Symbol type: function

#`fio_u2buf8u`

inline void fio_u2buf8u(void *buf, uint8_t i)

Writes a local 8 bit number to an unaligned buffer.

Symbol type: function

#`fio_buf2u8_le`

inline uint8_t fio_buf2u8_le(const void *c)

Converts an unaligned byte stream to an 8 bit number.

Symbol type: function

#`fio_u2buf8_le`

inline void fio_u2buf8_le(void *buf, uint8_t i)

Writes a local 8 bit number to an unaligned buffer.

Symbol type: function

#`fio_buf2u8_be`

inline uint8_t fio_buf2u8_be(const void *c)

Converts an unaligned byte stream to an 8 bit number.

Symbol type: function

#`fio_u2buf8_be`

inline void fio_u2buf8_be(void *buf, uint8_t i)

Writes a local 8 bit number to an unaligned buffer.

Symbol type: function

#`fio_buf2u16u`

uint16_t fio_buf2u16u(const void *c)

Converts an unaligned byte stream to a bits bit number.

Symbol type: function

#`fio_u2buf16u`

void fio_u2buf16u(void *buf, uint16_t i)

Writes a bits bit number to an unaligned buffer.

Symbol type: function

#`fio_buf2u32u`

uint32_t fio_buf2u32u(const void *c)

Converts an unaligned byte stream to a bits bit number.

Symbol type: function

#`fio_u2buf32u`

void fio_u2buf32u(void *buf, uint32_t i)

Writes a bits bit number to an unaligned buffer.

Symbol type: function

#`fio_buf2u64u`

uint64_t fio_buf2u64u(const void *c)

Converts an unaligned byte stream to a bits bit number.

Symbol type: function

#`fio_u2buf64u`

void fio_u2buf64u(void *buf, uint64_t i)

Writes a bits bit number to an unaligned buffer.

Symbol type: function

#`fio_buf2u16_le`

uint16_t fio_buf2u16_le(const void *c)

Converts an unaligned byte stream to a bits bit number.

Symbol type: function

#`fio_u2buf16_le`

void fio_u2buf16_le(void *buf, uint16_t i)

Writes a bits bit number to an unaligned buffer.

Symbol type: function

#`fio_buf2u32_le`

uint32_t fio_buf2u32_le(const void *c)

Converts an unaligned byte stream to a bits bit number.

Symbol type: function

#`fio_u2buf32_le`

void fio_u2buf32_le(void *buf, uint32_t i)

Writes a bits bit number to an unaligned buffer.

Symbol type: function

#`fio_buf2u64_le`

uint64_t fio_buf2u64_le(const void *c)

Converts an unaligned byte stream to a bits bit number.

Symbol type: function

#`fio_u2buf64_le`

void fio_u2buf64_le(void *buf, uint64_t i)

Writes a bits bit number to an unaligned buffer.

Symbol type: function

#`fio_buf2u16_be`

uint16_t fio_buf2u16_be(const void *c)

Converts an unaligned byte stream to a bits bit number.

Symbol type: function

#`fio_u2buf16_be`

void fio_u2buf16_be(void *buf, uint16_t i)

Writes a bits bit number to an unaligned buffer.

Symbol type: function

#`fio_buf2u32_be`

uint32_t fio_buf2u32_be(const void *c)

Converts an unaligned byte stream to a bits bit number.

Symbol type: function

#`fio_u2buf32_be`

void fio_u2buf32_be(void *buf, uint32_t i)

Writes a bits bit number to an unaligned buffer.

Symbol type: function

#`fio_buf2u64_be`

uint64_t fio_buf2u64_be(const void *c)

Converts an unaligned byte stream to a bits bit number.

Symbol type: function

#`fio_u2buf64_be`

void fio_u2buf64_be(void *buf, uint64_t i)

Writes a bits bit number to an unaligned buffer.

Symbol type: function

#`fio_buf2u24_le`

inline uint32_t fio_buf2u24_le(const void *c)

Converts an unaligned byte stream to a 24 bit number.

Symbol type: function

#`fio_u2buf24_le`

inline void fio_u2buf24_le(void *buf, uint32_t i)

Writes a 24 bit number to an unaligned buffer.

Symbol type: function

#`fio_buf2u24_be`

inline uint32_t fio_buf2u24_be(const void *c)

Converts an unaligned byte stream to a 24 bit number.

Symbol type: function

#`fio_u2buf24_be`

inline void fio_u2buf24_be(void *buf, uint32_t i)

Writes a 24 bit number to an unaligned buffer.

Symbol type: function

#`fio_buf2u24u`

inline uint32_t fio_buf2u24u(const void *c)

Converts an unaligned byte stream to a 24 bit number - local endieness.

Symbol type: function

#`fio_u2buf24u`

inline void fio_u2buf24u(void *buf, uint32_t i)

Writes a 24 bit number to an unaligned buffer - in local endieness.

Symbol type: function

#`fio_buf2zu`

inline size_t fio_buf2zu(const void *c)

Converts an unaligned byte stream to a size_t - local endieness.

Symbol type: function

#`fio_u2bufzu`

inline void fio_u2bufzu(void *buf, size_t i)

Writes a size_t to an unaligned buffer - in local endieness.

Symbol type: function

#`fio_u8x4_add`

void fio_u8x4_add(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_u8x4_and`

void fio_u8x4_and(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a & b, storing the result in dest.

Symbol type: function

#`fio_u8x4_mul`

void fio_u8x4_mul(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_u8x4_or`

void fio_u8x4_or(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a | b, storing the result in dest.

Symbol type: function

#`fio_u8x4_reduce_add`

uint8_t fio_u8x4_reduce_add(uint8_t *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_u8x4_reduce_and`

uint8_t fio_u8x4_reduce_and(uint8_t *v)

Performs and in order along the vector, returning the result.

Symbol type: function

#`fio_u8x4_reduce_max`

uint8_t fio_u8x4_reduce_max(uint8_t *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_u8x4_reduce_min`

uint8_t fio_u8x4_reduce_min(uint8_t *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_u8x4_reduce_mul`

uint8_t fio_u8x4_reduce_mul(uint8_t *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_u8x4_reduce_or`

uint8_t fio_u8x4_reduce_or(uint8_t *v)

Performs or in order along the vector, returning the result.

Symbol type: function

#`fio_u8x4_reduce_sub`

uint8_t fio_u8x4_reduce_sub(uint8_t *v)

Performs sub in order along the vector, returning the result.

Symbol type: function

#`fio_u8x4_reduce_xor`

uint8_t fio_u8x4_reduce_xor(uint8_t *v)

Performs xor in order along the vector, returning the result.

Symbol type: function

#`fio_u8x4_reshuffle`

void fio_u8x4_reshuffle(uint8_t *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_u8x4_sub`

void fio_u8x4_sub(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a - b, storing the result in dest.

Symbol type: function

#`fio_u8x4_xor`

void fio_u8x4_xor(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a ^ b, storing the result in dest.

Symbol type: function

#`fio_u8x8_add`

void fio_u8x8_add(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_u8x8_and`

void fio_u8x8_and(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a & b, storing the result in dest.

Symbol type: function

#`fio_u8x8_mul`

void fio_u8x8_mul(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_u8x8_or`

void fio_u8x8_or(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a | b, storing the result in dest.

Symbol type: function

#`fio_u8x8_reduce_add`

uint8_t fio_u8x8_reduce_add(uint8_t *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_u8x8_reduce_and`

uint8_t fio_u8x8_reduce_and(uint8_t *v)

Performs and in order along the vector, returning the result.

Symbol type: function

#`fio_u8x8_reduce_max`

uint8_t fio_u8x8_reduce_max(uint8_t *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_u8x8_reduce_min`

uint8_t fio_u8x8_reduce_min(uint8_t *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_u8x8_reduce_mul`

uint8_t fio_u8x8_reduce_mul(uint8_t *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_u8x8_reduce_or`

uint8_t fio_u8x8_reduce_or(uint8_t *v)

Performs or in order along the vector, returning the result.

Symbol type: function

#`fio_u8x8_reduce_sub`

uint8_t fio_u8x8_reduce_sub(uint8_t *v)

Performs sub in order along the vector, returning the result.

Symbol type: function

#`fio_u8x8_reduce_xor`

uint8_t fio_u8x8_reduce_xor(uint8_t *v)

Performs xor in order along the vector, returning the result.

Symbol type: function

#`fio_u8x8_reshuffle`

void fio_u8x8_reshuffle(uint8_t *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_u8x8_sub`

void fio_u8x8_sub(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a - b, storing the result in dest.

Symbol type: function

#`fio_u8x8_xor`

void fio_u8x8_xor(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a ^ b, storing the result in dest.

Symbol type: function

#`fio_u8x16_add`

void fio_u8x16_add(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_u8x16_and`

void fio_u8x16_and(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a & b, storing the result in dest.

Symbol type: function

#`fio_u8x16_mul`

void fio_u8x16_mul(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_u8x16_or`

void fio_u8x16_or(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a | b, storing the result in dest.

Symbol type: function

#`fio_u8x16_reduce_add`

uint8_t fio_u8x16_reduce_add(uint8_t *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_u8x16_reduce_and`

uint8_t fio_u8x16_reduce_and(uint8_t *v)

Performs and in order along the vector, returning the result.

Symbol type: function

#`fio_u8x16_reduce_max`

uint8_t fio_u8x16_reduce_max(uint8_t *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_u8x16_reduce_min`

uint8_t fio_u8x16_reduce_min(uint8_t *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_u8x16_reduce_mul`

uint8_t fio_u8x16_reduce_mul(uint8_t *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_u8x16_reduce_or`

uint8_t fio_u8x16_reduce_or(uint8_t *v)

Performs or in order along the vector, returning the result.

Symbol type: function

#`fio_u8x16_reduce_sub`

uint8_t fio_u8x16_reduce_sub(uint8_t *v)

Performs sub in order along the vector, returning the result.

Symbol type: function

#`fio_u8x16_reduce_xor`

uint8_t fio_u8x16_reduce_xor(uint8_t *v)

Performs xor in order along the vector, returning the result.

Symbol type: function

#`fio_u8x16_reshuffle`

void fio_u8x16_reshuffle(uint8_t *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_u8x16_sub`

void fio_u8x16_sub(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a - b, storing the result in dest.

Symbol type: function

#`fio_u8x16_xor`

void fio_u8x16_xor(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a ^ b, storing the result in dest.

Symbol type: function

#`fio_u8x32_add`

void fio_u8x32_add(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_u8x32_and`

void fio_u8x32_and(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a & b, storing the result in dest.

Symbol type: function

#`fio_u8x32_mul`

void fio_u8x32_mul(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_u8x32_or`

void fio_u8x32_or(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a | b, storing the result in dest.

Symbol type: function

#`fio_u8x32_reduce_add`

uint8_t fio_u8x32_reduce_add(uint8_t *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_u8x32_reduce_and`

uint8_t fio_u8x32_reduce_and(uint8_t *v)

Performs and in order along the vector, returning the result.

Symbol type: function

#`fio_u8x32_reduce_max`

uint8_t fio_u8x32_reduce_max(uint8_t *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_u8x32_reduce_min`

uint8_t fio_u8x32_reduce_min(uint8_t *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_u8x32_reduce_mul`

uint8_t fio_u8x32_reduce_mul(uint8_t *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_u8x32_reduce_or`

uint8_t fio_u8x32_reduce_or(uint8_t *v)

Performs or in order along the vector, returning the result.

Symbol type: function

#`fio_u8x32_reduce_sub`

uint8_t fio_u8x32_reduce_sub(uint8_t *v)

Performs sub in order along the vector, returning the result.

Symbol type: function

#`fio_u8x32_reduce_xor`

uint8_t fio_u8x32_reduce_xor(uint8_t *v)

Performs xor in order along the vector, returning the result.

Symbol type: function

#`fio_u8x32_reshuffle`

void fio_u8x32_reshuffle(uint8_t *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_u8x32_sub`

void fio_u8x32_sub(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a - b, storing the result in dest.

Symbol type: function

#`fio_u8x32_xor`

void fio_u8x32_xor(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a ^ b, storing the result in dest.

Symbol type: function

#`fio_u8x64_add`

void fio_u8x64_add(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_u8x64_and`

void fio_u8x64_and(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a & b, storing the result in dest.

Symbol type: function

#`fio_u8x64_mul`

void fio_u8x64_mul(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_u8x64_or`

void fio_u8x64_or(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a | b, storing the result in dest.

Symbol type: function

#`fio_u8x64_reduce_add`

uint8_t fio_u8x64_reduce_add(uint8_t *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_u8x64_reduce_and`

uint8_t fio_u8x64_reduce_and(uint8_t *v)

Performs and in order along the vector, returning the result.

Symbol type: function

#`fio_u8x64_reduce_max`

uint8_t fio_u8x64_reduce_max(uint8_t *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_u8x64_reduce_min`

uint8_t fio_u8x64_reduce_min(uint8_t *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_u8x64_reduce_mul`

uint8_t fio_u8x64_reduce_mul(uint8_t *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_u8x64_reduce_or`

uint8_t fio_u8x64_reduce_or(uint8_t *v)

Performs or in order along the vector, returning the result.

Symbol type: function

#`fio_u8x64_reduce_sub`

uint8_t fio_u8x64_reduce_sub(uint8_t *v)

Performs sub in order along the vector, returning the result.

Symbol type: function

#`fio_u8x64_reduce_xor`

uint8_t fio_u8x64_reduce_xor(uint8_t *v)

Performs xor in order along the vector, returning the result.

Symbol type: function

#`fio_u8x64_reshuffle`

void fio_u8x64_reshuffle(uint8_t *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_u8x64_sub`

void fio_u8x64_sub(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a - b, storing the result in dest.

Symbol type: function

#`fio_u8x64_xor`

void fio_u8x64_xor(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a ^ b, storing the result in dest.

Symbol type: function

#`fio_u8x128_add`

void fio_u8x128_add(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_u8x128_and`

void fio_u8x128_and(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a & b, storing the result in dest.

Symbol type: function

#`fio_u8x128_mul`

void fio_u8x128_mul(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_u8x128_or`

void fio_u8x128_or(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a | b, storing the result in dest.

Symbol type: function

#`fio_u8x128_reduce_add`

uint8_t fio_u8x128_reduce_add(uint8_t *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_u8x128_reduce_and`

uint8_t fio_u8x128_reduce_and(uint8_t *v)

Performs and in order along the vector, returning the result.

Symbol type: function

#`fio_u8x128_reduce_max`

uint8_t fio_u8x128_reduce_max(uint8_t *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_u8x128_reduce_min`

uint8_t fio_u8x128_reduce_min(uint8_t *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_u8x128_reduce_mul`

uint8_t fio_u8x128_reduce_mul(uint8_t *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_u8x128_reduce_or`

uint8_t fio_u8x128_reduce_or(uint8_t *v)

Performs or in order along the vector, returning the result.

Symbol type: function

#`fio_u8x128_reduce_sub`

uint8_t fio_u8x128_reduce_sub(uint8_t *v)

Performs sub in order along the vector, returning the result.

Symbol type: function

#`fio_u8x128_reduce_xor`

uint8_t fio_u8x128_reduce_xor(uint8_t *v)

Performs xor in order along the vector, returning the result.

Symbol type: function

#`fio_u8x128_reshuffle`

void fio_u8x128_reshuffle(uint8_t *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_u8x128_sub`

void fio_u8x128_sub(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a - b, storing the result in dest.

Symbol type: function

#`fio_u8x128_xor`

void fio_u8x128_xor(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a ^ b, storing the result in dest.

Symbol type: function

#`fio_u8x256_add`

void fio_u8x256_add(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_u8x256_and`

void fio_u8x256_and(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a & b, storing the result in dest.

Symbol type: function

#`fio_u8x256_mul`

void fio_u8x256_mul(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_u8x256_or`

void fio_u8x256_or(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a | b, storing the result in dest.

Symbol type: function

#`fio_u8x256_reduce_add`

uint8_t fio_u8x256_reduce_add(uint8_t *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_u8x256_reduce_and`

uint8_t fio_u8x256_reduce_and(uint8_t *v)

Performs and in order along the vector, returning the result.

Symbol type: function

#`fio_u8x256_reduce_max`

uint8_t fio_u8x256_reduce_max(uint8_t *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_u8x256_reduce_min`

uint8_t fio_u8x256_reduce_min(uint8_t *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_u8x256_reduce_mul`

uint8_t fio_u8x256_reduce_mul(uint8_t *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_u8x256_reduce_or`

uint8_t fio_u8x256_reduce_or(uint8_t *v)

Performs or in order along the vector, returning the result.

Symbol type: function

#`fio_u8x256_reduce_sub`

uint8_t fio_u8x256_reduce_sub(uint8_t *v)

Performs sub in order along the vector, returning the result.

Symbol type: function

#`fio_u8x256_reduce_xor`

uint8_t fio_u8x256_reduce_xor(uint8_t *v)

Performs xor in order along the vector, returning the result.

Symbol type: function

#`fio_u8x256_reshuffle`

void fio_u8x256_reshuffle(uint8_t *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_u8x256_sub`

void fio_u8x256_sub(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a - b, storing the result in dest.

Symbol type: function

#`fio_u8x256_xor`

void fio_u8x256_xor(uint8_t *dest, uint8_t *a, uint8_t *b)

Performs operation a ^ b, storing the result in dest.

Symbol type: function

#`fio_u16x2_add`

void fio_u16x2_add(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_u16x2_and`

void fio_u16x2_and(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a & b, storing the result in dest.

Symbol type: function

#`fio_u16x2_mul`

void fio_u16x2_mul(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_u16x2_or`

void fio_u16x2_or(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a | b, storing the result in dest.

Symbol type: function

#`fio_u16x2_reduce_add`

uint16_t fio_u16x2_reduce_add(uint16_t *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_u16x2_reduce_and`

uint16_t fio_u16x2_reduce_and(uint16_t *v)

Performs and in order along the vector, returning the result.

Symbol type: function

#`fio_u16x2_reduce_max`

uint16_t fio_u16x2_reduce_max(uint16_t *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_u16x2_reduce_min`

uint16_t fio_u16x2_reduce_min(uint16_t *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_u16x2_reduce_mul`

uint16_t fio_u16x2_reduce_mul(uint16_t *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_u16x2_reduce_or`

uint16_t fio_u16x2_reduce_or(uint16_t *v)

Performs or in order along the vector, returning the result.

Symbol type: function

#`fio_u16x2_reduce_sub`

uint16_t fio_u16x2_reduce_sub(uint16_t *v)

Performs sub in order along the vector, returning the result.

Symbol type: function

#`fio_u16x2_reduce_xor`

uint16_t fio_u16x2_reduce_xor(uint16_t *v)

Performs xor in order along the vector, returning the result.

Symbol type: function

#`fio_u16x2_reshuffle`

void fio_u16x2_reshuffle(uint16_t *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_u16x2_sub`

void fio_u16x2_sub(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a - b, storing the result in dest.

Symbol type: function

#`fio_u16x2_xor`

void fio_u16x2_xor(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a ^ b, storing the result in dest.

Symbol type: function

#`fio_u16x4_add`

void fio_u16x4_add(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_u16x4_and`

void fio_u16x4_and(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a & b, storing the result in dest.

Symbol type: function

#`fio_u16x4_mul`

void fio_u16x4_mul(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_u16x4_or`

void fio_u16x4_or(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a | b, storing the result in dest.

Symbol type: function

#`fio_u16x4_reduce_add`

uint16_t fio_u16x4_reduce_add(uint16_t *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_u16x4_reduce_and`

uint16_t fio_u16x4_reduce_and(uint16_t *v)

Performs and in order along the vector, returning the result.

Symbol type: function

#`fio_u16x4_reduce_max`

uint16_t fio_u16x4_reduce_max(uint16_t *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_u16x4_reduce_min`

uint16_t fio_u16x4_reduce_min(uint16_t *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_u16x4_reduce_mul`

uint16_t fio_u16x4_reduce_mul(uint16_t *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_u16x4_reduce_or`

uint16_t fio_u16x4_reduce_or(uint16_t *v)

Performs or in order along the vector, returning the result.

Symbol type: function

#`fio_u16x4_reduce_sub`

uint16_t fio_u16x4_reduce_sub(uint16_t *v)

Performs sub in order along the vector, returning the result.

Symbol type: function

#`fio_u16x4_reduce_xor`

uint16_t fio_u16x4_reduce_xor(uint16_t *v)

Performs xor in order along the vector, returning the result.

Symbol type: function

#`fio_u16x4_reshuffle`

void fio_u16x4_reshuffle(uint16_t *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_u16x4_sub`

void fio_u16x4_sub(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a - b, storing the result in dest.

Symbol type: function

#`fio_u16x4_xor`

void fio_u16x4_xor(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a ^ b, storing the result in dest.

Symbol type: function

#`fio_u16x8_add`

void fio_u16x8_add(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_u16x8_and`

void fio_u16x8_and(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a & b, storing the result in dest.

Symbol type: function

#`fio_u16x8_mul`

void fio_u16x8_mul(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_u16x8_or`

void fio_u16x8_or(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a | b, storing the result in dest.

Symbol type: function

#`fio_u16x8_reduce_add`

uint16_t fio_u16x8_reduce_add(uint16_t *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_u16x8_reduce_and`

uint16_t fio_u16x8_reduce_and(uint16_t *v)

Performs and in order along the vector, returning the result.

Symbol type: function

#`fio_u16x8_reduce_max`

uint16_t fio_u16x8_reduce_max(uint16_t *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_u16x8_reduce_min`

uint16_t fio_u16x8_reduce_min(uint16_t *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_u16x8_reduce_mul`

uint16_t fio_u16x8_reduce_mul(uint16_t *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_u16x8_reduce_or`

uint16_t fio_u16x8_reduce_or(uint16_t *v)

Performs or in order along the vector, returning the result.

Symbol type: function

#`fio_u16x8_reduce_sub`

uint16_t fio_u16x8_reduce_sub(uint16_t *v)

Performs sub in order along the vector, returning the result.

Symbol type: function

#`fio_u16x8_reduce_xor`

uint16_t fio_u16x8_reduce_xor(uint16_t *v)

Performs xor in order along the vector, returning the result.

Symbol type: function

#`fio_u16x8_reshuffle`

void fio_u16x8_reshuffle(uint16_t *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_u16x8_sub`

void fio_u16x8_sub(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a - b, storing the result in dest.

Symbol type: function

#`fio_u16x8_xor`

void fio_u16x8_xor(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a ^ b, storing the result in dest.

Symbol type: function

#`fio_u16x16_add`

void fio_u16x16_add(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_u16x16_and`

void fio_u16x16_and(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a & b, storing the result in dest.

Symbol type: function

#`fio_u16x16_mul`

void fio_u16x16_mul(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_u16x16_or`

void fio_u16x16_or(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a | b, storing the result in dest.

Symbol type: function

#`fio_u16x16_reduce_add`

uint16_t fio_u16x16_reduce_add(uint16_t *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_u16x16_reduce_and`

uint16_t fio_u16x16_reduce_and(uint16_t *v)

Performs and in order along the vector, returning the result.

Symbol type: function

#`fio_u16x16_reduce_max`

uint16_t fio_u16x16_reduce_max(uint16_t *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_u16x16_reduce_min`

uint16_t fio_u16x16_reduce_min(uint16_t *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_u16x16_reduce_mul`

uint16_t fio_u16x16_reduce_mul(uint16_t *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_u16x16_reduce_or`

uint16_t fio_u16x16_reduce_or(uint16_t *v)

Performs or in order along the vector, returning the result.

Symbol type: function

#`fio_u16x16_reduce_sub`

uint16_t fio_u16x16_reduce_sub(uint16_t *v)

Performs sub in order along the vector, returning the result.

Symbol type: function

#`fio_u16x16_reduce_xor`

uint16_t fio_u16x16_reduce_xor(uint16_t *v)

Performs xor in order along the vector, returning the result.

Symbol type: function

#`fio_u16x16_reshuffle`

void fio_u16x16_reshuffle(uint16_t *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_u16x16_sub`

void fio_u16x16_sub(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a - b, storing the result in dest.

Symbol type: function

#`fio_u16x16_xor`

void fio_u16x16_xor(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a ^ b, storing the result in dest.

Symbol type: function

#`fio_u16x32_add`

void fio_u16x32_add(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_u16x32_and`

void fio_u16x32_and(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a & b, storing the result in dest.

Symbol type: function

#`fio_u16x32_mul`

void fio_u16x32_mul(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_u16x32_or`

void fio_u16x32_or(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a | b, storing the result in dest.

Symbol type: function

#`fio_u16x32_reduce_add`

uint16_t fio_u16x32_reduce_add(uint16_t *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_u16x32_reduce_and`

uint16_t fio_u16x32_reduce_and(uint16_t *v)

Performs and in order along the vector, returning the result.

Symbol type: function

#`fio_u16x32_reduce_max`

uint16_t fio_u16x32_reduce_max(uint16_t *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_u16x32_reduce_min`

uint16_t fio_u16x32_reduce_min(uint16_t *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_u16x32_reduce_mul`

uint16_t fio_u16x32_reduce_mul(uint16_t *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_u16x32_reduce_or`

uint16_t fio_u16x32_reduce_or(uint16_t *v)

Performs or in order along the vector, returning the result.

Symbol type: function

#`fio_u16x32_reduce_sub`

uint16_t fio_u16x32_reduce_sub(uint16_t *v)

Performs sub in order along the vector, returning the result.

Symbol type: function

#`fio_u16x32_reduce_xor`

uint16_t fio_u16x32_reduce_xor(uint16_t *v)

Performs xor in order along the vector, returning the result.

Symbol type: function

#`fio_u16x32_reshuffle`

void fio_u16x32_reshuffle(uint16_t *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_u16x32_sub`

void fio_u16x32_sub(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a - b, storing the result in dest.

Symbol type: function

#`fio_u16x32_xor`

void fio_u16x32_xor(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a ^ b, storing the result in dest.

Symbol type: function

#`fio_u16x64_add`

void fio_u16x64_add(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_u16x64_and`

void fio_u16x64_and(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a & b, storing the result in dest.

Symbol type: function

#`fio_u16x64_mul`

void fio_u16x64_mul(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_u16x64_or`

void fio_u16x64_or(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a | b, storing the result in dest.

Symbol type: function

#`fio_u16x64_reduce_add`

uint16_t fio_u16x64_reduce_add(uint16_t *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_u16x64_reduce_and`

uint16_t fio_u16x64_reduce_and(uint16_t *v)

Performs and in order along the vector, returning the result.

Symbol type: function

#`fio_u16x64_reduce_max`

uint16_t fio_u16x64_reduce_max(uint16_t *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_u16x64_reduce_min`

uint16_t fio_u16x64_reduce_min(uint16_t *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_u16x64_reduce_mul`

uint16_t fio_u16x64_reduce_mul(uint16_t *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_u16x64_reduce_or`

uint16_t fio_u16x64_reduce_or(uint16_t *v)

Performs or in order along the vector, returning the result.

Symbol type: function

#`fio_u16x64_reduce_sub`

uint16_t fio_u16x64_reduce_sub(uint16_t *v)

Performs sub in order along the vector, returning the result.

Symbol type: function

#`fio_u16x64_reduce_xor`

uint16_t fio_u16x64_reduce_xor(uint16_t *v)

Performs xor in order along the vector, returning the result.

Symbol type: function

#`fio_u16x64_reshuffle`

void fio_u16x64_reshuffle(uint16_t *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_u16x64_sub`

void fio_u16x64_sub(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a - b, storing the result in dest.

Symbol type: function

#`fio_u16x64_xor`

void fio_u16x64_xor(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a ^ b, storing the result in dest.

Symbol type: function

#`fio_u16x128_add`

void fio_u16x128_add(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_u16x128_and`

void fio_u16x128_and(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a & b, storing the result in dest.

Symbol type: function

#`fio_u16x128_mul`

void fio_u16x128_mul(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_u16x128_or`

void fio_u16x128_or(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a | b, storing the result in dest.

Symbol type: function

#`fio_u16x128_reduce_add`

uint16_t fio_u16x128_reduce_add(uint16_t *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_u16x128_reduce_and`

uint16_t fio_u16x128_reduce_and(uint16_t *v)

Performs and in order along the vector, returning the result.

Symbol type: function

#`fio_u16x128_reduce_max`

uint16_t fio_u16x128_reduce_max(uint16_t *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_u16x128_reduce_min`

uint16_t fio_u16x128_reduce_min(uint16_t *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_u16x128_reduce_mul`

uint16_t fio_u16x128_reduce_mul(uint16_t *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_u16x128_reduce_or`

uint16_t fio_u16x128_reduce_or(uint16_t *v)

Performs or in order along the vector, returning the result.

Symbol type: function

#`fio_u16x128_reduce_sub`

uint16_t fio_u16x128_reduce_sub(uint16_t *v)

Performs sub in order along the vector, returning the result.

Symbol type: function

#`fio_u16x128_reduce_xor`

uint16_t fio_u16x128_reduce_xor(uint16_t *v)

Performs xor in order along the vector, returning the result.

Symbol type: function

#`fio_u16x128_reshuffle`

void fio_u16x128_reshuffle(uint16_t *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_u16x128_sub`

void fio_u16x128_sub(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a - b, storing the result in dest.

Symbol type: function

#`fio_u16x128_xor`

void fio_u16x128_xor(uint16_t *dest, uint16_t *a, uint16_t *b)

Performs operation a ^ b, storing the result in dest.

Symbol type: function

#`fio_u32x2_add`

void fio_u32x2_add(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_u32x2_and`

void fio_u32x2_and(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a & b, storing the result in dest.

Symbol type: function

#`fio_u32x2_mul`

void fio_u32x2_mul(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_u32x2_or`

void fio_u32x2_or(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a | b, storing the result in dest.

Symbol type: function

#`fio_u32x2_reduce_add`

uint32_t fio_u32x2_reduce_add(uint32_t *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_u32x2_reduce_and`

uint32_t fio_u32x2_reduce_and(uint32_t *v)

Performs and in order along the vector, returning the result.

Symbol type: function

#`fio_u32x2_reduce_max`

uint32_t fio_u32x2_reduce_max(uint32_t *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_u32x2_reduce_min`

uint32_t fio_u32x2_reduce_min(uint32_t *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_u32x2_reduce_mul`

uint32_t fio_u32x2_reduce_mul(uint32_t *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_u32x2_reduce_or`

uint32_t fio_u32x2_reduce_or(uint32_t *v)

Performs or in order along the vector, returning the result.

Symbol type: function

#`fio_u32x2_reduce_sub`

uint32_t fio_u32x2_reduce_sub(uint32_t *v)

Performs sub in order along the vector, returning the result.

Symbol type: function

#`fio_u32x2_reduce_xor`

uint32_t fio_u32x2_reduce_xor(uint32_t *v)

Performs xor in order along the vector, returning the result.

Symbol type: function

#`fio_u32x2_reshuffle`

void fio_u32x2_reshuffle(uint32_t *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_u32x2_sub`

void fio_u32x2_sub(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a - b, storing the result in dest.

Symbol type: function

#`fio_u32x2_xor`

void fio_u32x2_xor(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a ^ b, storing the result in dest.

Symbol type: function

#`fio_u32x4_add`

void fio_u32x4_add(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_u32x4_and`

void fio_u32x4_and(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a & b, storing the result in dest.

Symbol type: function

#`fio_u32x4_mul`

void fio_u32x4_mul(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_u32x4_or`

void fio_u32x4_or(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a | b, storing the result in dest.

Symbol type: function

#`fio_u32x4_reduce_add`

uint32_t fio_u32x4_reduce_add(uint32_t *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_u32x4_reduce_and`

uint32_t fio_u32x4_reduce_and(uint32_t *v)

Performs and in order along the vector, returning the result.

Symbol type: function

#`fio_u32x4_reduce_max`

uint32_t fio_u32x4_reduce_max(uint32_t *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_u32x4_reduce_min`

uint32_t fio_u32x4_reduce_min(uint32_t *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_u32x4_reduce_mul`

uint32_t fio_u32x4_reduce_mul(uint32_t *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_u32x4_reduce_or`

uint32_t fio_u32x4_reduce_or(uint32_t *v)

Performs or in order along the vector, returning the result.

Symbol type: function

#`fio_u32x4_reduce_sub`

uint32_t fio_u32x4_reduce_sub(uint32_t *v)

Performs sub in order along the vector, returning the result.

Symbol type: function

#`fio_u32x4_reduce_xor`

uint32_t fio_u32x4_reduce_xor(uint32_t *v)

Performs xor in order along the vector, returning the result.

Symbol type: function

#`fio_u32x4_reshuffle`

void fio_u32x4_reshuffle(uint32_t *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_u32x4_sub`

void fio_u32x4_sub(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a - b, storing the result in dest.

Symbol type: function

#`fio_u32x4_xor`

void fio_u32x4_xor(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a ^ b, storing the result in dest.

Symbol type: function

#`fio_u32x8_add`

void fio_u32x8_add(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_u32x8_and`

void fio_u32x8_and(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a & b, storing the result in dest.

Symbol type: function

#`fio_u32x8_mul`

void fio_u32x8_mul(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_u32x8_or`

void fio_u32x8_or(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a | b, storing the result in dest.

Symbol type: function

#`fio_u32x8_reduce_add`

uint32_t fio_u32x8_reduce_add(uint32_t *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_u32x8_reduce_and`

uint32_t fio_u32x8_reduce_and(uint32_t *v)

Performs and in order along the vector, returning the result.

Symbol type: function

#`fio_u32x8_reduce_max`

uint32_t fio_u32x8_reduce_max(uint32_t *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_u32x8_reduce_min`

uint32_t fio_u32x8_reduce_min(uint32_t *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_u32x8_reduce_mul`

uint32_t fio_u32x8_reduce_mul(uint32_t *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_u32x8_reduce_or`

uint32_t fio_u32x8_reduce_or(uint32_t *v)

Performs or in order along the vector, returning the result.

Symbol type: function

#`fio_u32x8_reduce_sub`

uint32_t fio_u32x8_reduce_sub(uint32_t *v)

Performs sub in order along the vector, returning the result.

Symbol type: function

#`fio_u32x8_reduce_xor`

uint32_t fio_u32x8_reduce_xor(uint32_t *v)

Performs xor in order along the vector, returning the result.

Symbol type: function

#`fio_u32x8_reshuffle`

void fio_u32x8_reshuffle(uint32_t *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_u32x8_sub`

void fio_u32x8_sub(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a - b, storing the result in dest.

Symbol type: function

#`fio_u32x8_xor`

void fio_u32x8_xor(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a ^ b, storing the result in dest.

Symbol type: function

#`fio_u32x16_add`

void fio_u32x16_add(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_u32x16_and`

void fio_u32x16_and(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a & b, storing the result in dest.

Symbol type: function

#`fio_u32x16_mul`

void fio_u32x16_mul(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_u32x16_or`

void fio_u32x16_or(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a | b, storing the result in dest.

Symbol type: function

#`fio_u32x16_reduce_add`

uint32_t fio_u32x16_reduce_add(uint32_t *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_u32x16_reduce_and`

uint32_t fio_u32x16_reduce_and(uint32_t *v)

Performs and in order along the vector, returning the result.

Symbol type: function

#`fio_u32x16_reduce_max`

uint32_t fio_u32x16_reduce_max(uint32_t *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_u32x16_reduce_min`

uint32_t fio_u32x16_reduce_min(uint32_t *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_u32x16_reduce_mul`

uint32_t fio_u32x16_reduce_mul(uint32_t *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_u32x16_reduce_or`

uint32_t fio_u32x16_reduce_or(uint32_t *v)

Performs or in order along the vector, returning the result.

Symbol type: function

#`fio_u32x16_reduce_sub`

uint32_t fio_u32x16_reduce_sub(uint32_t *v)

Performs sub in order along the vector, returning the result.

Symbol type: function

#`fio_u32x16_reduce_xor`

uint32_t fio_u32x16_reduce_xor(uint32_t *v)

Performs xor in order along the vector, returning the result.

Symbol type: function

#`fio_u32x16_reshuffle`

void fio_u32x16_reshuffle(uint32_t *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_u32x16_sub`

void fio_u32x16_sub(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a - b, storing the result in dest.

Symbol type: function

#`fio_u32x16_xor`

void fio_u32x16_xor(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a ^ b, storing the result in dest.

Symbol type: function

#`fio_u32x32_add`

void fio_u32x32_add(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_u32x32_and`

void fio_u32x32_and(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a & b, storing the result in dest.

Symbol type: function

#`fio_u32x32_mul`

void fio_u32x32_mul(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_u32x32_or`

void fio_u32x32_or(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a | b, storing the result in dest.

Symbol type: function

#`fio_u32x32_reduce_add`

uint32_t fio_u32x32_reduce_add(uint32_t *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_u32x32_reduce_and`

uint32_t fio_u32x32_reduce_and(uint32_t *v)

Performs and in order along the vector, returning the result.

Symbol type: function

#`fio_u32x32_reduce_max`

uint32_t fio_u32x32_reduce_max(uint32_t *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_u32x32_reduce_min`

uint32_t fio_u32x32_reduce_min(uint32_t *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_u32x32_reduce_mul`

uint32_t fio_u32x32_reduce_mul(uint32_t *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_u32x32_reduce_or`

uint32_t fio_u32x32_reduce_or(uint32_t *v)

Performs or in order along the vector, returning the result.

Symbol type: function

#`fio_u32x32_reduce_sub`

uint32_t fio_u32x32_reduce_sub(uint32_t *v)

Performs sub in order along the vector, returning the result.

Symbol type: function

#`fio_u32x32_reduce_xor`

uint32_t fio_u32x32_reduce_xor(uint32_t *v)

Performs xor in order along the vector, returning the result.

Symbol type: function

#`fio_u32x32_reshuffle`

void fio_u32x32_reshuffle(uint32_t *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_u32x32_sub`

void fio_u32x32_sub(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a - b, storing the result in dest.

Symbol type: function

#`fio_u32x32_xor`

void fio_u32x32_xor(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a ^ b, storing the result in dest.

Symbol type: function

#`fio_u32x64_add`

void fio_u32x64_add(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_u32x64_and`

void fio_u32x64_and(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a & b, storing the result in dest.

Symbol type: function

#`fio_u32x64_mul`

void fio_u32x64_mul(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_u32x64_or`

void fio_u32x64_or(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a | b, storing the result in dest.

Symbol type: function

#`fio_u32x64_reduce_add`

uint32_t fio_u32x64_reduce_add(uint32_t *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_u32x64_reduce_and`

uint32_t fio_u32x64_reduce_and(uint32_t *v)

Performs and in order along the vector, returning the result.

Symbol type: function

#`fio_u32x64_reduce_max`

uint32_t fio_u32x64_reduce_max(uint32_t *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_u32x64_reduce_min`

uint32_t fio_u32x64_reduce_min(uint32_t *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_u32x64_reduce_mul`

uint32_t fio_u32x64_reduce_mul(uint32_t *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_u32x64_reduce_or`

uint32_t fio_u32x64_reduce_or(uint32_t *v)

Performs or in order along the vector, returning the result.

Symbol type: function

#`fio_u32x64_reduce_sub`

uint32_t fio_u32x64_reduce_sub(uint32_t *v)

Performs sub in order along the vector, returning the result.

Symbol type: function

#`fio_u32x64_reduce_xor`

uint32_t fio_u32x64_reduce_xor(uint32_t *v)

Performs xor in order along the vector, returning the result.

Symbol type: function

#`fio_u32x64_reshuffle`

void fio_u32x64_reshuffle(uint32_t *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_u32x64_sub`

void fio_u32x64_sub(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a - b, storing the result in dest.

Symbol type: function

#`fio_u32x64_xor`

void fio_u32x64_xor(uint32_t *dest, uint32_t *a, uint32_t *b)

Performs operation a ^ b, storing the result in dest.

Symbol type: function

#`fio_u64x2_add`

void fio_u64x2_add(uint64_t *dest, uint64_t *a, uint64_t *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_u64x2_and`

void fio_u64x2_and(uint64_t *dest, uint64_t *a, uint64_t *b)

Performs operation a & b, storing the result in dest.

Symbol type: function

#`fio_u64x2_mul`

void fio_u64x2_mul(uint64_t *dest, uint64_t *a, uint64_t *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_u64x2_or`

void fio_u64x2_or(uint64_t *dest, uint64_t *a, uint64_t *b)

Performs operation a | b, storing the result in dest.

Symbol type: function

#`fio_u64x2_reduce_add`

uint64_t fio_u64x2_reduce_add(uint64_t *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_u64x2_reduce_and`

uint64_t fio_u64x2_reduce_and(uint64_t *v)

Performs and in order along the vector, returning the result.

Symbol type: function

#`fio_u64x2_reduce_max`

uint64_t fio_u64x2_reduce_max(uint64_t *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_u64x2_reduce_min`

uint64_t fio_u64x2_reduce_min(uint64_t *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_u64x2_reduce_mul`

uint64_t fio_u64x2_reduce_mul(uint64_t *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_u64x2_reduce_or`

uint64_t fio_u64x2_reduce_or(uint64_t *v)

Performs or in order along the vector, returning the result.

Symbol type: function

#`fio_u64x2_reduce_sub`

uint64_t fio_u64x2_reduce_sub(uint64_t *v)

Performs sub in order along the vector, returning the result.

Symbol type: function

#`fio_u64x2_reduce_xor`

uint64_t fio_u64x2_reduce_xor(uint64_t *v)

Performs xor in order along the vector, returning the result.

Symbol type: function

#`fio_u64x2_reshuffle`

void fio_u64x2_reshuffle(uint64_t *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_u64x2_sub`

void fio_u64x2_sub(uint64_t *dest, uint64_t *a, uint64_t *b)

Performs operation a - b, storing the result in dest.

Symbol type: function

#`fio_u64x2_xor`

void fio_u64x2_xor(uint64_t *dest, uint64_t *a, uint64_t *b)

Performs operation a ^ b, storing the result in dest.

Symbol type: function

#`fio_u64x4_add`

void fio_u64x4_add(uint64_t *dest, uint64_t *a, uint64_t *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_u64x4_and`

void fio_u64x4_and(uint64_t *dest, uint64_t *a, uint64_t *b)

Performs operation a & b, storing the result in dest.

Symbol type: function

#`fio_u64x4_mul`

void fio_u64x4_mul(uint64_t *dest, uint64_t *a, uint64_t *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_u64x4_or`

void fio_u64x4_or(uint64_t *dest, uint64_t *a, uint64_t *b)

Performs operation a | b, storing the result in dest.

Symbol type: function

#`fio_u64x4_reduce_add`

uint64_t fio_u64x4_reduce_add(uint64_t *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_u64x4_reduce_and`

uint64_t fio_u64x4_reduce_and(uint64_t *v)

Performs and in order along the vector, returning the result.

Symbol type: function

#`fio_u64x4_reduce_max`

uint64_t fio_u64x4_reduce_max(uint64_t *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_u64x4_reduce_min`

uint64_t fio_u64x4_reduce_min(uint64_t *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_u64x4_reduce_mul`

uint64_t fio_u64x4_reduce_mul(uint64_t *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_u64x4_reduce_or`

uint64_t fio_u64x4_reduce_or(uint64_t *v)

Performs or in order along the vector, returning the result.

Symbol type: function

#`fio_u64x4_reduce_sub`

uint64_t fio_u64x4_reduce_sub(uint64_t *v)

Performs sub in order along the vector, returning the result.

Symbol type: function

#`fio_u64x4_reduce_xor`

uint64_t fio_u64x4_reduce_xor(uint64_t *v)

Performs xor in order along the vector, returning the result.

Symbol type: function

#`fio_u64x4_reshuffle`

void fio_u64x4_reshuffle(uint64_t *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_u64x4_sub`

void fio_u64x4_sub(uint64_t *dest, uint64_t *a, uint64_t *b)

Performs operation a - b, storing the result in dest.

Symbol type: function

#`fio_u64x4_xor`

void fio_u64x4_xor(uint64_t *dest, uint64_t *a, uint64_t *b)

Performs operation a ^ b, storing the result in dest.

Symbol type: function

#`fio_u64x8_add`

void fio_u64x8_add(uint64_t *dest, uint64_t *a, uint64_t *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_u64x8_and`

void fio_u64x8_and(uint64_t *dest, uint64_t *a, uint64_t *b)

Performs operation a & b, storing the result in dest.

Symbol type: function

#`fio_u64x8_mul`

void fio_u64x8_mul(uint64_t *dest, uint64_t *a, uint64_t *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_u64x8_or`

void fio_u64x8_or(uint64_t *dest, uint64_t *a, uint64_t *b)

Performs operation a | b, storing the result in dest.

Symbol type: function

#`fio_u64x8_reduce_add`

uint64_t fio_u64x8_reduce_add(uint64_t *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_u64x8_reduce_and`

uint64_t fio_u64x8_reduce_and(uint64_t *v)

Performs and in order along the vector, returning the result.

Symbol type: function

#`fio_u64x8_reduce_max`

uint64_t fio_u64x8_reduce_max(uint64_t *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_u64x8_reduce_min`

uint64_t fio_u64x8_reduce_min(uint64_t *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_u64x8_reduce_mul`

uint64_t fio_u64x8_reduce_mul(uint64_t *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_u64x8_reduce_or`

uint64_t fio_u64x8_reduce_or(uint64_t *v)

Performs or in order along the vector, returning the result.

Symbol type: function

#`fio_u64x8_reduce_sub`

uint64_t fio_u64x8_reduce_sub(uint64_t *v)

Performs sub in order along the vector, returning the result.

Symbol type: function

#`fio_u64x8_reduce_xor`

uint64_t fio_u64x8_reduce_xor(uint64_t *v)

Performs xor in order along the vector, returning the result.

Symbol type: function

#`fio_u64x8_reshuffle`

void fio_u64x8_reshuffle(uint64_t *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_u64x8_sub`

void fio_u64x8_sub(uint64_t *dest, uint64_t *a, uint64_t *b)

Performs operation a - b, storing the result in dest.

Symbol type: function

#`fio_u64x8_xor`

void fio_u64x8_xor(uint64_t *dest, uint64_t *a, uint64_t *b)

Performs operation a ^ b, storing the result in dest.

Symbol type: function

#`fio_u64x16_add`

void fio_u64x16_add(uint64_t *dest, uint64_t *a, uint64_t *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_u64x16_and`

void fio_u64x16_and(uint64_t *dest, uint64_t *a, uint64_t *b)

Performs operation a & b, storing the result in dest.

Symbol type: function

#`fio_u64x16_mul`

void fio_u64x16_mul(uint64_t *dest, uint64_t *a, uint64_t *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_u64x16_or`

void fio_u64x16_or(uint64_t *dest, uint64_t *a, uint64_t *b)

Performs operation a | b, storing the result in dest.

Symbol type: function

#`fio_u64x16_reduce_add`

uint64_t fio_u64x16_reduce_add(uint64_t *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_u64x16_reduce_and`

uint64_t fio_u64x16_reduce_and(uint64_t *v)

Performs and in order along the vector, returning the result.

Symbol type: function

#`fio_u64x16_reduce_max`

uint64_t fio_u64x16_reduce_max(uint64_t *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_u64x16_reduce_min`

uint64_t fio_u64x16_reduce_min(uint64_t *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_u64x16_reduce_mul`

uint64_t fio_u64x16_reduce_mul(uint64_t *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_u64x16_reduce_or`

uint64_t fio_u64x16_reduce_or(uint64_t *v)

Performs or in order along the vector, returning the result.

Symbol type: function

#`fio_u64x16_reduce_sub`

uint64_t fio_u64x16_reduce_sub(uint64_t *v)

Performs sub in order along the vector, returning the result.

Symbol type: function

#`fio_u64x16_reduce_xor`

uint64_t fio_u64x16_reduce_xor(uint64_t *v)

Performs xor in order along the vector, returning the result.

Symbol type: function

#`fio_u64x16_reshuffle`

void fio_u64x16_reshuffle(uint64_t *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_u64x16_sub`

void fio_u64x16_sub(uint64_t *dest, uint64_t *a, uint64_t *b)

Performs operation a - b, storing the result in dest.

Symbol type: function

#`fio_u64x16_xor`

void fio_u64x16_xor(uint64_t *dest, uint64_t *a, uint64_t *b)

Performs operation a ^ b, storing the result in dest.

Symbol type: function

#`fio_u64x32_add`

void fio_u64x32_add(uint64_t *dest, uint64_t *a, uint64_t *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_u64x32_and`

void fio_u64x32_and(uint64_t *dest, uint64_t *a, uint64_t *b)

Performs operation a & b, storing the result in dest.

Symbol type: function

#`fio_u64x32_mul`

void fio_u64x32_mul(uint64_t *dest, uint64_t *a, uint64_t *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_u64x32_or`

void fio_u64x32_or(uint64_t *dest, uint64_t *a, uint64_t *b)

Performs operation a | b, storing the result in dest.

Symbol type: function

#`fio_u64x32_reduce_add`

uint64_t fio_u64x32_reduce_add(uint64_t *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_u64x32_reduce_and`

uint64_t fio_u64x32_reduce_and(uint64_t *v)

Performs and in order along the vector, returning the result.

Symbol type: function

#`fio_u64x32_reduce_max`

uint64_t fio_u64x32_reduce_max(uint64_t *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_u64x32_reduce_min`

uint64_t fio_u64x32_reduce_min(uint64_t *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_u64x32_reduce_mul`

uint64_t fio_u64x32_reduce_mul(uint64_t *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_u64x32_reduce_or`

uint64_t fio_u64x32_reduce_or(uint64_t *v)

Performs or in order along the vector, returning the result.

Symbol type: function

#`fio_u64x32_reduce_sub`

uint64_t fio_u64x32_reduce_sub(uint64_t *v)

Performs sub in order along the vector, returning the result.

Symbol type: function

#`fio_u64x32_reduce_xor`

uint64_t fio_u64x32_reduce_xor(uint64_t *v)

Performs xor in order along the vector, returning the result.

Symbol type: function

#`fio_u64x32_reshuffle`

void fio_u64x32_reshuffle(uint64_t *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_u64x32_sub`

void fio_u64x32_sub(uint64_t *dest, uint64_t *a, uint64_t *b)

Performs operation a - b, storing the result in dest.

Symbol type: function

#`fio_u64x32_xor`

void fio_u64x32_xor(uint64_t *dest, uint64_t *a, uint64_t *b)

Performs operation a ^ b, storing the result in dest.

Symbol type: function

#`fio_floatx2_add`

void fio_floatx2_add(float *dest, float *a, float *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_floatx2_mul`

void fio_floatx2_mul(float *dest, float *a, float *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_floatx2_reduce_add`

float fio_floatx2_reduce_add(float *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_floatx2_reduce_max`

float fio_floatx2_reduce_max(float *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_floatx2_reduce_min`

float fio_floatx2_reduce_min(float *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_floatx2_reduce_mul`

float fio_floatx2_reduce_mul(float *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_floatx2_reshuffle`

void fio_floatx2_reshuffle(float *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_floatx4_add`

void fio_floatx4_add(float *dest, float *a, float *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_floatx4_mul`

void fio_floatx4_mul(float *dest, float *a, float *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_floatx4_reduce_add`

float fio_floatx4_reduce_add(float *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_floatx4_reduce_max`

float fio_floatx4_reduce_max(float *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_floatx4_reduce_min`

float fio_floatx4_reduce_min(float *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_floatx4_reduce_mul`

float fio_floatx4_reduce_mul(float *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_floatx4_reshuffle`

void fio_floatx4_reshuffle(float *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_floatx8_add`

void fio_floatx8_add(float *dest, float *a, float *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_floatx8_mul`

void fio_floatx8_mul(float *dest, float *a, float *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_floatx8_reduce_add`

float fio_floatx8_reduce_add(float *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_floatx8_reduce_max`

float fio_floatx8_reduce_max(float *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_floatx8_reduce_min`

float fio_floatx8_reduce_min(float *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_floatx8_reduce_mul`

float fio_floatx8_reduce_mul(float *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_floatx8_reshuffle`

void fio_floatx8_reshuffle(float *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_floatx16_add`

void fio_floatx16_add(float *dest, float *a, float *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_floatx16_mul`

void fio_floatx16_mul(float *dest, float *a, float *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_floatx16_reduce_add`

float fio_floatx16_reduce_add(float *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_floatx16_reduce_max`

float fio_floatx16_reduce_max(float *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_floatx16_reduce_min`

float fio_floatx16_reduce_min(float *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_floatx16_reduce_mul`

float fio_floatx16_reduce_mul(float *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_floatx16_reshuffle`

void fio_floatx16_reshuffle(float *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_floatx32_add`

void fio_floatx32_add(float *dest, float *a, float *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_floatx32_mul`

void fio_floatx32_mul(float *dest, float *a, float *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_floatx32_reduce_add`

float fio_floatx32_reduce_add(float *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_floatx32_reduce_max`

float fio_floatx32_reduce_max(float *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_floatx32_reduce_min`

float fio_floatx32_reduce_min(float *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_floatx32_reduce_mul`

float fio_floatx32_reduce_mul(float *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_floatx32_reshuffle`

void fio_floatx32_reshuffle(float *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_floatx64_add`

void fio_floatx64_add(float *dest, float *a, float *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_floatx64_mul`

void fio_floatx64_mul(float *dest, float *a, float *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_floatx64_reduce_add`

float fio_floatx64_reduce_add(float *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_floatx64_reduce_max`

float fio_floatx64_reduce_max(float *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_floatx64_reduce_min`

float fio_floatx64_reduce_min(float *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_floatx64_reduce_mul`

float fio_floatx64_reduce_mul(float *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_floatx64_reshuffle`

void fio_floatx64_reshuffle(float *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_dblx2_add`

void fio_dblx2_add(double *dest, double *a, double *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_dblx2_mul`

void fio_dblx2_mul(double *dest, double *a, double *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_dblx2_reduce_add`

double fio_dblx2_reduce_add(double *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_dblx2_reduce_max`

double fio_dblx2_reduce_max(double *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_dblx2_reduce_min`

double fio_dblx2_reduce_min(double *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_dblx2_reduce_mul`

double fio_dblx2_reduce_mul(double *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_dblx2_reshuffle`

void fio_dblx2_reshuffle(double *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_dblx4_add`

void fio_dblx4_add(double *dest, double *a, double *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_dblx4_mul`

void fio_dblx4_mul(double *dest, double *a, double *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_dblx4_reduce_add`

double fio_dblx4_reduce_add(double *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_dblx4_reduce_max`

double fio_dblx4_reduce_max(double *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_dblx4_reduce_min`

double fio_dblx4_reduce_min(double *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_dblx4_reduce_mul`

double fio_dblx4_reduce_mul(double *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_dblx4_reshuffle`

void fio_dblx4_reshuffle(double *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_dblx8_add`

void fio_dblx8_add(double *dest, double *a, double *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_dblx8_mul`

void fio_dblx8_mul(double *dest, double *a, double *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_dblx8_reduce_add`

double fio_dblx8_reduce_add(double *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_dblx8_reduce_max`

double fio_dblx8_reduce_max(double *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_dblx8_reduce_min`

double fio_dblx8_reduce_min(double *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_dblx8_reduce_mul`

double fio_dblx8_reduce_mul(double *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_dblx8_reshuffle`

void fio_dblx8_reshuffle(double *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_dblx16_add`

void fio_dblx16_add(double *dest, double *a, double *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_dblx16_mul`

void fio_dblx16_mul(double *dest, double *a, double *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_dblx16_reduce_add`

double fio_dblx16_reduce_add(double *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_dblx16_reduce_max`

double fio_dblx16_reduce_max(double *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_dblx16_reduce_min`

double fio_dblx16_reduce_min(double *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_dblx16_reduce_mul`

double fio_dblx16_reduce_mul(double *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_dblx16_reshuffle`

void fio_dblx16_reshuffle(double *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_dblx32_add`

void fio_dblx32_add(double *dest, double *a, double *b)

Performs operation a + b, storing the result in dest.

Symbol type: function

#`fio_dblx32_mul`

void fio_dblx32_mul(double *dest, double *a, double *b)

Performs operation a * b, storing the result in dest.

Symbol type: function

#`fio_dblx32_reduce_add`

double fio_dblx32_reduce_add(double *v)

Performs add in order along the vector, returning the result.

Symbol type: function

#`fio_dblx32_reduce_max`

double fio_dblx32_reduce_max(double *v)

Returns the maximum value in a vector.

Symbol type: function

#`fio_dblx32_reduce_min`

double fio_dblx32_reduce_min(double *v)

Returns the minimum value in a vector.

Symbol type: function

#`fio_dblx32_reduce_mul`

double fio_dblx32_reduce_mul(double *v)

Performs mul in order along the vector, returning the result.

Symbol type: function

#`fio_dblx32_reshuffle`

void fio_dblx32_reshuffle(double *v, uint8_t *indx)

Reorders (shuffles) the vectors using the indexes in indx.

Symbol type: function

#`fio_u8x4_reshuffle`

#define fio_u8x4_reshuffle(v, ...)     fio_u8x4_reshuffle(v,     (uint8_t[4]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u8x8_reshuffle`

#define fio_u8x8_reshuffle(v, ...)     fio_u8x8_reshuffle(v,     (uint8_t[8]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u8x16_reshuffle`

#define fio_u8x16_reshuffle(v, ...)    fio_u8x16_reshuffle(v,    (uint8_t[16]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u8x32_reshuffle`

#define fio_u8x32_reshuffle(v, ...)    fio_u8x32_reshuffle(v,    (uint8_t[32]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u8x64_reshuffle`

#define fio_u8x64_reshuffle(v, ...)    fio_u8x64_reshuffle(v,    (uint8_t[64]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u8x128_reshuffle`

#define fio_u8x128_reshuffle(v, ...)   fio_u8x128_reshuffle(v,   (uint8_t[128]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u8x256_reshuffle`

#define fio_u8x256_reshuffle(v, ...)   fio_u8x256_reshuffle(v,   (uint8_t[256]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u16x2_reshuffle`

#define fio_u16x2_reshuffle(v, ...)    fio_u16x2_reshuffle(v,    (uint8_t[2]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u16x4_reshuffle`

#define fio_u16x4_reshuffle(v, ...)    fio_u16x4_reshuffle(v,    (uint8_t[4]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u16x8_reshuffle`

#define fio_u16x8_reshuffle(v, ...)    fio_u16x8_reshuffle(v,    (uint8_t[8]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u16x16_reshuffle`

#define fio_u16x16_reshuffle(v, ...)   fio_u16x16_reshuffle(v,   (uint8_t[16]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u16x32_reshuffle`

#define fio_u16x32_reshuffle(v, ...)   fio_u16x32_reshuffle(v,   (uint8_t[32]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u16x64_reshuffle`

#define fio_u16x64_reshuffle(v, ...)   fio_u16x64_reshuffle(v,   (uint8_t[64]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u16x128_reshuffle`

#define fio_u16x128_reshuffle(v,...)   fio_u16x128_reshuffle(v,  (uint8_t[128]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u32x2_reshuffle`

#define fio_u32x2_reshuffle(v, ...)    fio_u32x2_reshuffle(v,    (uint8_t[2]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u32x4_reshuffle`

#define fio_u32x4_reshuffle(v, ...)    fio_u32x4_reshuffle(v,    (uint8_t[4]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u32x8_reshuffle`

#define fio_u32x8_reshuffle(v, ...)    fio_u32x8_reshuffle(v,    (uint8_t[8]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u32x16_reshuffle`

#define fio_u32x16_reshuffle(v, ...)   fio_u32x16_reshuffle(v,   (uint8_t[16]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u32x32_reshuffle`

#define fio_u32x32_reshuffle(v, ...)   fio_u32x32_reshuffle(v,   (uint8_t[32]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u32x64_reshuffle`

#define fio_u32x64_reshuffle(v, ...)   fio_u32x64_reshuffle(v,   (uint8_t[64]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u64x2_reshuffle`

#define fio_u64x2_reshuffle(v, ...)    fio_u64x2_reshuffle(v,    (uint8_t[2]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u64x4_reshuffle`

#define fio_u64x4_reshuffle(v, ...)    fio_u64x4_reshuffle(v,    (uint8_t[4]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u64x8_reshuffle`

#define fio_u64x8_reshuffle(v, ...)    fio_u64x8_reshuffle(v,    (uint8_t[8]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u64x16_reshuffle`

#define fio_u64x16_reshuffle(v, ...)   fio_u64x16_reshuffle(v,   (uint8_t[16]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u64x32_reshuffle`

#define fio_u64x32_reshuffle(v, ...)   fio_u64x32_reshuffle(v,   (uint8_t[32]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_floatx2_reshuffle`

#define fio_floatx2_reshuffle(v, ...)  fio_floatx2_reshuffle(v,  (uint8_t[2]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_floatx4_reshuffle`

#define fio_floatx4_reshuffle(v, ...)  fio_floatx4_reshuffle(v,  (uint8_t[4]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_floatx8_reshuffle`

#define fio_floatx8_reshuffle(v, ...)  fio_floatx8_reshuffle(v,  (uint8_t[8]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_floatx16_reshuffle`

#define fio_floatx16_reshuffle(v, ...) fio_floatx16_reshuffle(v, (uint8_t[16]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_floatx32_reshuffle`

#define fio_floatx32_reshuffle(v, ...) fio_floatx32_reshuffle(v, (uint8_t[32]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_floatx64_reshuffle`

#define fio_floatx64_reshuffle(v, ...) fio_floatx64_reshuffle(v, (uint8_t[64]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_dblx2_reshuffle`

#define fio_dblx2_reshuffle(v, ...)    fio_dblx2_reshuffle(v,    (uint8_t[2]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_dblx4_reshuffle`

#define fio_dblx4_reshuffle(v, ...)    fio_dblx4_reshuffle(v,    (uint8_t[4]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_dblx8_reshuffle`

#define fio_dblx8_reshuffle(v, ...)    fio_dblx8_reshuffle(v,    (uint8_t[8]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_dblx16_reshuffle`

#define fio_dblx16_reshuffle(v, ...)   fio_dblx16_reshuffle(v,   (uint8_t[16]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_dblx32_reshuffle`

#define fio_dblx32_reshuffle(v, ...)   fio_dblx32_reshuffle(v,   (uint8_t[32]){__VA_ARGS__})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_ct_true`

inline FIO_CONST uintmax_t fio_ct_true(uintmax_t cond)

Returns 1 if the expression is true (input isn't zero).

Symbol type: function

#`fio_ct_false`

inline FIO_CONST uintmax_t fio_ct_false(uintmax_t cond)

Returns 1 if the expression is false (input is zero).

Symbol type: function

#`fio_ct_if_bool`

inline FIO_CONST uintmax_t fio_ct_if_bool(uintmax_t cond, uintmax_t a, uintmax_t b)

Returns a if cond is boolean and true, returns b otherwise.

Symbol type: function

#`fio_ct_if`

inline FIO_CONST uintmax_t fio_ct_if(uintmax_t cond, uintmax_t a, uintmax_t b)

Returns a if cond isn't zero (uses fio_ct_true), returns b otherwise.

Symbol type: function

#`fio_ct_max`

inline FIO_CONST intmax_t fio_ct_max(intmax_t a_, intmax_t b_)

Returns a if a >= b.

Symbol type: function

#`fio_ct_min`

inline FIO_CONST intmax_t fio_ct_min(intmax_t a_, intmax_t b_)

Returns a if a >= b.

Symbol type: function

#`fio_ct_abs`

inline FIO_CONST uintmax_t fio_ct_abs(intmax_t i_)

Returns absolute value.

Symbol type: function

#`fio_ct_tolower`

inline char fio_ct_tolower(char c)

Symbol type: function

#`fio_ct_mux32`

inline FIO_CONST uint32_t fio_ct_mux32(uint32_t x, uint32_t y, uint32_t z)

Bitwise "choose": for each bit, if x is set, return y's bit, else z's bit. Formula: (x & y) ^ (~x & z) -or equivalently- z ^ (x & (y ^ z)) Used in: SHA-1 (Ch), SHA-256 (Ch), SHA-512 (Ch), AES, etc.

Symbol type: function

#`fio_ct_mux64`

inline FIO_CONST uint64_t fio_ct_mux64(uint64_t x, uint64_t y, uint64_t z)

64-bit version of bitwise choose/mux.

Symbol type: function

#`fio_ct_maj32`

inline FIO_CONST uint32_t fio_ct_maj32(uint32_t x, uint32_t y, uint32_t z)

Bitwise "majority": for each bit position, return 1 if 2+ inputs have 1. Formula: (x & y) ^ (x & z) ^ (y & z) -or- (x & y) | (z & (x | y)) Used in: SHA-1 (Maj), SHA-256 (Maj), SHA-512 (Maj), etc.

Symbol type: function

#`fio_ct_maj64`

inline FIO_CONST uint64_t fio_ct_maj64(uint64_t x, uint64_t y, uint64_t z)

64-bit version of bitwise majority.

Symbol type: function

#`fio_ct_xor3_32`

inline FIO_CONST uint32_t fio_ct_xor3_32(uint32_t x, uint32_t y, uint32_t z)

Bitwise "parity": XOR of all three inputs (1 if odd number of 1s). Formula: x ^ y ^ z Used in: SHA-1 (Parity function for rounds 20-39 and 60-79)

Symbol type: function

#`fio_ct_xor3_64`

inline FIO_CONST uint64_t fio_ct_xor3_64(uint64_t x, uint64_t y, uint64_t z)

64-bit version of 3-way XOR.

Symbol type: function

#`fio_ct_is_eq`

FIO_SFUNC _Bool fio_ct_is_eq(const void *a_, const void *b_, size_t bytes)

A timing attack resistant memory comparison function.

Symbol type: function

#`fio_secure_zero`

inline void fio_secure_zero(void *a_, size_t bytes)

A timing attack resistant memory zeroing function.

Symbol type: function

#`fio_lrot8`

#define fio_lrot8(i, bits) __builtin_rotateleft8(i, bits)

8Bit left rotation, inlined.

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_lrot16`

#define fio_lrot16(i, bits) __builtin_rotateleft16(i, bits)

16Bit left rotation, inlined.

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_lrot32`

#define fio_lrot32(i, bits) __builtin_rotateleft32(i, bits)

32Bit left rotation, inlined.

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_lrot64`

#define fio_lrot64(i, bits) __builtin_rotateleft64(i, bits)

64Bit left rotation, inlined.

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_rrot8`

#define fio_rrot8(i, bits) __builtin_rotateright8(i, bits)

8Bit right rotation, inlined.

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_rrot8`

inline FIO_CONST uint8_t fio_rrot8(uint8_t i, uint8_t bits)

8Bit right rotation, inlined.

Symbol type: function

#`fio_rrot16`

#define fio_rrot16(i, bits) __builtin_rotateright16(i, bits)

16Bit right rotation, inlined.

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_rrot32`

#define fio_rrot32(i, bits) __builtin_rotateright32(i, bits)

32Bit right rotation, inlined.

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_rrot64`

#define fio_rrot64(i, bits) __builtin_rotateright64(i, bits)

64Bit right rotation, inlined.

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_lrot128`

#define fio_lrot128(i, bits) __builtin_rotateleft128(i, bits)

128Bit left rotation, inlined.

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_rrot128`

#define fio_rrot128(i, bits) __builtin_rotateright128(i, bits)

128Bit right rotation, inlined.

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_lrot128`

inline FIO_CONST __uint128_t fio_lrot128(__uint128_t i, uint8_t bits)

128Bit left rotation, inlined.

Symbol type: function

#`fio_rrot128`

inline FIO_CONST __uint128_t fio_rrot128(__uint128_t i, uint8_t bits)

128Bit right rotation, inlined.

Symbol type: function

#`fio_frot16`

#define fio_frot16 fio_rrot16

Rotates the bits Forwards (endian specific).

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_frot32`

#define fio_frot32 fio_rrot32

Rotates the bits Forwards (endian specific).

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_frot64`

#define fio_frot64 fio_rrot64

Rotates the bits Forwards (endian specific).

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_xor_rrot3_32`

inline FIO_CONST uint32_t fio_xor_rrot3_32(uint32_t x, uint8_t a, uint8_t b, uint8_t c)

XOR of three right rotations: ROTR(x,a) ^ ROTR(x,b) ^ ROTR(x,c) Common in SHA-256/SHA-512 Sigma functions.

Symbol type: function

#`fio_xor_rrot3_64`

inline FIO_CONST uint64_t fio_xor_rrot3_64(uint64_t x, uint8_t a, uint8_t b, uint8_t c)

64-bit version of triple rotation XOR.

Symbol type: function

#`fio_xor_rrot2_shr_32`

inline FIO_CONST uint32_t fio_xor_rrot2_shr_32(uint32_t x, uint8_t a, uint8_t b, uint8_t c)

XOR of two right rotations and a right shift: ROTR(x,a) ^ ROTR(x,b) ^ SHR(x,c) Common in SHA-256/SHA-512 sigma (lowercase) functions for message schedule.

Symbol type: function

#`fio_xor_rrot2_shr_64`

inline FIO_CONST uint64_t fio_xor_rrot2_shr_64(uint64_t x, uint8_t a, uint8_t b, uint8_t c)

64-bit version of double rotation + shift XOR.

Symbol type: function

#`fio_xmask`

inline void fio_xmask(void *buf_, size_t len, uint64_t mask)

Masks data using a persistent 64 bit mask.

When the buffer's memory is aligned, the function may perform significantly better.

Symbol type: function

#`fio_xmask_cpy`

inline void fio_xmask_cpy(char *restrict dest, const char *src, size_t len, uint64_t mask)

Masks data using a persistent 64 bit mask.

When the buffer's memory is aligned, the function may perform significantly better.

Symbol type: function

#`fio_popcount`

#define fio_popcount(n) __builtin_popcountll(n)

performs a popcount operation to count the set bits.

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_hemming_dist`

#define fio_hemming_dist(n1, n2) fio_popcount(((uint64_t)(n1) ^ (uint64_t)(n2)))

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_lsb_index_unsafe`

FIO_SFUNC FIO_CONST size_t fio_lsb_index_unsafe(uint64_t i)

Returns the index of the least significant (lowest) bit.

Symbol type: function

#`fio_msb_index_unsafe`

FIO_SFUNC FIO_CONST size_t fio_msb_index_unsafe(uint64_t i)

Returns the index of the most significant (highest) bit.

Symbol type: function

#`fio_has_zero_byte32`

inline FIO_CONST uint32_t fio_has_zero_byte32(uint32_t row)

Detects a byte where no bits are set (0) within a 4 byte vector.

The zero byte will be be set to 0x80, all other bytes will be 0x0.

Symbol type: function

#`fio_has_byte32`

inline FIO_CONST uint32_t fio_has_byte32(uint32_t row, uint8_t byte)

Detects if byte exists within a 4 byte vector.

The requested byte will be be set to 0x80, all other bytes will be 0x0.

Symbol type: function

#`fio_has_full_byte32`

inline FIO_CONST uint32_t fio_has_full_byte32(uint32_t row)

Detects a byte where all the bits are set (255) within a 4 byte vector.

The full byte will be be set to 0x80, all other bytes will be 0x0.

Symbol type: function

#`fio_has_zero_byte64`

inline FIO_CONST uint64_t fio_has_zero_byte64(uint64_t row)

Detects a byte where no bits are set (0) within an 8 byte vector.

The zero byte will be be set to 0x80, all other bytes will be 0x0.

Symbol type: function

#`fio_has_zero_byte_alt64`

inline FIO_CONST uint64_t fio_has_zero_byte_alt64(uint64_t row)

Detects a byte where no bits are set (0) within an 8 byte vector.

This variation should NOT be used to build a bitmap, but May be used to detect the first occurrence.

Symbol type: function

#`fio_has_byte64`

inline FIO_CONST uint64_t fio_has_byte64(uint64_t row, uint8_t byte)

Detects if byte exists within an 8 byte vector.

The requested byte will be be set to 0x80, all other bytes will be 0x0.

Symbol type: function

#`fio_has_full_byte64`

inline FIO_CONST uint64_t fio_has_full_byte64(uint64_t row)

Detects a byte where all the bits are set (255) within an 8 byte vector.

The full byte will be be set to 0x80, all other bytes will be 0x0.

Symbol type: function

#`fio_has_byte2bitmap`

inline FIO_CONST uint64_t fio_has_byte2bitmap(uint64_t result)

Converts a fio_has_byteX result to a bitmap.

Symbol type: function

#`fio_bits_lsb`

inline FIO_CONST uint64_t fio_bits_lsb(uint64_t i)

Isolates the least significant (lowest) bit.

Symbol type: function

#`fio_bits_msb`

inline FIO_CONST uint64_t fio_bits_msb(uint64_t i)

Isolates the most significant (highest) bit.

Symbol type: function

#`fio_bits_msb_index`

inline FIO_CONST size_t fio_bits_msb_index(uint64_t i)

Returns the index of the most significant (highest) bit.

Symbol type: function

#`fio_bits_lsb_index`

inline FIO_CONST size_t fio_bits_lsb_index(uint64_t i)

Returns the index of the least significant (lowest) bit.

Symbol type: function

#`fio_bit_get`

inline uint8_t fio_bit_get(void *map, size_t bit)

Gets the state of a bit in a bitmap.

Symbol type: function

#`fio_bit_set`

inline void fio_bit_set(void *map, size_t bit)

Sets the a bit in a bitmap (sets to 1).

Symbol type: function

#`fio_bit_unset`

inline void fio_bit_unset(void *map, size_t bit)

Unsets the a bit in a bitmap (sets to 0).

Symbol type: function

#`fio_bit_flip`

inline void fio_bit_flip(void *map, size_t bit)

Flips the a bit in a bitmap (sets to 0 if 1, sets to 1 if 0).

Symbol type: function

#`fio_math_mod_mul64`

inline uint64_t fio_math_mod_mul64(uint64_t a, uint64_t b, uint64_t mod)

Perform modular multiplication for numbers with up to 64 bits.

Symbol type: function

#`fio_math_mod_expo64`

inline uint64_t fio_math_mod_expo64(uint64_t base, uint64_t exp, uint64_t mod)

Perform modular exponentiation

Symbol type: function

#`fio_math_is_uprime`

FIO_SFUNC bool fio_math_is_uprime(uint64_t n)

Tests if an unsigned 64 bit number is (probably) a prime.

For numbers up to 1023 this is deterministic.

Symbol type: function

#`fio_math_is_iprime`

inline bool fio_math_is_iprime(int64_t n)

Tests if the absolute value of a signed 64 bit number is (probably) a prime.

For numbers up to 1023 this is deterministic.

Symbol type: function

#`fio_math_addc64`

FIO_MIFN uint64_t fio_math_addc64(uint64_t a, uint64_t b, uint64_t carry_in, uint64_t *carry_out)

Add with carry.

Symbol type: function

#`fio_math_add`

FIO_MIFN bool fio_math_add(uint64_t *dest, const uint64_t *a, const uint64_t *b, const size_t len)

Multi-precision ADD for len 64 bit words a + b. Returns the carry.

Symbol type: function

#`fio_math_addc128`

FIO_MIFN __uint128_t fio_math_addc128(const __uint128_t a, const __uint128_t b, bool carry_in, bool *carry_out)

Multi-precision ADD for bits long a + b. Returns the carry.

Symbol type: function

#`fio_math_add2`

FIO_MIFN bool fio_math_add2(__uint128_t *dest, const __uint128_t *a, const __uint128_t *b, const size_t len)

Symbol type: function

#`fio_math_subc64`

FIO_MIFN uint64_t fio_math_subc64(uint64_t a, uint64_t b, uint64_t borrow_in, uint64_t *borrow_out)

Subtract with borrow.

Symbol type: function

#`fio_math_sub`

FIO_MIFN uint64_t fio_math_sub(uint64_t *dest, const uint64_t *a, const uint64_t *b, const size_t len)

Multi-precision SUB for len 64 bit words a + b. Returns the borrow.

Symbol type: function

#`fio_math_mulc64`

FIO_MIFN uint64_t fio_math_mulc64(uint64_t a, uint64_t b, uint64_t *carry_out)

Multiply with carry out.

Symbol type: function

#`fio_math_mul`

inline void fio_math_mul(uint64_t *restrict dest, const uint64_t *a, const uint64_t *b, const size_t len)

Multi-precision MUL for len 64 bit words.

dest must be len * 2 long to hold the result.

a and b must be of equal len.

Symbol type: function

#`fio_u128_init8`

#define fio_u128_init8(...)  ((fio_u128){.u8 = {__VA_ARGS__}})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u128_init16`

#define fio_u128_init16(...) ((fio_u128){.u16 = {__VA_ARGS__}})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u128_init32`

#define fio_u128_init32(...) ((fio_u128){.u32 = {__VA_ARGS__}})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u128_init64`

#define fio_u128_init64(...) ((fio_u128){.u64 = {__VA_ARGS__}})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u256_init8`

#define fio_u256_init8(...)  ((fio_u256){.u8 = {__VA_ARGS__}})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u256_init16`

#define fio_u256_init16(...) ((fio_u256){.u16 = {__VA_ARGS__}})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u256_init32`

#define fio_u256_init32(...) ((fio_u256){.u32 = {__VA_ARGS__}})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u256_init64`

#define fio_u256_init64(...) ((fio_u256){.u64 = {__VA_ARGS__}})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u512_init8`

#define fio_u512_init8(...)  ((fio_u512){.u8 = {__VA_ARGS__}})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u512_init16`

#define fio_u512_init16(...) ((fio_u512){.u16 = {__VA_ARGS__}})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u512_init32`

#define fio_u512_init32(...) ((fio_u512){.u32 = {__VA_ARGS__}})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u512_init64`

#define fio_u512_init64(...) ((fio_u512){.u64 = {__VA_ARGS__}})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u1024_init8`

#define fio_u1024_init8(...)  ((fio_u1024){.u8 = {__VA_ARGS__}})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u1024_init16`

#define fio_u1024_init16(...) ((fio_u1024){.u16 = {__VA_ARGS__}})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u1024_init32`

#define fio_u1024_init32(...) ((fio_u1024){.u32 = {__VA_ARGS__}})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u1024_init64`

#define fio_u1024_init64(...) ((fio_u1024){.u64 = {__VA_ARGS__}})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u2048_init8`

#define fio_u2048_init8(...)  ((fio_u2048){.u8 = {__VA_ARGS__}})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u2048_init16`

#define fio_u2048_init16(...) ((fio_u2048){.u16 = {__VA_ARGS__}})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u2048_init32`

#define fio_u2048_init32(...) ((fio_u2048){.u32 = {__VA_ARGS__}})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u2048_init64`

#define fio_u2048_init64(...) ((fio_u2048){.u64 = {__VA_ARGS__}})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u4096_init8`

#define fio_u4096_init8(...)  ((fio_u4096){.u8 = {__VA_ARGS__}})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u4096_init16`

#define fio_u4096_init16(...) ((fio_u4096){.u16 = {__VA_ARGS__}})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u4096_init32`

#define fio_u4096_init32(...) ((fio_u4096){.u32 = {__VA_ARGS__}})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u4096_init64`

#define fio_u4096_init64(...) ((fio_u4096){.u64 = {__VA_ARGS__}})

Note: this may be a macro only / macro wrapper for a function.

Symbol type: macro

#`fio_u128_bswap16`

fio_u128 fio_u128_bswap16(fio_u128 a)

Symbol type: function

#`fio_u128_bswap32`

fio_u128 fio_u128_bswap32(fio_u128 a)

Symbol type: function

#`fio_u128_bswap64`

fio_u128 fio_u128_bswap64(fio_u128 a)

Symbol type: function

#`fio_u128_load`

fio_u128 fio_u128_load(const void *buf)

Loads from memory using local-endian.

Symbol type: function

#`fio_u128_load_be16`

fio_u128 fio_u128_load_be16(const void *buf)

Symbol type: function

#`fio_u128_load_be32`

fio_u128 fio_u128_load_be32(const void *buf)

Symbol type: function

#`fio_u128_load_be64`

fio_u128 fio_u128_load_be64(const void *buf)

Symbol type: function

#`fio_u128_load_le16`

fio_u128 fio_u128_load_le16(const void *buf)

Symbol type: function

#`fio_u128_load_le32`

fio_u128 fio_u128_load_le32(const void *buf)

Symbol type: function

#`fio_u128_load_le64`

fio_u128 fio_u128_load_le64(const void *buf)

Symbol type: function

#`fio_u128_store`

void fio_u128_store(void *buf, const fio_u128 a)

Stores to memory using local-endian.

Symbol type: function

#`fio_u256_bswap16`

fio_u256 fio_u256_bswap16(fio_u256 a)

Symbol type: function

#`fio_u256_bswap32`

fio_u256 fio_u256_bswap32(fio_u256 a)

Symbol type: function

#`fio_u256_bswap64`

fio_u256 fio_u256_bswap64(fio_u256 a)

Symbol type: function

#`fio_u256_load`

fio_u256 fio_u256_load(const void *buf)

Loads from memory using local-endian.

Symbol type: function

#`fio_u256_load_be16`

fio_u256 fio_u256_load_be16(const void *buf)

Symbol type: function

#`fio_u256_load_be32`

fio_u256 fio_u256_load_be32(const void *buf)

Symbol type: function

#`fio_u256_load_be64`

fio_u256 fio_u256_load_be64(const void *buf)

Symbol type: function

#`fio_u256_load_le16`

fio_u256 fio_u256_load_le16(const void *buf)

Symbol type: function

#`fio_u256_load_le32`

fio_u256 fio_u256_load_le32(const void *buf)

Symbol type: function

#`fio_u256_load_le64`

fio_u256 fio_u256_load_le64(const void *buf)

Symbol type: function

#`fio_u256_store`

void fio_u256_store(void *buf, const fio_u256 a)

Stores to memory using local-endian.

Symbol type: function

#`fio_u512_bswap16`

fio_u512 fio_u512_bswap16(fio_u512 a)

Symbol type: function

#`fio_u512_bswap32`

fio_u512 fio_u512_bswap32(fio_u512 a)

Symbol type: function

#`fio_u512_bswap64`

fio_u512 fio_u512_bswap64(fio_u512 a)

Symbol type: function

#`fio_u512_load`

fio_u512 fio_u512_load(const void *buf)

Loads from memory using local-endian.

Symbol type: function

#`fio_u512_load_be16`

fio_u512 fio_u512_load_be16(const void *buf)

Symbol type: function

#`fio_u512_load_be32`

fio_u512 fio_u512_load_be32(const void *buf)

Symbol type: function

#`fio_u512_load_be64`

fio_u512 fio_u512_load_be64(const void *buf)

Symbol type: function

#`fio_u512_load_le16`

fio_u512 fio_u512_load_le16(const void *buf)

Symbol type: function

#`fio_u512_load_le32`

fio_u512 fio_u512_load_le32(const void *buf)

Symbol type: function

#`fio_u512_load_le64`

fio_u512 fio_u512_load_le64(const void *buf)

Symbol type: function

#`fio_u512_store`

void fio_u512_store(void *buf, const fio_u512 a)

Stores to memory using local-endian.

Symbol type: function

#`fio_u1024_bswap16`

fio_u1024 fio_u1024_bswap16(fio_u1024 a)

Symbol type: function

#`fio_u1024_bswap32`

fio_u1024 fio_u1024_bswap32(fio_u1024 a)

Symbol type: function

#`fio_u1024_bswap64`

fio_u1024 fio_u1024_bswap64(fio_u1024 a)

Symbol type: function

#`fio_u1024_load`

fio_u1024 fio_u1024_load(const void *buf)

Loads from memory using local-endian.

Symbol type: function

#`fio_u1024_load_be16`

fio_u1024 fio_u1024_load_be16(const void *buf)

Symbol type: function

#`fio_u1024_load_be32`

fio_u1024 fio_u1024_load_be32(const void *buf)

Symbol type: function

#`fio_u1024_load_be64`

fio_u1024 fio_u1024_load_be64(const void *buf)

Symbol type: function

#`fio_u1024_load_le16`

fio_u1024 fio_u1024_load_le16(const void *buf)

Symbol type: function

#`fio_u1024_load_le32`

fio_u1024 fio_u1024_load_le32(const void *buf)

Symbol type: function

#`fio_u1024_load_le64`

fio_u1024 fio_u1024_load_le64(const void *buf)

Symbol type: function

#`fio_u1024_store`

void fio_u1024_store(void *buf, const fio_u1024 a)

Stores to memory using local-endian.

Symbol type: function

#`fio_u2048_bswap16`

fio_u2048 fio_u2048_bswap16(fio_u2048 a)

Symbol type: function

#`fio_u2048_bswap32`

fio_u2048 fio_u2048_bswap32(fio_u2048 a)

Symbol type: function

#`fio_u2048_bswap64`

fio_u2048 fio_u2048_bswap64(fio_u2048 a)

Symbol type: function

#`fio_u2048_load`

fio_u2048 fio_u2048_load(const void *buf)

Loads from memory using local-endian.

Symbol type: function

#`fio_u2048_load_be16`

fio_u2048 fio_u2048_load_be16(const void *buf)

Symbol type: function

#`fio_u2048_load_be32`

fio_u2048 fio_u2048_load_be32(const void *buf)

Symbol type: function

#`fio_u2048_load_be64`

fio_u2048 fio_u2048_load_be64(const void *buf)

Symbol type: function

#`fio_u2048_load_le16`

fio_u2048 fio_u2048_load_le16(const void *buf)

Symbol type: function

#`fio_u2048_load_le32`

fio_u2048 fio_u2048_load_le32(const void *buf)

Symbol type: function

#`fio_u2048_load_le64`

fio_u2048 fio_u2048_load_le64(const void *buf)

Symbol type: function

#`fio_u2048_store`

void fio_u2048_store(void *buf, const fio_u2048 a)

Stores to memory using local-endian.

Symbol type: function

#`fio_u4096_bswap16`

fio_u4096 fio_u4096_bswap16(fio_u4096 a)

Symbol type: function

#`fio_u4096_bswap32`

fio_u4096 fio_u4096_bswap32(fio_u4096 a)

Symbol type: function

#`fio_u4096_bswap64`

fio_u4096 fio_u4096_bswap64(fio_u4096 a)

Symbol type: function

#`fio_u4096_load`

fio_u4096 fio_u4096_load(const void *buf)

Loads from memory using local-endian.

Symbol type: function

#`fio_u4096_load_be16`

fio_u4096 fio_u4096_load_be16(const void *buf)

Symbol type: function

#`fio_u4096_load_be32`

fio_u4096 fio_u4096_load_be32(const void *buf)

Symbol type: function

#`fio_u4096_load_be64`

fio_u4096 fio_u4096_load_be64(const void *buf)

Symbol type: function

#`fio_u4096_load_le16`

fio_u4096 fio_u4096_load_le16(const void *buf)

Symbol type: function

#`fio_u4096_load_le32`

fio_u4096 fio_u4096_load_le32(const void *buf)

Symbol type: function

#`fio_u4096_load_le64`

fio_u4096 fio_u4096_load_le64(const void *buf)

Symbol type: function

#`fio_u4096_store`

void fio_u4096_store(void *buf, const fio_u4096 a)

Stores to memory using local-endian.

Symbol type: function

#`fio_u128_3xor`

void fio_u128_3xor(fio_u128 *target, const fio_u128 *a, const fio_u128 *b, const fio_u128 *c)

Symbol type: function

#`fio_u128_3xor32`

void fio_u128_3xor32(fio_u128 *target, const fio_u128 *a, const fio_u128 *b, const fio_u128 *c)

Symbol type: function

#`fio_u128_3xor64`

void fio_u128_3xor64(fio_u128 *target, const fio_u128 *a, const fio_u128 *b, const fio_u128 *c)

Symbol type: function

#`fio_u128_add16`

void fio_u128_add16(fio_u128 *target, const fio_u128 *a, const fio_u128 *b)

Symbol type: function

#`fio_u128_add32`

void fio_u128_add32(fio_u128 *target, const fio_u128 *a, const fio_u128 *b)

Symbol type: function

#`fio_u128_add64`

void fio_u128_add64(fio_u128 *target, const fio_u128 *a, const fio_u128 *b)

Symbol type: function

#`fio_u128_add8`

void fio_u128_add8(fio_u128 *target, const fio_u128 *a, const fio_u128 *b)

Symbol type: function

#`fio_u128_and`

void fio_u128_and(fio_u128 *target, const fio_u128 *a, const fio_u128 *b)

Symbol type: function

#`fio_u128_and16`

void fio_u128_and16(fio_u128 *target, const fio_u128 *a, const fio_u128 *b)

Symbol type: function

#`fio_u128_and32`

void fio_u128_and32(fio_u128 *target, const fio_u128 *a, const fio_u128 *b)

Symbol type: function

#`fio_u128_and64`

void fio_u128_and64(fio_u128 *target, const fio_u128 *a, const fio_u128 *b)

Symbol type: function

#`fio_u128_and8`

void fio_u128_and8(fio_u128 *target, const fio_u128 *a, const fio_u128 *b)

Symbol type: function

#`fio_u128_cadd16`

void fio_u128_cadd16(fio_u128 *target, const fio_u128 *a, uint16_t b)

Symbol type: function

#`fio_u128_cadd32`

void fio_u128_cadd32(fio_u128 *target, const fio_u128 *a, uint32_t b)

Symbol type: function

#`fio_u128_cadd64`

void fio_u128_cadd64(fio_u128 *target, const fio_u128 *a, uint64_t b)

Symbol type: function

#`fio_u128_cadd8`

void fio_u128_cadd8(fio_u128 *target, const fio_u128 *a, uint8_t b)

Symbol type: function

#`fio_u128_cand16`

void fio_u128_cand16(fio_u128 *target, const fio_u128 *a, uint16_t b)

Symbol type: function

#`fio_u128_cand32`

void fio_u128_cand32(fio_u128 *target, const fio_u128 *a, uint32_t b)

Symbol type: function

#`fio_u128_cand64`

void fio_u128_cand64(fio_u128 *target, const fio_u128 *a, uint64_t b)

Symbol type: function

#`fio_u128_cand8`

void fio_u128_cand8(fio_u128 *target, const fio_u128 *a, uint8_t b)

Symbol type: function

#`fio_u128_clrot16`

void fio_u128_clrot16(fio_u128 *target, const fio_u128 *a, const uint8_t bts)

Symbol type: function

#`fio_u128_clrot32`

void fio_u128_clrot32(fio_u128 *target, const fio_u128 *a, const uint8_t bts)

Symbol type: function

#`fio_u128_clrot64`

void fio_u128_clrot64(fio_u128 *target, const fio_u128 *a, const uint8_t bts)

Symbol type: function

#`fio_u128_clrot8`

void fio_u128_clrot8(fio_u128 *target, const fio_u128 *a, const uint8_t bts)

Symbol type: function

#`fio_u128_cmul16`

void fio_u128_cmul16(fio_u128 *target, const fio_u128 *a, uint16_t b)

Symbol type: function

#`fio_u128_cmul32`

void fio_u128_cmul32(fio_u128 *target, const fio_u128 *a, uint32_t b)

Symbol type: function

#`fio_u128_cmul64`

void fio_u128_cmul64(fio_u128 *target, const fio_u128 *a, uint64_t b)

Symbol type: function

#`fio_u128_cmul8`

void fio_u128_cmul8(fio_u128 *target, const fio_u128 *a, uint8_t b)

Symbol type: function

#`fio_u128_cor16`

void fio_u128_cor16(fio_u128 *target, const fio_u128 *a, uint16_t b)

Symbol type: function

#`fio_u128_cor32`

void fio_u128_cor32(fio_u128 *target, const fio_u128 *a, uint32_t b)

Symbol type: function

#`fio_u128_cor64`

void fio_u128_cor64(fio_u128 *target, const fio_u128 *a, uint64_t b)

Symbol type: function

#`fio_u128_cor8`

void fio_u128_cor8(fio_u128 *target, const fio_u128 *a, uint8_t b)

Symbol type: function

#`fio_u128_crrot16`

void fio_u128_crrot16(fio_u128 *target, const fio_u128 *a, const uint8_t bts)

Symbol type: function

#`fio_u128_crrot32`

void fio_u128_crrot32(fio_u128 *target, const fio_u128 *a, const uint8_t bts)

Symbol type: function

#`fio_u128_crrot64`

void fio_u128_crrot64(fio_u128 *target, const fio_u128 *a, const uint8_t bts)

Symbol type: function

#`fio_u128_crrot8`

void fio_u128_crrot8(fio_u128 *target, const fio_u128 *a, const uint8_t bts)

Symbol type: function

#`fio_u128_csub16`

void fio_u128_csub16(fio_u128 *target, const fio_u128 *a, uint16_t b)

Symbol type: function

#`fio_u128_csub32`

void fio_u128_csub32(fio_u128 *target, const fio_u128 *a, uint32_t b)

Symbol type: function

#`fio_u128_csub64`

void fio_u128_csub64(fio_u128 *target, const fio_u128 *a, uint64_t b)

Symbol type: function

#`fio_u128_csub8`

void fio_u128_csub8(fio_u128 *target, const fio_u128 *a, uint8_t b)

Symbol type: function

#`fio_u128_ct_swap_if`

void fio_u128_ct_swap_if(bool cond, fio_u128 *restrict a, fio_u128 *restrict b)

Symbol type: function

#`fio_u128_cxor16`

void fio_u128_cxor16(fio_u128 *target, const fio_u128 *a, uint16_t b)

Symbol type: function

#`fio_u128_cxor32`

void fio_u128_cxor32(fio_u128 *target, const fio_u128 *a, uint32_t b)

Symbol type: function

#`fio_u128_cxor64`

void fio_u128_cxor64(fio_u128 *target, const fio_u128 *a, uint64_t b)

Symbol type: function

#`fio_u128_cxor8`

void fio_u128_cxor8(fio_u128 *target, const fio_u128 *a, uint8_t b)

Symbol type: function

#`fio_u128_inv`

void fio_u128_inv(fio_u128 *target, const fio_u128 *a)

Symbol type: function

#`fio_u128_is_eq`

bool fio_u128_is_eq(const fio_u128 *a, const fio_u128 *b)

Symbol type: function

#`fio_u128_lrot16`

void fio_u128_lrot16(fio_u128 *target, const fio_u128 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u128_lrot32`

void fio_u128_lrot32(fio_u128 *target, const fio_u128 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u128_lrot64`

void fio_u128_lrot64(fio_u128 *target, const fio_u128 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u128_lrot8`

void fio_u128_lrot8(fio_u128 *target, const fio_u128 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u128_maj`

void fio_u128_maj(fio_u128 *target, const fio_u128 *a, const fio_u128 *b, const fio_u128 *c)

Symbol type: function

#`fio_u128_maj32`

void fio_u128_maj32(fio_u128 *target, const fio_u128 *a, const fio_u128 *b, const fio_u128 *c)

Symbol type: function

#`fio_u128_maj64`

void fio_u128_maj64(fio_u128 *target, const fio_u128 *a, const fio_u128 *b, const fio_u128 *c)

Symbol type: function

#`fio_u128_mul16`

void fio_u128_mul16(fio_u128 *target, const fio_u128 *a, const fio_u128 *b)

Symbol type: function

#`fio_u128_mul32`

void fio_u128_mul32(fio_u128 *target, const fio_u128 *a, const fio_u128 *b)

Symbol type: function

#`fio_u128_mul64`

void fio_u128_mul64(fio_u128 *target, const fio_u128 *a, const fio_u128 *b)

Symbol type: function

#`fio_u128_mul8`

void fio_u128_mul8(fio_u128 *target, const fio_u128 *a, const fio_u128 *b)

Symbol type: function

#`fio_u128_mux`

void fio_u128_mux(fio_u128 *target, const fio_u128 *a, const fio_u128 *b, const fio_u128 *c)

Symbol type: function

#`fio_u128_mux32`

void fio_u128_mux32(fio_u128 *target, const fio_u128 *a, const fio_u128 *b, const fio_u128 *c)

Symbol type: function

#`fio_u128_mux64`

void fio_u128_mux64(fio_u128 *target, const fio_u128 *a, const fio_u128 *b, const fio_u128 *c)

Symbol type: function

#`fio_u128_or`

void fio_u128_or(fio_u128 *target, const fio_u128 *a, const fio_u128 *b)

Symbol type: function

#`fio_u128_or16`

void fio_u128_or16(fio_u128 *target, const fio_u128 *a, const fio_u128 *b)

Symbol type: function

#`fio_u128_or32`

void fio_u128_or32(fio_u128 *target, const fio_u128 *a, const fio_u128 *b)

Symbol type: function

#`fio_u128_or64`

void fio_u128_or64(fio_u128 *target, const fio_u128 *a, const fio_u128 *b)

Symbol type: function

#`fio_u128_or8`

void fio_u128_or8(fio_u128 *target, const fio_u128 *a, const fio_u128 *b)

Symbol type: function

#`fio_u128_reduce_add16`

uint16_t fio_u128_reduce_add16(const fio_u128 *a)

Symbol type: function

#`fio_u128_reduce_add32`

uint32_t fio_u128_reduce_add32(const fio_u128 *a)

Symbol type: function

#`fio_u128_reduce_add64`

uint64_t fio_u128_reduce_add64(const fio_u128 *a)

Symbol type: function

#`fio_u128_reduce_add8`

uint8_t fio_u128_reduce_add8(const fio_u128 *a)

Symbol type: function

#`fio_u128_reduce_and16`

uint16_t fio_u128_reduce_and16(const fio_u128 *a)

Symbol type: function

#`fio_u128_reduce_and32`

uint32_t fio_u128_reduce_and32(const fio_u128 *a)

Symbol type: function

#`fio_u128_reduce_and64`

uint64_t fio_u128_reduce_and64(const fio_u128 *a)

Symbol type: function

#`fio_u128_reduce_and8`

uint8_t fio_u128_reduce_and8(const fio_u128 *a)

Symbol type: function

#`fio_u128_reduce_mul16`

uint16_t fio_u128_reduce_mul16(const fio_u128 *a)

Symbol type: function

#`fio_u128_reduce_mul32`

uint32_t fio_u128_reduce_mul32(const fio_u128 *a)

Symbol type: function

#`fio_u128_reduce_mul64`

uint64_t fio_u128_reduce_mul64(const fio_u128 *a)

Symbol type: function

#`fio_u128_reduce_mul8`

uint8_t fio_u128_reduce_mul8(const fio_u128 *a)

Symbol type: function

#`fio_u128_reduce_or16`

uint16_t fio_u128_reduce_or16(const fio_u128 *a)

Symbol type: function

#`fio_u128_reduce_or32`

uint32_t fio_u128_reduce_or32(const fio_u128 *a)

Symbol type: function

#`fio_u128_reduce_or64`

uint64_t fio_u128_reduce_or64(const fio_u128 *a)

Symbol type: function

#`fio_u128_reduce_or8`

uint8_t fio_u128_reduce_or8(const fio_u128 *a)

Symbol type: function

#`fio_u128_reduce_sub16`

uint16_t fio_u128_reduce_sub16(const fio_u128 *a)

Symbol type: function

#`fio_u128_reduce_sub32`

uint32_t fio_u128_reduce_sub32(const fio_u128 *a)

Symbol type: function

#`fio_u128_reduce_sub64`

uint64_t fio_u128_reduce_sub64(const fio_u128 *a)

Symbol type: function

#`fio_u128_reduce_sub8`

uint8_t fio_u128_reduce_sub8(const fio_u128 *a)

Symbol type: function

#`fio_u128_reduce_xor16`

uint16_t fio_u128_reduce_xor16(const fio_u128 *a)

Symbol type: function

#`fio_u128_reduce_xor32`

uint32_t fio_u128_reduce_xor32(const fio_u128 *a)

Symbol type: function

#`fio_u128_reduce_xor64`

uint64_t fio_u128_reduce_xor64(const fio_u128 *a)

Symbol type: function

#`fio_u128_reduce_xor8`

uint8_t fio_u128_reduce_xor8(const fio_u128 *a)

Symbol type: function

#`fio_u128_rrot16`

void fio_u128_rrot16(fio_u128 *target, const fio_u128 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u128_rrot32`

void fio_u128_rrot32(fio_u128 *target, const fio_u128 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u128_rrot64`

void fio_u128_rrot64(fio_u128 *target, const fio_u128 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u128_rrot8`

void fio_u128_rrot8(fio_u128 *target, const fio_u128 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u128_sub16`

void fio_u128_sub16(fio_u128 *target, const fio_u128 *a, const fio_u128 *b)

Symbol type: function

#`fio_u128_sub32`

void fio_u128_sub32(fio_u128 *target, const fio_u128 *a, const fio_u128 *b)

Symbol type: function

#`fio_u128_sub64`

void fio_u128_sub64(fio_u128 *target, const fio_u128 *a, const fio_u128 *b)

Symbol type: function

#`fio_u128_sub8`

void fio_u128_sub8(fio_u128 *target, const fio_u128 *a, const fio_u128 *b)

Symbol type: function

#`fio_u128_xor`

void fio_u128_xor(fio_u128 *target, const fio_u128 *a, const fio_u128 *b)

Symbol type: function

#`fio_u128_xor16`

void fio_u128_xor16(fio_u128 *target, const fio_u128 *a, const fio_u128 *b)

Symbol type: function

#`fio_u128_xor32`

void fio_u128_xor32(fio_u128 *target, const fio_u128 *a, const fio_u128 *b)

Symbol type: function

#`fio_u128_xor64`

void fio_u128_xor64(fio_u128 *target, const fio_u128 *a, const fio_u128 *b)

Symbol type: function

#`fio_u128_xor8`

void fio_u128_xor8(fio_u128 *target, const fio_u128 *a, const fio_u128 *b)

Symbol type: function

#`fio_u256_3xor`

void fio_u256_3xor(fio_u256 *target, const fio_u256 *a, const fio_u256 *b, const fio_u256 *c)

Symbol type: function

#`fio_u256_3xor32`

void fio_u256_3xor32(fio_u256 *target, const fio_u256 *a, const fio_u256 *b, const fio_u256 *c)

Symbol type: function

#`fio_u256_3xor64`

void fio_u256_3xor64(fio_u256 *target, const fio_u256 *a, const fio_u256 *b, const fio_u256 *c)

Symbol type: function

#`fio_u256_add16`

void fio_u256_add16(fio_u256 *target, const fio_u256 *a, const fio_u256 *b)

Symbol type: function

#`fio_u256_add32`

void fio_u256_add32(fio_u256 *target, const fio_u256 *a, const fio_u256 *b)

Symbol type: function

#`fio_u256_add64`

void fio_u256_add64(fio_u256 *target, const fio_u256 *a, const fio_u256 *b)

Symbol type: function

#`fio_u256_add8`

void fio_u256_add8(fio_u256 *target, const fio_u256 *a, const fio_u256 *b)

Symbol type: function

#`fio_u256_and`

void fio_u256_and(fio_u256 *target, const fio_u256 *a, const fio_u256 *b)

Symbol type: function

#`fio_u256_and16`

void fio_u256_and16(fio_u256 *target, const fio_u256 *a, const fio_u256 *b)

Symbol type: function

#`fio_u256_and32`

void fio_u256_and32(fio_u256 *target, const fio_u256 *a, const fio_u256 *b)

Symbol type: function

#`fio_u256_and64`

void fio_u256_and64(fio_u256 *target, const fio_u256 *a, const fio_u256 *b)

Symbol type: function

#`fio_u256_and8`

void fio_u256_and8(fio_u256 *target, const fio_u256 *a, const fio_u256 *b)

Symbol type: function

#`fio_u256_cadd16`

void fio_u256_cadd16(fio_u256 *target, const fio_u256 *a, uint16_t b)

Symbol type: function

#`fio_u256_cadd32`

void fio_u256_cadd32(fio_u256 *target, const fio_u256 *a, uint32_t b)

Symbol type: function

#`fio_u256_cadd64`

void fio_u256_cadd64(fio_u256 *target, const fio_u256 *a, uint64_t b)

Symbol type: function

#`fio_u256_cadd8`

void fio_u256_cadd8(fio_u256 *target, const fio_u256 *a, uint8_t b)

Symbol type: function

#`fio_u256_cand16`

void fio_u256_cand16(fio_u256 *target, const fio_u256 *a, uint16_t b)

Symbol type: function

#`fio_u256_cand32`

void fio_u256_cand32(fio_u256 *target, const fio_u256 *a, uint32_t b)

Symbol type: function

#`fio_u256_cand64`

void fio_u256_cand64(fio_u256 *target, const fio_u256 *a, uint64_t b)

Symbol type: function

#`fio_u256_cand8`

void fio_u256_cand8(fio_u256 *target, const fio_u256 *a, uint8_t b)

Symbol type: function

#`fio_u256_clrot16`

void fio_u256_clrot16(fio_u256 *target, const fio_u256 *a, const uint8_t bts)

Symbol type: function

#`fio_u256_clrot32`

void fio_u256_clrot32(fio_u256 *target, const fio_u256 *a, const uint8_t bts)

Symbol type: function

#`fio_u256_clrot64`

void fio_u256_clrot64(fio_u256 *target, const fio_u256 *a, const uint8_t bts)

Symbol type: function

#`fio_u256_clrot8`

void fio_u256_clrot8(fio_u256 *target, const fio_u256 *a, const uint8_t bts)

Symbol type: function

#`fio_u256_cmul16`

void fio_u256_cmul16(fio_u256 *target, const fio_u256 *a, uint16_t b)

Symbol type: function

#`fio_u256_cmul32`

void fio_u256_cmul32(fio_u256 *target, const fio_u256 *a, uint32_t b)

Symbol type: function

#`fio_u256_cmul64`

void fio_u256_cmul64(fio_u256 *target, const fio_u256 *a, uint64_t b)

Symbol type: function

#`fio_u256_cmul8`

void fio_u256_cmul8(fio_u256 *target, const fio_u256 *a, uint8_t b)

Symbol type: function

#`fio_u256_cor16`

void fio_u256_cor16(fio_u256 *target, const fio_u256 *a, uint16_t b)

Symbol type: function

#`fio_u256_cor32`

void fio_u256_cor32(fio_u256 *target, const fio_u256 *a, uint32_t b)

Symbol type: function

#`fio_u256_cor64`

void fio_u256_cor64(fio_u256 *target, const fio_u256 *a, uint64_t b)

Symbol type: function

#`fio_u256_cor8`

void fio_u256_cor8(fio_u256 *target, const fio_u256 *a, uint8_t b)

Symbol type: function

#`fio_u256_crrot16`

void fio_u256_crrot16(fio_u256 *target, const fio_u256 *a, const uint8_t bts)

Symbol type: function

#`fio_u256_crrot32`

void fio_u256_crrot32(fio_u256 *target, const fio_u256 *a, const uint8_t bts)

Symbol type: function

#`fio_u256_crrot64`

void fio_u256_crrot64(fio_u256 *target, const fio_u256 *a, const uint8_t bts)

Symbol type: function

#`fio_u256_crrot8`

void fio_u256_crrot8(fio_u256 *target, const fio_u256 *a, const uint8_t bts)

Symbol type: function

#`fio_u256_csub16`

void fio_u256_csub16(fio_u256 *target, const fio_u256 *a, uint16_t b)

Symbol type: function

#`fio_u256_csub32`

void fio_u256_csub32(fio_u256 *target, const fio_u256 *a, uint32_t b)

Symbol type: function

#`fio_u256_csub64`

void fio_u256_csub64(fio_u256 *target, const fio_u256 *a, uint64_t b)

Symbol type: function

#`fio_u256_csub8`

void fio_u256_csub8(fio_u256 *target, const fio_u256 *a, uint8_t b)

Symbol type: function

#`fio_u256_ct_swap_if`

void fio_u256_ct_swap_if(bool cond, fio_u256 *restrict a, fio_u256 *restrict b)

Symbol type: function

#`fio_u256_cxor16`

void fio_u256_cxor16(fio_u256 *target, const fio_u256 *a, uint16_t b)

Symbol type: function

#`fio_u256_cxor32`

void fio_u256_cxor32(fio_u256 *target, const fio_u256 *a, uint32_t b)

Symbol type: function

#`fio_u256_cxor64`

void fio_u256_cxor64(fio_u256 *target, const fio_u256 *a, uint64_t b)

Symbol type: function

#`fio_u256_cxor8`

void fio_u256_cxor8(fio_u256 *target, const fio_u256 *a, uint8_t b)

Symbol type: function

#`fio_u256_inv`

void fio_u256_inv(fio_u256 *target, const fio_u256 *a)

Symbol type: function

#`fio_u256_is_eq`

bool fio_u256_is_eq(const fio_u256 *a, const fio_u256 *b)

Symbol type: function

#`fio_u256_lrot16`

void fio_u256_lrot16(fio_u256 *target, const fio_u256 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u256_lrot32`

void fio_u256_lrot32(fio_u256 *target, const fio_u256 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u256_lrot64`

void fio_u256_lrot64(fio_u256 *target, const fio_u256 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u256_lrot8`

void fio_u256_lrot8(fio_u256 *target, const fio_u256 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u256_maj`

void fio_u256_maj(fio_u256 *target, const fio_u256 *a, const fio_u256 *b, const fio_u256 *c)

Symbol type: function

#`fio_u256_maj32`

void fio_u256_maj32(fio_u256 *target, const fio_u256 *a, const fio_u256 *b, const fio_u256 *c)

Symbol type: function

#`fio_u256_maj64`

void fio_u256_maj64(fio_u256 *target, const fio_u256 *a, const fio_u256 *b, const fio_u256 *c)

Symbol type: function

#`fio_u256_mul16`

void fio_u256_mul16(fio_u256 *target, const fio_u256 *a, const fio_u256 *b)

Symbol type: function

#`fio_u256_mul32`

void fio_u256_mul32(fio_u256 *target, const fio_u256 *a, const fio_u256 *b)

Symbol type: function

#`fio_u256_mul64`

void fio_u256_mul64(fio_u256 *target, const fio_u256 *a, const fio_u256 *b)

Symbol type: function

#`fio_u256_mul8`

void fio_u256_mul8(fio_u256 *target, const fio_u256 *a, const fio_u256 *b)

Symbol type: function

#`fio_u256_mux`

void fio_u256_mux(fio_u256 *target, const fio_u256 *a, const fio_u256 *b, const fio_u256 *c)

Symbol type: function

#`fio_u256_mux32`

void fio_u256_mux32(fio_u256 *target, const fio_u256 *a, const fio_u256 *b, const fio_u256 *c)

Symbol type: function

#`fio_u256_mux64`

void fio_u256_mux64(fio_u256 *target, const fio_u256 *a, const fio_u256 *b, const fio_u256 *c)

Symbol type: function

#`fio_u256_or`

void fio_u256_or(fio_u256 *target, const fio_u256 *a, const fio_u256 *b)

Symbol type: function

#`fio_u256_or16`

void fio_u256_or16(fio_u256 *target, const fio_u256 *a, const fio_u256 *b)

Symbol type: function

#`fio_u256_or32`

void fio_u256_or32(fio_u256 *target, const fio_u256 *a, const fio_u256 *b)

Symbol type: function

#`fio_u256_or64`

void fio_u256_or64(fio_u256 *target, const fio_u256 *a, const fio_u256 *b)

Symbol type: function

#`fio_u256_or8`

void fio_u256_or8(fio_u256 *target, const fio_u256 *a, const fio_u256 *b)

Symbol type: function

#`fio_u256_reduce_add16`

uint16_t fio_u256_reduce_add16(const fio_u256 *a)

Symbol type: function

#`fio_u256_reduce_add32`

uint32_t fio_u256_reduce_add32(const fio_u256 *a)

Symbol type: function

#`fio_u256_reduce_add64`

uint64_t fio_u256_reduce_add64(const fio_u256 *a)

Symbol type: function

#`fio_u256_reduce_add8`

uint8_t fio_u256_reduce_add8(const fio_u256 *a)

Symbol type: function

#`fio_u256_reduce_and16`

uint16_t fio_u256_reduce_and16(const fio_u256 *a)

Symbol type: function

#`fio_u256_reduce_and32`

uint32_t fio_u256_reduce_and32(const fio_u256 *a)

Symbol type: function

#`fio_u256_reduce_and64`

uint64_t fio_u256_reduce_and64(const fio_u256 *a)

Symbol type: function

#`fio_u256_reduce_and8`

uint8_t fio_u256_reduce_and8(const fio_u256 *a)

Symbol type: function

#`fio_u256_reduce_mul16`

uint16_t fio_u256_reduce_mul16(const fio_u256 *a)

Symbol type: function

#`fio_u256_reduce_mul32`

uint32_t fio_u256_reduce_mul32(const fio_u256 *a)

Symbol type: function

#`fio_u256_reduce_mul64`

uint64_t fio_u256_reduce_mul64(const fio_u256 *a)

Symbol type: function

#`fio_u256_reduce_mul8`

uint8_t fio_u256_reduce_mul8(const fio_u256 *a)

Symbol type: function

#`fio_u256_reduce_or16`

uint16_t fio_u256_reduce_or16(const fio_u256 *a)

Symbol type: function

#`fio_u256_reduce_or32`

uint32_t fio_u256_reduce_or32(const fio_u256 *a)

Symbol type: function

#`fio_u256_reduce_or64`

uint64_t fio_u256_reduce_or64(const fio_u256 *a)

Symbol type: function

#`fio_u256_reduce_or8`

uint8_t fio_u256_reduce_or8(const fio_u256 *a)

Symbol type: function

#`fio_u256_reduce_sub16`

uint16_t fio_u256_reduce_sub16(const fio_u256 *a)

Symbol type: function

#`fio_u256_reduce_sub32`

uint32_t fio_u256_reduce_sub32(const fio_u256 *a)

Symbol type: function

#`fio_u256_reduce_sub64`

uint64_t fio_u256_reduce_sub64(const fio_u256 *a)

Symbol type: function

#`fio_u256_reduce_sub8`

uint8_t fio_u256_reduce_sub8(const fio_u256 *a)

Symbol type: function

#`fio_u256_reduce_xor16`

uint16_t fio_u256_reduce_xor16(const fio_u256 *a)

Symbol type: function

#`fio_u256_reduce_xor32`

uint32_t fio_u256_reduce_xor32(const fio_u256 *a)

Symbol type: function

#`fio_u256_reduce_xor64`

uint64_t fio_u256_reduce_xor64(const fio_u256 *a)

Symbol type: function

#`fio_u256_reduce_xor8`

uint8_t fio_u256_reduce_xor8(const fio_u256 *a)

Symbol type: function

#`fio_u256_rrot16`

void fio_u256_rrot16(fio_u256 *target, const fio_u256 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u256_rrot32`

void fio_u256_rrot32(fio_u256 *target, const fio_u256 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u256_rrot64`

void fio_u256_rrot64(fio_u256 *target, const fio_u256 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u256_rrot8`

void fio_u256_rrot8(fio_u256 *target, const fio_u256 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u256_sub16`

void fio_u256_sub16(fio_u256 *target, const fio_u256 *a, const fio_u256 *b)

Symbol type: function

#`fio_u256_sub32`

void fio_u256_sub32(fio_u256 *target, const fio_u256 *a, const fio_u256 *b)

Symbol type: function

#`fio_u256_sub64`

void fio_u256_sub64(fio_u256 *target, const fio_u256 *a, const fio_u256 *b)

Symbol type: function

#`fio_u256_sub8`

void fio_u256_sub8(fio_u256 *target, const fio_u256 *a, const fio_u256 *b)

Symbol type: function

#`fio_u256_xor`

void fio_u256_xor(fio_u256 *target, const fio_u256 *a, const fio_u256 *b)

Symbol type: function

#`fio_u256_xor16`

void fio_u256_xor16(fio_u256 *target, const fio_u256 *a, const fio_u256 *b)

Symbol type: function

#`fio_u256_xor32`

void fio_u256_xor32(fio_u256 *target, const fio_u256 *a, const fio_u256 *b)

Symbol type: function

#`fio_u256_xor64`

void fio_u256_xor64(fio_u256 *target, const fio_u256 *a, const fio_u256 *b)

Symbol type: function

#`fio_u256_xor8`

void fio_u256_xor8(fio_u256 *target, const fio_u256 *a, const fio_u256 *b)

Symbol type: function

#`fio_u512_3xor`

void fio_u512_3xor(fio_u512 *target, const fio_u512 *a, const fio_u512 *b, const fio_u512 *c)

Symbol type: function

#`fio_u512_3xor32`

void fio_u512_3xor32(fio_u512 *target, const fio_u512 *a, const fio_u512 *b, const fio_u512 *c)

Symbol type: function

#`fio_u512_3xor64`

void fio_u512_3xor64(fio_u512 *target, const fio_u512 *a, const fio_u512 *b, const fio_u512 *c)

Symbol type: function

#`fio_u512_add16`

void fio_u512_add16(fio_u512 *target, const fio_u512 *a, const fio_u512 *b)

Symbol type: function

#`fio_u512_add32`

void fio_u512_add32(fio_u512 *target, const fio_u512 *a, const fio_u512 *b)

Symbol type: function

#`fio_u512_add64`

void fio_u512_add64(fio_u512 *target, const fio_u512 *a, const fio_u512 *b)

Symbol type: function

#`fio_u512_add8`

void fio_u512_add8(fio_u512 *target, const fio_u512 *a, const fio_u512 *b)

Symbol type: function

#`fio_u512_and`

void fio_u512_and(fio_u512 *target, const fio_u512 *a, const fio_u512 *b)

Symbol type: function

#`fio_u512_and16`

void fio_u512_and16(fio_u512 *target, const fio_u512 *a, const fio_u512 *b)

Symbol type: function

#`fio_u512_and32`

void fio_u512_and32(fio_u512 *target, const fio_u512 *a, const fio_u512 *b)

Symbol type: function

#`fio_u512_and64`

void fio_u512_and64(fio_u512 *target, const fio_u512 *a, const fio_u512 *b)

Symbol type: function

#`fio_u512_and8`

void fio_u512_and8(fio_u512 *target, const fio_u512 *a, const fio_u512 *b)

Symbol type: function

#`fio_u512_cadd16`

void fio_u512_cadd16(fio_u512 *target, const fio_u512 *a, uint16_t b)

Symbol type: function

#`fio_u512_cadd32`

void fio_u512_cadd32(fio_u512 *target, const fio_u512 *a, uint32_t b)

Symbol type: function

#`fio_u512_cadd64`

void fio_u512_cadd64(fio_u512 *target, const fio_u512 *a, uint64_t b)

Symbol type: function

#`fio_u512_cadd8`

void fio_u512_cadd8(fio_u512 *target, const fio_u512 *a, uint8_t b)

Symbol type: function

#`fio_u512_cand16`

void fio_u512_cand16(fio_u512 *target, const fio_u512 *a, uint16_t b)

Symbol type: function

#`fio_u512_cand32`

void fio_u512_cand32(fio_u512 *target, const fio_u512 *a, uint32_t b)

Symbol type: function

#`fio_u512_cand64`

void fio_u512_cand64(fio_u512 *target, const fio_u512 *a, uint64_t b)

Symbol type: function

#`fio_u512_cand8`

void fio_u512_cand8(fio_u512 *target, const fio_u512 *a, uint8_t b)

Symbol type: function

#`fio_u512_clrot16`

void fio_u512_clrot16(fio_u512 *target, const fio_u512 *a, const uint8_t bts)

Symbol type: function

#`fio_u512_clrot32`

void fio_u512_clrot32(fio_u512 *target, const fio_u512 *a, const uint8_t bts)

Symbol type: function

#`fio_u512_clrot64`

void fio_u512_clrot64(fio_u512 *target, const fio_u512 *a, const uint8_t bts)

Symbol type: function

#`fio_u512_clrot8`

void fio_u512_clrot8(fio_u512 *target, const fio_u512 *a, const uint8_t bts)

Symbol type: function

#`fio_u512_cmul16`

void fio_u512_cmul16(fio_u512 *target, const fio_u512 *a, uint16_t b)

Symbol type: function

#`fio_u512_cmul32`

void fio_u512_cmul32(fio_u512 *target, const fio_u512 *a, uint32_t b)

Symbol type: function

#`fio_u512_cmul64`

void fio_u512_cmul64(fio_u512 *target, const fio_u512 *a, uint64_t b)

Symbol type: function

#`fio_u512_cmul8`

void fio_u512_cmul8(fio_u512 *target, const fio_u512 *a, uint8_t b)

Symbol type: function

#`fio_u512_cor16`

void fio_u512_cor16(fio_u512 *target, const fio_u512 *a, uint16_t b)

Symbol type: function

#`fio_u512_cor32`

void fio_u512_cor32(fio_u512 *target, const fio_u512 *a, uint32_t b)

Symbol type: function

#`fio_u512_cor64`

void fio_u512_cor64(fio_u512 *target, const fio_u512 *a, uint64_t b)

Symbol type: function

#`fio_u512_cor8`

void fio_u512_cor8(fio_u512 *target, const fio_u512 *a, uint8_t b)

Symbol type: function

#`fio_u512_crrot16`

void fio_u512_crrot16(fio_u512 *target, const fio_u512 *a, const uint8_t bts)

Symbol type: function

#`fio_u512_crrot32`

void fio_u512_crrot32(fio_u512 *target, const fio_u512 *a, const uint8_t bts)

Symbol type: function

#`fio_u512_crrot64`

void fio_u512_crrot64(fio_u512 *target, const fio_u512 *a, const uint8_t bts)

Symbol type: function

#`fio_u512_crrot8`

void fio_u512_crrot8(fio_u512 *target, const fio_u512 *a, const uint8_t bts)

Symbol type: function

#`fio_u512_csub16`

void fio_u512_csub16(fio_u512 *target, const fio_u512 *a, uint16_t b)

Symbol type: function

#`fio_u512_csub32`

void fio_u512_csub32(fio_u512 *target, const fio_u512 *a, uint32_t b)

Symbol type: function

#`fio_u512_csub64`

void fio_u512_csub64(fio_u512 *target, const fio_u512 *a, uint64_t b)

Symbol type: function

#`fio_u512_csub8`

void fio_u512_csub8(fio_u512 *target, const fio_u512 *a, uint8_t b)

Symbol type: function

#`fio_u512_ct_swap_if`

void fio_u512_ct_swap_if(bool cond, fio_u512 *restrict a, fio_u512 *restrict b)

Symbol type: function

#`fio_u512_cxor16`

void fio_u512_cxor16(fio_u512 *target, const fio_u512 *a, uint16_t b)

Symbol type: function

#`fio_u512_cxor32`

void fio_u512_cxor32(fio_u512 *target, const fio_u512 *a, uint32_t b)

Symbol type: function

#`fio_u512_cxor64`

void fio_u512_cxor64(fio_u512 *target, const fio_u512 *a, uint64_t b)

Symbol type: function

#`fio_u512_cxor8`

void fio_u512_cxor8(fio_u512 *target, const fio_u512 *a, uint8_t b)

Symbol type: function

#`fio_u512_inv`

void fio_u512_inv(fio_u512 *target, const fio_u512 *a)

Symbol type: function

#`fio_u512_is_eq`

bool fio_u512_is_eq(const fio_u512 *a, const fio_u512 *b)

Symbol type: function

#`fio_u512_lrot16`

void fio_u512_lrot16(fio_u512 *target, const fio_u512 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u512_lrot32`

void fio_u512_lrot32(fio_u512 *target, const fio_u512 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u512_lrot64`

void fio_u512_lrot64(fio_u512 *target, const fio_u512 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u512_lrot8`

void fio_u512_lrot8(fio_u512 *target, const fio_u512 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u512_maj`

void fio_u512_maj(fio_u512 *target, const fio_u512 *a, const fio_u512 *b, const fio_u512 *c)

Symbol type: function

#`fio_u512_maj32`

void fio_u512_maj32(fio_u512 *target, const fio_u512 *a, const fio_u512 *b, const fio_u512 *c)

Symbol type: function

#`fio_u512_maj64`

void fio_u512_maj64(fio_u512 *target, const fio_u512 *a, const fio_u512 *b, const fio_u512 *c)

Symbol type: function

#`fio_u512_mul16`

void fio_u512_mul16(fio_u512 *target, const fio_u512 *a, const fio_u512 *b)

Symbol type: function

#`fio_u512_mul32`

void fio_u512_mul32(fio_u512 *target, const fio_u512 *a, const fio_u512 *b)

Symbol type: function

#`fio_u512_mul64`

void fio_u512_mul64(fio_u512 *target, const fio_u512 *a, const fio_u512 *b)

Symbol type: function

#`fio_u512_mul8`

void fio_u512_mul8(fio_u512 *target, const fio_u512 *a, const fio_u512 *b)

Symbol type: function

#`fio_u512_mux`

void fio_u512_mux(fio_u512 *target, const fio_u512 *a, const fio_u512 *b, const fio_u512 *c)

Symbol type: function

#`fio_u512_mux32`

void fio_u512_mux32(fio_u512 *target, const fio_u512 *a, const fio_u512 *b, const fio_u512 *c)

Symbol type: function

#`fio_u512_mux64`

void fio_u512_mux64(fio_u512 *target, const fio_u512 *a, const fio_u512 *b, const fio_u512 *c)

Symbol type: function

#`fio_u512_or`

void fio_u512_or(fio_u512 *target, const fio_u512 *a, const fio_u512 *b)

Symbol type: function

#`fio_u512_or16`

void fio_u512_or16(fio_u512 *target, const fio_u512 *a, const fio_u512 *b)

Symbol type: function

#`fio_u512_or32`

void fio_u512_or32(fio_u512 *target, const fio_u512 *a, const fio_u512 *b)

Symbol type: function

#`fio_u512_or64`

void fio_u512_or64(fio_u512 *target, const fio_u512 *a, const fio_u512 *b)

Symbol type: function

#`fio_u512_or8`

void fio_u512_or8(fio_u512 *target, const fio_u512 *a, const fio_u512 *b)

Symbol type: function

#`fio_u512_reduce_add16`

uint16_t fio_u512_reduce_add16(const fio_u512 *a)

Symbol type: function

#`fio_u512_reduce_add32`

uint32_t fio_u512_reduce_add32(const fio_u512 *a)

Symbol type: function

#`fio_u512_reduce_add64`

uint64_t fio_u512_reduce_add64(const fio_u512 *a)

Symbol type: function

#`fio_u512_reduce_add8`

uint8_t fio_u512_reduce_add8(const fio_u512 *a)

Symbol type: function

#`fio_u512_reduce_and16`

uint16_t fio_u512_reduce_and16(const fio_u512 *a)

Symbol type: function

#`fio_u512_reduce_and32`

uint32_t fio_u512_reduce_and32(const fio_u512 *a)

Symbol type: function

#`fio_u512_reduce_and64`

uint64_t fio_u512_reduce_and64(const fio_u512 *a)

Symbol type: function

#`fio_u512_reduce_and8`

uint8_t fio_u512_reduce_and8(const fio_u512 *a)

Symbol type: function

#`fio_u512_reduce_mul16`

uint16_t fio_u512_reduce_mul16(const fio_u512 *a)

Symbol type: function

#`fio_u512_reduce_mul32`

uint32_t fio_u512_reduce_mul32(const fio_u512 *a)

Symbol type: function

#`fio_u512_reduce_mul64`

uint64_t fio_u512_reduce_mul64(const fio_u512 *a)

Symbol type: function

#`fio_u512_reduce_mul8`

uint8_t fio_u512_reduce_mul8(const fio_u512 *a)

Symbol type: function

#`fio_u512_reduce_or16`

uint16_t fio_u512_reduce_or16(const fio_u512 *a)

Symbol type: function

#`fio_u512_reduce_or32`

uint32_t fio_u512_reduce_or32(const fio_u512 *a)

Symbol type: function

#`fio_u512_reduce_or64`

uint64_t fio_u512_reduce_or64(const fio_u512 *a)

Symbol type: function

#`fio_u512_reduce_or8`

uint8_t fio_u512_reduce_or8(const fio_u512 *a)

Symbol type: function

#`fio_u512_reduce_sub16`

uint16_t fio_u512_reduce_sub16(const fio_u512 *a)

Symbol type: function

#`fio_u512_reduce_sub32`

uint32_t fio_u512_reduce_sub32(const fio_u512 *a)

Symbol type: function

#`fio_u512_reduce_sub64`

uint64_t fio_u512_reduce_sub64(const fio_u512 *a)

Symbol type: function

#`fio_u512_reduce_sub8`

uint8_t fio_u512_reduce_sub8(const fio_u512 *a)

Symbol type: function

#`fio_u512_reduce_xor16`

uint16_t fio_u512_reduce_xor16(const fio_u512 *a)

Symbol type: function

#`fio_u512_reduce_xor32`

uint32_t fio_u512_reduce_xor32(const fio_u512 *a)

Symbol type: function

#`fio_u512_reduce_xor64`

uint64_t fio_u512_reduce_xor64(const fio_u512 *a)

Symbol type: function

#`fio_u512_reduce_xor8`

uint8_t fio_u512_reduce_xor8(const fio_u512 *a)

Symbol type: function

#`fio_u512_rrot16`

void fio_u512_rrot16(fio_u512 *target, const fio_u512 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u512_rrot32`

void fio_u512_rrot32(fio_u512 *target, const fio_u512 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u512_rrot64`

void fio_u512_rrot64(fio_u512 *target, const fio_u512 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u512_rrot8`

void fio_u512_rrot8(fio_u512 *target, const fio_u512 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u512_sub16`

void fio_u512_sub16(fio_u512 *target, const fio_u512 *a, const fio_u512 *b)

Symbol type: function

#`fio_u512_sub32`

void fio_u512_sub32(fio_u512 *target, const fio_u512 *a, const fio_u512 *b)

Symbol type: function

#`fio_u512_sub64`

void fio_u512_sub64(fio_u512 *target, const fio_u512 *a, const fio_u512 *b)

Symbol type: function

#`fio_u512_sub8`

void fio_u512_sub8(fio_u512 *target, const fio_u512 *a, const fio_u512 *b)

Symbol type: function

#`fio_u512_xor`

void fio_u512_xor(fio_u512 *target, const fio_u512 *a, const fio_u512 *b)

Symbol type: function

#`fio_u512_xor16`

void fio_u512_xor16(fio_u512 *target, const fio_u512 *a, const fio_u512 *b)

Symbol type: function

#`fio_u512_xor32`

void fio_u512_xor32(fio_u512 *target, const fio_u512 *a, const fio_u512 *b)

Symbol type: function

#`fio_u512_xor64`

void fio_u512_xor64(fio_u512 *target, const fio_u512 *a, const fio_u512 *b)

Symbol type: function

#`fio_u512_xor8`

void fio_u512_xor8(fio_u512 *target, const fio_u512 *a, const fio_u512 *b)

Symbol type: function

#`fio_u1024_3xor`

void fio_u1024_3xor(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b, const fio_u1024 *c)

Symbol type: function

#`fio_u1024_3xor32`

void fio_u1024_3xor32(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b, const fio_u1024 *c)

Symbol type: function

#`fio_u1024_3xor64`

void fio_u1024_3xor64(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b, const fio_u1024 *c)

Symbol type: function

#`fio_u1024_add16`

void fio_u1024_add16(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b)

Symbol type: function

#`fio_u1024_add32`

void fio_u1024_add32(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b)

Symbol type: function

#`fio_u1024_add64`

void fio_u1024_add64(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b)

Symbol type: function

#`fio_u1024_add8`

void fio_u1024_add8(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b)

Symbol type: function

#`fio_u1024_and`

void fio_u1024_and(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b)

Symbol type: function

#`fio_u1024_and16`

void fio_u1024_and16(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b)

Symbol type: function

#`fio_u1024_and32`

void fio_u1024_and32(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b)

Symbol type: function

#`fio_u1024_and64`

void fio_u1024_and64(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b)

Symbol type: function

#`fio_u1024_and8`

void fio_u1024_and8(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b)

Symbol type: function

#`fio_u1024_cadd16`

void fio_u1024_cadd16(fio_u1024 *target, const fio_u1024 *a, uint16_t b)

Symbol type: function

#`fio_u1024_cadd32`

void fio_u1024_cadd32(fio_u1024 *target, const fio_u1024 *a, uint32_t b)

Symbol type: function

#`fio_u1024_cadd64`

void fio_u1024_cadd64(fio_u1024 *target, const fio_u1024 *a, uint64_t b)

Symbol type: function

#`fio_u1024_cadd8`

void fio_u1024_cadd8(fio_u1024 *target, const fio_u1024 *a, uint8_t b)

Symbol type: function

#`fio_u1024_cand16`

void fio_u1024_cand16(fio_u1024 *target, const fio_u1024 *a, uint16_t b)

Symbol type: function

#`fio_u1024_cand32`

void fio_u1024_cand32(fio_u1024 *target, const fio_u1024 *a, uint32_t b)

Symbol type: function

#`fio_u1024_cand64`

void fio_u1024_cand64(fio_u1024 *target, const fio_u1024 *a, uint64_t b)

Symbol type: function

#`fio_u1024_cand8`

void fio_u1024_cand8(fio_u1024 *target, const fio_u1024 *a, uint8_t b)

Symbol type: function

#`fio_u1024_clrot16`

void fio_u1024_clrot16(fio_u1024 *target, const fio_u1024 *a, const uint8_t bts)

Symbol type: function

#`fio_u1024_clrot32`

void fio_u1024_clrot32(fio_u1024 *target, const fio_u1024 *a, const uint8_t bts)

Symbol type: function

#`fio_u1024_clrot64`

void fio_u1024_clrot64(fio_u1024 *target, const fio_u1024 *a, const uint8_t bts)

Symbol type: function

#`fio_u1024_clrot8`

void fio_u1024_clrot8(fio_u1024 *target, const fio_u1024 *a, const uint8_t bts)

Symbol type: function

#`fio_u1024_cmul16`

void fio_u1024_cmul16(fio_u1024 *target, const fio_u1024 *a, uint16_t b)

Symbol type: function

#`fio_u1024_cmul32`

void fio_u1024_cmul32(fio_u1024 *target, const fio_u1024 *a, uint32_t b)

Symbol type: function

#`fio_u1024_cmul64`

void fio_u1024_cmul64(fio_u1024 *target, const fio_u1024 *a, uint64_t b)

Symbol type: function

#`fio_u1024_cmul8`

void fio_u1024_cmul8(fio_u1024 *target, const fio_u1024 *a, uint8_t b)

Symbol type: function

#`fio_u1024_cor16`

void fio_u1024_cor16(fio_u1024 *target, const fio_u1024 *a, uint16_t b)

Symbol type: function

#`fio_u1024_cor32`

void fio_u1024_cor32(fio_u1024 *target, const fio_u1024 *a, uint32_t b)

Symbol type: function

#`fio_u1024_cor64`

void fio_u1024_cor64(fio_u1024 *target, const fio_u1024 *a, uint64_t b)

Symbol type: function

#`fio_u1024_cor8`

void fio_u1024_cor8(fio_u1024 *target, const fio_u1024 *a, uint8_t b)

Symbol type: function

#`fio_u1024_crrot16`

void fio_u1024_crrot16(fio_u1024 *target, const fio_u1024 *a, const uint8_t bts)

Symbol type: function

#`fio_u1024_crrot32`

void fio_u1024_crrot32(fio_u1024 *target, const fio_u1024 *a, const uint8_t bts)

Symbol type: function

#`fio_u1024_crrot64`

void fio_u1024_crrot64(fio_u1024 *target, const fio_u1024 *a, const uint8_t bts)

Symbol type: function

#`fio_u1024_crrot8`

void fio_u1024_crrot8(fio_u1024 *target, const fio_u1024 *a, const uint8_t bts)

Symbol type: function

#`fio_u1024_csub16`

void fio_u1024_csub16(fio_u1024 *target, const fio_u1024 *a, uint16_t b)

Symbol type: function

#`fio_u1024_csub32`

void fio_u1024_csub32(fio_u1024 *target, const fio_u1024 *a, uint32_t b)

Symbol type: function

#`fio_u1024_csub64`

void fio_u1024_csub64(fio_u1024 *target, const fio_u1024 *a, uint64_t b)

Symbol type: function

#`fio_u1024_csub8`

void fio_u1024_csub8(fio_u1024 *target, const fio_u1024 *a, uint8_t b)

Symbol type: function

#`fio_u1024_ct_swap_if`

void fio_u1024_ct_swap_if(bool cond, fio_u1024 *restrict a, fio_u1024 *restrict b)

Symbol type: function

#`fio_u1024_cxor16`

void fio_u1024_cxor16(fio_u1024 *target, const fio_u1024 *a, uint16_t b)

Symbol type: function

#`fio_u1024_cxor32`

void fio_u1024_cxor32(fio_u1024 *target, const fio_u1024 *a, uint32_t b)

Symbol type: function

#`fio_u1024_cxor64`

void fio_u1024_cxor64(fio_u1024 *target, const fio_u1024 *a, uint64_t b)

Symbol type: function

#`fio_u1024_cxor8`

void fio_u1024_cxor8(fio_u1024 *target, const fio_u1024 *a, uint8_t b)

Symbol type: function

#`fio_u1024_inv`

void fio_u1024_inv(fio_u1024 *target, const fio_u1024 *a)

Symbol type: function

#`fio_u1024_is_eq`

bool fio_u1024_is_eq(const fio_u1024 *a, const fio_u1024 *b)

Symbol type: function

#`fio_u1024_lrot16`

void fio_u1024_lrot16(fio_u1024 *target, const fio_u1024 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u1024_lrot32`

void fio_u1024_lrot32(fio_u1024 *target, const fio_u1024 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u1024_lrot64`

void fio_u1024_lrot64(fio_u1024 *target, const fio_u1024 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u1024_lrot8`

void fio_u1024_lrot8(fio_u1024 *target, const fio_u1024 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u1024_maj`

void fio_u1024_maj(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b, const fio_u1024 *c)

Symbol type: function

#`fio_u1024_maj32`

void fio_u1024_maj32(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b, const fio_u1024 *c)

Symbol type: function

#`fio_u1024_maj64`

void fio_u1024_maj64(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b, const fio_u1024 *c)

Symbol type: function

#`fio_u1024_mul16`

void fio_u1024_mul16(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b)

Symbol type: function

#`fio_u1024_mul32`

void fio_u1024_mul32(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b)

Symbol type: function

#`fio_u1024_mul64`

void fio_u1024_mul64(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b)

Symbol type: function

#`fio_u1024_mul8`

void fio_u1024_mul8(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b)

Symbol type: function

#`fio_u1024_mux`

void fio_u1024_mux(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b, const fio_u1024 *c)

Symbol type: function

#`fio_u1024_mux32`

void fio_u1024_mux32(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b, const fio_u1024 *c)

Symbol type: function

#`fio_u1024_mux64`

void fio_u1024_mux64(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b, const fio_u1024 *c)

Symbol type: function

#`fio_u1024_or`

void fio_u1024_or(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b)

Symbol type: function

#`fio_u1024_or16`

void fio_u1024_or16(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b)

Symbol type: function

#`fio_u1024_or32`

void fio_u1024_or32(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b)

Symbol type: function

#`fio_u1024_or64`

void fio_u1024_or64(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b)

Symbol type: function

#`fio_u1024_or8`

void fio_u1024_or8(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b)

Symbol type: function

#`fio_u1024_reduce_add16`

uint16_t fio_u1024_reduce_add16(const fio_u1024 *a)

Symbol type: function

#`fio_u1024_reduce_add32`

uint32_t fio_u1024_reduce_add32(const fio_u1024 *a)

Symbol type: function

#`fio_u1024_reduce_add64`

uint64_t fio_u1024_reduce_add64(const fio_u1024 *a)

Symbol type: function

#`fio_u1024_reduce_add8`

uint8_t fio_u1024_reduce_add8(const fio_u1024 *a)

Symbol type: function

#`fio_u1024_reduce_and16`

uint16_t fio_u1024_reduce_and16(const fio_u1024 *a)

Symbol type: function

#`fio_u1024_reduce_and32`

uint32_t fio_u1024_reduce_and32(const fio_u1024 *a)

Symbol type: function

#`fio_u1024_reduce_and64`

uint64_t fio_u1024_reduce_and64(const fio_u1024 *a)

Symbol type: function

#`fio_u1024_reduce_and8`

uint8_t fio_u1024_reduce_and8(const fio_u1024 *a)

Symbol type: function

#`fio_u1024_reduce_mul16`

uint16_t fio_u1024_reduce_mul16(const fio_u1024 *a)

Symbol type: function

#`fio_u1024_reduce_mul32`

uint32_t fio_u1024_reduce_mul32(const fio_u1024 *a)

Symbol type: function

#`fio_u1024_reduce_mul64`

uint64_t fio_u1024_reduce_mul64(const fio_u1024 *a)

Symbol type: function

#`fio_u1024_reduce_mul8`

uint8_t fio_u1024_reduce_mul8(const fio_u1024 *a)

Symbol type: function

#`fio_u1024_reduce_or16`

uint16_t fio_u1024_reduce_or16(const fio_u1024 *a)

Symbol type: function

#`fio_u1024_reduce_or32`

uint32_t fio_u1024_reduce_or32(const fio_u1024 *a)

Symbol type: function

#`fio_u1024_reduce_or64`

uint64_t fio_u1024_reduce_or64(const fio_u1024 *a)

Symbol type: function

#`fio_u1024_reduce_or8`

uint8_t fio_u1024_reduce_or8(const fio_u1024 *a)

Symbol type: function

#`fio_u1024_reduce_sub16`

uint16_t fio_u1024_reduce_sub16(const fio_u1024 *a)

Symbol type: function

#`fio_u1024_reduce_sub32`

uint32_t fio_u1024_reduce_sub32(const fio_u1024 *a)

Symbol type: function

#`fio_u1024_reduce_sub64`

uint64_t fio_u1024_reduce_sub64(const fio_u1024 *a)

Symbol type: function

#`fio_u1024_reduce_sub8`

uint8_t fio_u1024_reduce_sub8(const fio_u1024 *a)

Symbol type: function

#`fio_u1024_reduce_xor16`

uint16_t fio_u1024_reduce_xor16(const fio_u1024 *a)

Symbol type: function

#`fio_u1024_reduce_xor32`

uint32_t fio_u1024_reduce_xor32(const fio_u1024 *a)

Symbol type: function

#`fio_u1024_reduce_xor64`

uint64_t fio_u1024_reduce_xor64(const fio_u1024 *a)

Symbol type: function

#`fio_u1024_reduce_xor8`

uint8_t fio_u1024_reduce_xor8(const fio_u1024 *a)

Symbol type: function

#`fio_u1024_rrot16`

void fio_u1024_rrot16(fio_u1024 *target, const fio_u1024 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u1024_rrot32`

void fio_u1024_rrot32(fio_u1024 *target, const fio_u1024 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u1024_rrot64`

void fio_u1024_rrot64(fio_u1024 *target, const fio_u1024 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u1024_rrot8`

void fio_u1024_rrot8(fio_u1024 *target, const fio_u1024 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u1024_sub16`

void fio_u1024_sub16(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b)

Symbol type: function

#`fio_u1024_sub32`

void fio_u1024_sub32(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b)

Symbol type: function

#`fio_u1024_sub64`

void fio_u1024_sub64(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b)

Symbol type: function

#`fio_u1024_sub8`

void fio_u1024_sub8(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b)

Symbol type: function

#`fio_u1024_xor`

void fio_u1024_xor(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b)

Symbol type: function

#`fio_u1024_xor16`

void fio_u1024_xor16(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b)

Symbol type: function

#`fio_u1024_xor32`

void fio_u1024_xor32(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b)

Symbol type: function

#`fio_u1024_xor64`

void fio_u1024_xor64(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b)

Symbol type: function

#`fio_u1024_xor8`

void fio_u1024_xor8(fio_u1024 *target, const fio_u1024 *a, const fio_u1024 *b)

Symbol type: function

#`fio_u2048_3xor`

void fio_u2048_3xor(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b, const fio_u2048 *c)

Symbol type: function

#`fio_u2048_3xor32`

void fio_u2048_3xor32(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b, const fio_u2048 *c)

Symbol type: function

#`fio_u2048_3xor64`

void fio_u2048_3xor64(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b, const fio_u2048 *c)

Symbol type: function

#`fio_u2048_add16`

void fio_u2048_add16(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b)

Symbol type: function

#`fio_u2048_add32`

void fio_u2048_add32(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b)

Symbol type: function

#`fio_u2048_add64`

void fio_u2048_add64(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b)

Symbol type: function

#`fio_u2048_add8`

void fio_u2048_add8(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b)

Symbol type: function

#`fio_u2048_and`

void fio_u2048_and(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b)

Symbol type: function

#`fio_u2048_and16`

void fio_u2048_and16(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b)

Symbol type: function

#`fio_u2048_and32`

void fio_u2048_and32(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b)

Symbol type: function

#`fio_u2048_and64`

void fio_u2048_and64(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b)

Symbol type: function

#`fio_u2048_and8`

void fio_u2048_and8(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b)

Symbol type: function

#`fio_u2048_cadd16`

void fio_u2048_cadd16(fio_u2048 *target, const fio_u2048 *a, uint16_t b)

Symbol type: function

#`fio_u2048_cadd32`

void fio_u2048_cadd32(fio_u2048 *target, const fio_u2048 *a, uint32_t b)

Symbol type: function

#`fio_u2048_cadd64`

void fio_u2048_cadd64(fio_u2048 *target, const fio_u2048 *a, uint64_t b)

Symbol type: function

#`fio_u2048_cadd8`

void fio_u2048_cadd8(fio_u2048 *target, const fio_u2048 *a, uint8_t b)

Symbol type: function

#`fio_u2048_cand16`

void fio_u2048_cand16(fio_u2048 *target, const fio_u2048 *a, uint16_t b)

Symbol type: function

#`fio_u2048_cand32`

void fio_u2048_cand32(fio_u2048 *target, const fio_u2048 *a, uint32_t b)

Symbol type: function

#`fio_u2048_cand64`

void fio_u2048_cand64(fio_u2048 *target, const fio_u2048 *a, uint64_t b)

Symbol type: function

#`fio_u2048_cand8`

void fio_u2048_cand8(fio_u2048 *target, const fio_u2048 *a, uint8_t b)

Symbol type: function

#`fio_u2048_clrot16`

void fio_u2048_clrot16(fio_u2048 *target, const fio_u2048 *a, const uint8_t bts)

Symbol type: function

#`fio_u2048_clrot32`

void fio_u2048_clrot32(fio_u2048 *target, const fio_u2048 *a, const uint8_t bts)

Symbol type: function

#`fio_u2048_clrot64`

void fio_u2048_clrot64(fio_u2048 *target, const fio_u2048 *a, const uint8_t bts)

Symbol type: function

#`fio_u2048_clrot8`

void fio_u2048_clrot8(fio_u2048 *target, const fio_u2048 *a, const uint8_t bts)

Symbol type: function

#`fio_u2048_cmul16`

void fio_u2048_cmul16(fio_u2048 *target, const fio_u2048 *a, uint16_t b)

Symbol type: function

#`fio_u2048_cmul32`

void fio_u2048_cmul32(fio_u2048 *target, const fio_u2048 *a, uint32_t b)

Symbol type: function

#`fio_u2048_cmul64`

void fio_u2048_cmul64(fio_u2048 *target, const fio_u2048 *a, uint64_t b)

Symbol type: function

#`fio_u2048_cmul8`

void fio_u2048_cmul8(fio_u2048 *target, const fio_u2048 *a, uint8_t b)

Symbol type: function

#`fio_u2048_cor16`

void fio_u2048_cor16(fio_u2048 *target, const fio_u2048 *a, uint16_t b)

Symbol type: function

#`fio_u2048_cor32`

void fio_u2048_cor32(fio_u2048 *target, const fio_u2048 *a, uint32_t b)

Symbol type: function

#`fio_u2048_cor64`

void fio_u2048_cor64(fio_u2048 *target, const fio_u2048 *a, uint64_t b)

Symbol type: function

#`fio_u2048_cor8`

void fio_u2048_cor8(fio_u2048 *target, const fio_u2048 *a, uint8_t b)

Symbol type: function

#`fio_u2048_crrot16`

void fio_u2048_crrot16(fio_u2048 *target, const fio_u2048 *a, const uint8_t bts)

Symbol type: function

#`fio_u2048_crrot32`

void fio_u2048_crrot32(fio_u2048 *target, const fio_u2048 *a, const uint8_t bts)

Symbol type: function

#`fio_u2048_crrot64`

void fio_u2048_crrot64(fio_u2048 *target, const fio_u2048 *a, const uint8_t bts)

Symbol type: function

#`fio_u2048_crrot8`

void fio_u2048_crrot8(fio_u2048 *target, const fio_u2048 *a, const uint8_t bts)

Symbol type: function

#`fio_u2048_csub16`

void fio_u2048_csub16(fio_u2048 *target, const fio_u2048 *a, uint16_t b)

Symbol type: function

#`fio_u2048_csub32`

void fio_u2048_csub32(fio_u2048 *target, const fio_u2048 *a, uint32_t b)

Symbol type: function

#`fio_u2048_csub64`

void fio_u2048_csub64(fio_u2048 *target, const fio_u2048 *a, uint64_t b)

Symbol type: function

#`fio_u2048_csub8`

void fio_u2048_csub8(fio_u2048 *target, const fio_u2048 *a, uint8_t b)

Symbol type: function

#`fio_u2048_ct_swap_if`

void fio_u2048_ct_swap_if(bool cond, fio_u2048 *restrict a, fio_u2048 *restrict b)

Symbol type: function

#`fio_u2048_cxor16`

void fio_u2048_cxor16(fio_u2048 *target, const fio_u2048 *a, uint16_t b)

Symbol type: function

#`fio_u2048_cxor32`

void fio_u2048_cxor32(fio_u2048 *target, const fio_u2048 *a, uint32_t b)

Symbol type: function

#`fio_u2048_cxor64`

void fio_u2048_cxor64(fio_u2048 *target, const fio_u2048 *a, uint64_t b)

Symbol type: function

#`fio_u2048_cxor8`

void fio_u2048_cxor8(fio_u2048 *target, const fio_u2048 *a, uint8_t b)

Symbol type: function

#`fio_u2048_inv`

void fio_u2048_inv(fio_u2048 *target, const fio_u2048 *a)

Symbol type: function

#`fio_u2048_is_eq`

bool fio_u2048_is_eq(const fio_u2048 *a, const fio_u2048 *b)

Symbol type: function

#`fio_u2048_lrot16`

void fio_u2048_lrot16(fio_u2048 *target, const fio_u2048 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u2048_lrot32`

void fio_u2048_lrot32(fio_u2048 *target, const fio_u2048 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u2048_lrot64`

void fio_u2048_lrot64(fio_u2048 *target, const fio_u2048 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u2048_lrot8`

void fio_u2048_lrot8(fio_u2048 *target, const fio_u2048 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u2048_maj`

void fio_u2048_maj(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b, const fio_u2048 *c)

Symbol type: function

#`fio_u2048_maj32`

void fio_u2048_maj32(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b, const fio_u2048 *c)

Symbol type: function

#`fio_u2048_maj64`

void fio_u2048_maj64(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b, const fio_u2048 *c)

Symbol type: function

#`fio_u2048_mul16`

void fio_u2048_mul16(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b)

Symbol type: function

#`fio_u2048_mul32`

void fio_u2048_mul32(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b)

Symbol type: function

#`fio_u2048_mul64`

void fio_u2048_mul64(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b)

Symbol type: function

#`fio_u2048_mul8`

void fio_u2048_mul8(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b)

Symbol type: function

#`fio_u2048_mux`

void fio_u2048_mux(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b, const fio_u2048 *c)

Symbol type: function

#`fio_u2048_mux32`

void fio_u2048_mux32(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b, const fio_u2048 *c)

Symbol type: function

#`fio_u2048_mux64`

void fio_u2048_mux64(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b, const fio_u2048 *c)

Symbol type: function

#`fio_u2048_or`

void fio_u2048_or(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b)

Symbol type: function

#`fio_u2048_or16`

void fio_u2048_or16(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b)

Symbol type: function

#`fio_u2048_or32`

void fio_u2048_or32(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b)

Symbol type: function

#`fio_u2048_or64`

void fio_u2048_or64(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b)

Symbol type: function

#`fio_u2048_or8`

void fio_u2048_or8(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b)

Symbol type: function

#`fio_u2048_reduce_add16`

uint16_t fio_u2048_reduce_add16(const fio_u2048 *a)

Symbol type: function

#`fio_u2048_reduce_add32`

uint32_t fio_u2048_reduce_add32(const fio_u2048 *a)

Symbol type: function

#`fio_u2048_reduce_add64`

uint64_t fio_u2048_reduce_add64(const fio_u2048 *a)

Symbol type: function

#`fio_u2048_reduce_add8`

uint8_t fio_u2048_reduce_add8(const fio_u2048 *a)

Symbol type: function

#`fio_u2048_reduce_and16`

uint16_t fio_u2048_reduce_and16(const fio_u2048 *a)

Symbol type: function

#`fio_u2048_reduce_and32`

uint32_t fio_u2048_reduce_and32(const fio_u2048 *a)

Symbol type: function

#`fio_u2048_reduce_and64`

uint64_t fio_u2048_reduce_and64(const fio_u2048 *a)

Symbol type: function

#`fio_u2048_reduce_and8`

uint8_t fio_u2048_reduce_and8(const fio_u2048 *a)

Symbol type: function

#`fio_u2048_reduce_mul16`

uint16_t fio_u2048_reduce_mul16(const fio_u2048 *a)

Symbol type: function

#`fio_u2048_reduce_mul32`

uint32_t fio_u2048_reduce_mul32(const fio_u2048 *a)

Symbol type: function

#`fio_u2048_reduce_mul64`

uint64_t fio_u2048_reduce_mul64(const fio_u2048 *a)

Symbol type: function

#`fio_u2048_reduce_mul8`

uint8_t fio_u2048_reduce_mul8(const fio_u2048 *a)

Symbol type: function

#`fio_u2048_reduce_or16`

uint16_t fio_u2048_reduce_or16(const fio_u2048 *a)

Symbol type: function

#`fio_u2048_reduce_or32`

uint32_t fio_u2048_reduce_or32(const fio_u2048 *a)

Symbol type: function

#`fio_u2048_reduce_or64`

uint64_t fio_u2048_reduce_or64(const fio_u2048 *a)

Symbol type: function

#`fio_u2048_reduce_or8`

uint8_t fio_u2048_reduce_or8(const fio_u2048 *a)

Symbol type: function

#`fio_u2048_reduce_sub16`

uint16_t fio_u2048_reduce_sub16(const fio_u2048 *a)

Symbol type: function

#`fio_u2048_reduce_sub32`

uint32_t fio_u2048_reduce_sub32(const fio_u2048 *a)

Symbol type: function

#`fio_u2048_reduce_sub64`

uint64_t fio_u2048_reduce_sub64(const fio_u2048 *a)

Symbol type: function

#`fio_u2048_reduce_sub8`

uint8_t fio_u2048_reduce_sub8(const fio_u2048 *a)

Symbol type: function

#`fio_u2048_reduce_xor16`

uint16_t fio_u2048_reduce_xor16(const fio_u2048 *a)

Symbol type: function

#`fio_u2048_reduce_xor32`

uint32_t fio_u2048_reduce_xor32(const fio_u2048 *a)

Symbol type: function

#`fio_u2048_reduce_xor64`

uint64_t fio_u2048_reduce_xor64(const fio_u2048 *a)

Symbol type: function

#`fio_u2048_reduce_xor8`

uint8_t fio_u2048_reduce_xor8(const fio_u2048 *a)

Symbol type: function

#`fio_u2048_rrot16`

void fio_u2048_rrot16(fio_u2048 *target, const fio_u2048 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u2048_rrot32`

void fio_u2048_rrot32(fio_u2048 *target, const fio_u2048 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u2048_rrot64`

void fio_u2048_rrot64(fio_u2048 *target, const fio_u2048 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u2048_rrot8`

void fio_u2048_rrot8(fio_u2048 *target, const fio_u2048 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u2048_sub16`

void fio_u2048_sub16(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b)

Symbol type: function

#`fio_u2048_sub32`

void fio_u2048_sub32(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b)

Symbol type: function

#`fio_u2048_sub64`

void fio_u2048_sub64(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b)

Symbol type: function

#`fio_u2048_sub8`

void fio_u2048_sub8(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b)

Symbol type: function

#`fio_u2048_xor`

void fio_u2048_xor(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b)

Symbol type: function

#`fio_u2048_xor16`

void fio_u2048_xor16(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b)

Symbol type: function

#`fio_u2048_xor32`

void fio_u2048_xor32(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b)

Symbol type: function

#`fio_u2048_xor64`

void fio_u2048_xor64(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b)

Symbol type: function

#`fio_u2048_xor8`

void fio_u2048_xor8(fio_u2048 *target, const fio_u2048 *a, const fio_u2048 *b)

Symbol type: function

#`fio_u4096_3xor`

void fio_u4096_3xor(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b, const fio_u4096 *c)

Symbol type: function

#`fio_u4096_3xor32`

void fio_u4096_3xor32(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b, const fio_u4096 *c)

Symbol type: function

#`fio_u4096_3xor64`

void fio_u4096_3xor64(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b, const fio_u4096 *c)

Symbol type: function

#`fio_u4096_add16`

void fio_u4096_add16(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b)

Symbol type: function

#`fio_u4096_add32`

void fio_u4096_add32(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b)

Symbol type: function

#`fio_u4096_add64`

void fio_u4096_add64(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b)

Symbol type: function

#`fio_u4096_add8`

void fio_u4096_add8(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b)

Symbol type: function

#`fio_u4096_and`

void fio_u4096_and(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b)

Symbol type: function

#`fio_u4096_and16`

void fio_u4096_and16(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b)

Symbol type: function

#`fio_u4096_and32`

void fio_u4096_and32(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b)

Symbol type: function

#`fio_u4096_and64`

void fio_u4096_and64(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b)

Symbol type: function

#`fio_u4096_and8`

void fio_u4096_and8(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b)

Symbol type: function

#`fio_u4096_cadd16`

void fio_u4096_cadd16(fio_u4096 *target, const fio_u4096 *a, uint16_t b)

Symbol type: function

#`fio_u4096_cadd32`

void fio_u4096_cadd32(fio_u4096 *target, const fio_u4096 *a, uint32_t b)

Symbol type: function

#`fio_u4096_cadd64`

void fio_u4096_cadd64(fio_u4096 *target, const fio_u4096 *a, uint64_t b)

Symbol type: function

#`fio_u4096_cadd8`

void fio_u4096_cadd8(fio_u4096 *target, const fio_u4096 *a, uint8_t b)

Symbol type: function

#`fio_u4096_cand16`

void fio_u4096_cand16(fio_u4096 *target, const fio_u4096 *a, uint16_t b)

Symbol type: function

#`fio_u4096_cand32`

void fio_u4096_cand32(fio_u4096 *target, const fio_u4096 *a, uint32_t b)

Symbol type: function

#`fio_u4096_cand64`

void fio_u4096_cand64(fio_u4096 *target, const fio_u4096 *a, uint64_t b)

Symbol type: function

#`fio_u4096_cand8`

void fio_u4096_cand8(fio_u4096 *target, const fio_u4096 *a, uint8_t b)

Symbol type: function

#`fio_u4096_clrot16`

void fio_u4096_clrot16(fio_u4096 *target, const fio_u4096 *a, const uint8_t bts)

Symbol type: function

#`fio_u4096_clrot32`

void fio_u4096_clrot32(fio_u4096 *target, const fio_u4096 *a, const uint8_t bts)

Symbol type: function

#`fio_u4096_clrot64`

void fio_u4096_clrot64(fio_u4096 *target, const fio_u4096 *a, const uint8_t bts)

Symbol type: function

#`fio_u4096_clrot8`

void fio_u4096_clrot8(fio_u4096 *target, const fio_u4096 *a, const uint8_t bts)

Symbol type: function

#`fio_u4096_cmul16`

void fio_u4096_cmul16(fio_u4096 *target, const fio_u4096 *a, uint16_t b)

Symbol type: function

#`fio_u4096_cmul32`

void fio_u4096_cmul32(fio_u4096 *target, const fio_u4096 *a, uint32_t b)

Symbol type: function

#`fio_u4096_cmul64`

void fio_u4096_cmul64(fio_u4096 *target, const fio_u4096 *a, uint64_t b)

Symbol type: function

#`fio_u4096_cmul8`

void fio_u4096_cmul8(fio_u4096 *target, const fio_u4096 *a, uint8_t b)

Symbol type: function

#`fio_u4096_cor16`

void fio_u4096_cor16(fio_u4096 *target, const fio_u4096 *a, uint16_t b)

Symbol type: function

#`fio_u4096_cor32`

void fio_u4096_cor32(fio_u4096 *target, const fio_u4096 *a, uint32_t b)

Symbol type: function

#`fio_u4096_cor64`

void fio_u4096_cor64(fio_u4096 *target, const fio_u4096 *a, uint64_t b)

Symbol type: function

#`fio_u4096_cor8`

void fio_u4096_cor8(fio_u4096 *target, const fio_u4096 *a, uint8_t b)

Symbol type: function

#`fio_u4096_crrot16`

void fio_u4096_crrot16(fio_u4096 *target, const fio_u4096 *a, const uint8_t bts)

Symbol type: function

#`fio_u4096_crrot32`

void fio_u4096_crrot32(fio_u4096 *target, const fio_u4096 *a, const uint8_t bts)

Symbol type: function

#`fio_u4096_crrot64`

void fio_u4096_crrot64(fio_u4096 *target, const fio_u4096 *a, const uint8_t bts)

Symbol type: function

#`fio_u4096_crrot8`

void fio_u4096_crrot8(fio_u4096 *target, const fio_u4096 *a, const uint8_t bts)

Symbol type: function

#`fio_u4096_csub16`

void fio_u4096_csub16(fio_u4096 *target, const fio_u4096 *a, uint16_t b)

Symbol type: function

#`fio_u4096_csub32`

void fio_u4096_csub32(fio_u4096 *target, const fio_u4096 *a, uint32_t b)

Symbol type: function

#`fio_u4096_csub64`

void fio_u4096_csub64(fio_u4096 *target, const fio_u4096 *a, uint64_t b)

Symbol type: function

#`fio_u4096_csub8`

void fio_u4096_csub8(fio_u4096 *target, const fio_u4096 *a, uint8_t b)

Symbol type: function

#`fio_u4096_ct_swap_if`

void fio_u4096_ct_swap_if(bool cond, fio_u4096 *restrict a, fio_u4096 *restrict b)

Symbol type: function

#`fio_u4096_cxor16`

void fio_u4096_cxor16(fio_u4096 *target, const fio_u4096 *a, uint16_t b)

Symbol type: function

#`fio_u4096_cxor32`

void fio_u4096_cxor32(fio_u4096 *target, const fio_u4096 *a, uint32_t b)

Symbol type: function

#`fio_u4096_cxor64`

void fio_u4096_cxor64(fio_u4096 *target, const fio_u4096 *a, uint64_t b)

Symbol type: function

#`fio_u4096_cxor8`

void fio_u4096_cxor8(fio_u4096 *target, const fio_u4096 *a, uint8_t b)

Symbol type: function

#`fio_u4096_inv`

void fio_u4096_inv(fio_u4096 *target, const fio_u4096 *a)

Symbol type: function

#`fio_u4096_is_eq`

bool fio_u4096_is_eq(const fio_u4096 *a, const fio_u4096 *b)

Symbol type: function

#`fio_u4096_lrot16`

void fio_u4096_lrot16(fio_u4096 *target, const fio_u4096 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u4096_lrot32`

void fio_u4096_lrot32(fio_u4096 *target, const fio_u4096 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u4096_lrot64`

void fio_u4096_lrot64(fio_u4096 *target, const fio_u4096 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u4096_lrot8`

void fio_u4096_lrot8(fio_u4096 *target, const fio_u4096 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u4096_maj`

void fio_u4096_maj(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b, const fio_u4096 *c)

Symbol type: function

#`fio_u4096_maj32`

void fio_u4096_maj32(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b, const fio_u4096 *c)

Symbol type: function

#`fio_u4096_maj64`

void fio_u4096_maj64(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b, const fio_u4096 *c)

Symbol type: function

#`fio_u4096_mul16`

void fio_u4096_mul16(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b)

Symbol type: function

#`fio_u4096_mul32`

void fio_u4096_mul32(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b)

Symbol type: function

#`fio_u4096_mul64`

void fio_u4096_mul64(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b)

Symbol type: function

#`fio_u4096_mul8`

void fio_u4096_mul8(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b)

Symbol type: function

#`fio_u4096_mux`

void fio_u4096_mux(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b, const fio_u4096 *c)

Symbol type: function

#`fio_u4096_mux32`

void fio_u4096_mux32(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b, const fio_u4096 *c)

Symbol type: function

#`fio_u4096_mux64`

void fio_u4096_mux64(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b, const fio_u4096 *c)

Symbol type: function

#`fio_u4096_or`

void fio_u4096_or(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b)

Symbol type: function

#`fio_u4096_or16`

void fio_u4096_or16(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b)

Symbol type: function

#`fio_u4096_or32`

void fio_u4096_or32(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b)

Symbol type: function

#`fio_u4096_or64`

void fio_u4096_or64(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b)

Symbol type: function

#`fio_u4096_or8`

void fio_u4096_or8(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b)

Symbol type: function

#`fio_u4096_reduce_add16`

uint16_t fio_u4096_reduce_add16(const fio_u4096 *a)

Symbol type: function

#`fio_u4096_reduce_add32`

uint32_t fio_u4096_reduce_add32(const fio_u4096 *a)

Symbol type: function

#`fio_u4096_reduce_add64`

uint64_t fio_u4096_reduce_add64(const fio_u4096 *a)

Symbol type: function

#`fio_u4096_reduce_add8`

uint8_t fio_u4096_reduce_add8(const fio_u4096 *a)

Symbol type: function

#`fio_u4096_reduce_and16`

uint16_t fio_u4096_reduce_and16(const fio_u4096 *a)

Symbol type: function

#`fio_u4096_reduce_and32`

uint32_t fio_u4096_reduce_and32(const fio_u4096 *a)

Symbol type: function

#`fio_u4096_reduce_and64`

uint64_t fio_u4096_reduce_and64(const fio_u4096 *a)

Symbol type: function

#`fio_u4096_reduce_and8`

uint8_t fio_u4096_reduce_and8(const fio_u4096 *a)

Symbol type: function

#`fio_u4096_reduce_mul16`

uint16_t fio_u4096_reduce_mul16(const fio_u4096 *a)

Symbol type: function

#`fio_u4096_reduce_mul32`

uint32_t fio_u4096_reduce_mul32(const fio_u4096 *a)

Symbol type: function

#`fio_u4096_reduce_mul64`

uint64_t fio_u4096_reduce_mul64(const fio_u4096 *a)

Symbol type: function

#`fio_u4096_reduce_mul8`

uint8_t fio_u4096_reduce_mul8(const fio_u4096 *a)

Symbol type: function

#`fio_u4096_reduce_or16`

uint16_t fio_u4096_reduce_or16(const fio_u4096 *a)

Symbol type: function

#`fio_u4096_reduce_or32`

uint32_t fio_u4096_reduce_or32(const fio_u4096 *a)

Symbol type: function

#`fio_u4096_reduce_or64`

uint64_t fio_u4096_reduce_or64(const fio_u4096 *a)

Symbol type: function

#`fio_u4096_reduce_or8`

uint8_t fio_u4096_reduce_or8(const fio_u4096 *a)

Symbol type: function

#`fio_u4096_reduce_sub16`

uint16_t fio_u4096_reduce_sub16(const fio_u4096 *a)

Symbol type: function

#`fio_u4096_reduce_sub32`

uint32_t fio_u4096_reduce_sub32(const fio_u4096 *a)

Symbol type: function

#`fio_u4096_reduce_sub64`

uint64_t fio_u4096_reduce_sub64(const fio_u4096 *a)

Symbol type: function

#`fio_u4096_reduce_sub8`

uint8_t fio_u4096_reduce_sub8(const fio_u4096 *a)

Symbol type: function

#`fio_u4096_reduce_xor16`

uint16_t fio_u4096_reduce_xor16(const fio_u4096 *a)

Symbol type: function

#`fio_u4096_reduce_xor32`

uint32_t fio_u4096_reduce_xor32(const fio_u4096 *a)

Symbol type: function

#`fio_u4096_reduce_xor64`

uint64_t fio_u4096_reduce_xor64(const fio_u4096 *a)

Symbol type: function

#`fio_u4096_reduce_xor8`

uint8_t fio_u4096_reduce_xor8(const fio_u4096 *a)

Symbol type: function

#`fio_u4096_rrot16`

void fio_u4096_rrot16(fio_u4096 *target, const fio_u4096 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u4096_rrot32`

void fio_u4096_rrot32(fio_u4096 *target, const fio_u4096 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u4096_rrot64`

void fio_u4096_rrot64(fio_u4096 *target, const fio_u4096 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u4096_rrot8`

void fio_u4096_rrot8(fio_u4096 *target, const fio_u4096 *a, const uint8_t *rotations)

Symbol type: function

#`fio_u4096_sub16`

void fio_u4096_sub16(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b)

Symbol type: function

#`fio_u4096_sub32`

void fio_u4096_sub32(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b)

Symbol type: function

#`fio_u4096_sub64`

void fio_u4096_sub64(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b)

Symbol type: function

#`fio_u4096_sub8`

void fio_u4096_sub8(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b)

Symbol type: function

#`fio_u4096_xor`

void fio_u4096_xor(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b)

Symbol type: function

#`fio_u4096_xor16`

void fio_u4096_xor16(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b)

Symbol type: function

#`fio_u4096_xor32`

void fio_u4096_xor32(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b)

Symbol type: function

#`fio_u4096_xor64`

void fio_u4096_xor64(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b)

Symbol type: function

#`fio_u4096_xor8`

void fio_u4096_xor8(fio_u4096 *target, const fio_u4096 *a, const fio_u4096 *b)

Symbol type: function

#`fio_u128_addv64`

fio_u128 fio_u128_addv64(fio_u128 a, fio_u128 b)

ADD two values as 64-bit lanes, returning result by value.

Symbol type: function

#`fio_u128_andv`

fio_u128 fio_u128_andv(fio_u128 a, fio_u128 b)

AND two values, returning result by value.

Symbol type: function

#`fio_u128_orv`

fio_u128 fio_u128_orv(fio_u128 a, fio_u128 b)

OR two values, returning result by value.

Symbol type: function

#`fio_u128_xorv`

fio_u128 fio_u128_xorv(fio_u128 a, fio_u128 b)

XOR two values, returning result by value.

Symbol type: function

#`fio_u256_addv64`

fio_u256 fio_u256_addv64(fio_u256 a, fio_u256 b)

ADD two values as 64-bit lanes, returning result by value.

Symbol type: function

#`fio_u256_andv`

fio_u256 fio_u256_andv(fio_u256 a, fio_u256 b)

AND two values, returning result by value.

Symbol type: function

#`fio_u256_orv`

fio_u256 fio_u256_orv(fio_u256 a, fio_u256 b)

OR two values, returning result by value.

Symbol type: function

#`fio_u256_xorv`

fio_u256 fio_u256_xorv(fio_u256 a, fio_u256 b)

XOR two values, returning result by value.

Symbol type: function

#`fio_u512_addv64`

fio_u512 fio_u512_addv64(fio_u512 a, fio_u512 b)

ADD two values as 64-bit lanes, returning result by value.

Symbol type: function

#`fio_u512_andv`

fio_u512 fio_u512_andv(fio_u512 a, fio_u512 b)

AND two values, returning result by value.

Symbol type: function

#`fio_u512_orv`

fio_u512 fio_u512_orv(fio_u512 a, fio_u512 b)

OR two values, returning result by value.

Symbol type: function

#`fio_u512_xorv`

fio_u512 fio_u512_xorv(fio_u512 a, fio_u512 b)

XOR two values, returning result by value.

Symbol type: function

#`fio_u1024_addv64`

fio_u1024 fio_u1024_addv64(fio_u1024 a, fio_u1024 b)

ADD two values as 64-bit lanes, returning result by value.

Symbol type: function

#`fio_u1024_andv`

fio_u1024 fio_u1024_andv(fio_u1024 a, fio_u1024 b)

AND two values, returning result by value.

Symbol type: function

#`fio_u1024_orv`

fio_u1024 fio_u1024_orv(fio_u1024 a, fio_u1024 b)

OR two values, returning result by value.

Symbol type: function

#`fio_u1024_xorv`

fio_u1024 fio_u1024_xorv(fio_u1024 a, fio_u1024 b)

XOR two values, returning result by value.

Symbol type: function

#`fio_u2048_addv64`

fio_u2048 fio_u2048_addv64(fio_u2048 a, fio_u2048 b)

ADD two values as 64-bit lanes, returning result by value.

Symbol type: function

#`fio_u2048_andv`

fio_u2048 fio_u2048_andv(fio_u2048 a, fio_u2048 b)

AND two values, returning result by value.

Symbol type: function

#`fio_u2048_orv`

fio_u2048 fio_u2048_orv(fio_u2048 a, fio_u2048 b)

OR two values, returning result by value.

Symbol type: function

#`fio_u2048_xorv`

fio_u2048 fio_u2048_xorv(fio_u2048 a, fio_u2048 b)

XOR two values, returning result by value.

Symbol type: function

#`fio_u4096_addv64`

fio_u4096 fio_u4096_addv64(fio_u4096 a, fio_u4096 b)

ADD two values as 64-bit lanes, returning result by value.

Symbol type: function

#`fio_u4096_andv`

fio_u4096 fio_u4096_andv(fio_u4096 a, fio_u4096 b)

AND two values, returning result by value.

Symbol type: function

#`fio_u4096_orv`

fio_u4096 fio_u4096_orv(fio_u4096 a, fio_u4096 b)

OR two values, returning result by value.

Symbol type: function

#`fio_u4096_xorv`

fio_u4096 fio_u4096_xorv(fio_u4096 a, fio_u4096 b)

XOR two values, returning result by value.

Symbol type: function

#`fio_u128_add`

uint64_t fio_u128_add(fio_u128 *result, const fio_u128 *a, const fio_u128 *b)

Performs A+B, storing in result. Return the carry bit (1 or 0).

Symbol type: function

#`fio_u128_cmp`

int fio_u128_cmp(const fio_u128 *a, const fio_u128 *b)

Returns -1, 0, or 1 if a < b, a == b or a > a (respectively).

Symbol type: function

#`fio_u128_sub`

uint64_t fio_u128_sub(fio_u128 *result, const fio_u128 *a, const fio_u128 *b)

Performs A-B, storing in result. Returns the borrow bit (1 or 0).

Symbol type: function

#`fio_u256_add`

uint64_t fio_u256_add(fio_u256 *result, const fio_u256 *a, const fio_u256 *b)

Performs A+B, storing in result. Return the carry bit (1 or 0).

Symbol type: function

#`fio_u256_cmp`

int fio_u256_cmp(const fio_u256 *a, const fio_u256 *b)

Returns -1, 0, or 1 if a < b, a == b or a > a (respectively).

Symbol type: function

#`fio_u256_sub`

uint64_t fio_u256_sub(fio_u256 *result, const fio_u256 *a, const fio_u256 *b)

Performs A-B, storing in result. Returns the borrow bit (1 or 0).

Symbol type: function

#`fio_u512_add`

uint64_t fio_u512_add(fio_u512 *result, const fio_u512 *a, const fio_u512 *b)

Performs A+B, storing in result. Return the carry bit (1 or 0).

Symbol type: function

#`fio_u512_cmp`

int fio_u512_cmp(const fio_u512 *a, const fio_u512 *b)

Returns -1, 0, or 1 if a < b, a == b or a > a (respectively).

Symbol type: function

#`fio_u512_sub`

uint64_t fio_u512_sub(fio_u512 *result, const fio_u512 *a, const fio_u512 *b)

Performs A-B, storing in result. Returns the borrow bit (1 or 0).

Symbol type: function

#`fio_u1024_add`

uint64_t fio_u1024_add(fio_u1024 *result, const fio_u1024 *a, const fio_u1024 *b)

Performs A+B, storing in result. Return the carry bit (1 or 0).

Symbol type: function

#`fio_u1024_cmp`

int fio_u1024_cmp(const fio_u1024 *a, const fio_u1024 *b)

Returns -1, 0, or 1 if a < b, a == b or a > a (respectively).

Symbol type: function

#`fio_u1024_sub`

uint64_t fio_u1024_sub(fio_u1024 *result, const fio_u1024 *a, const fio_u1024 *b)

Performs A-B, storing in result. Returns the borrow bit (1 or 0).

Symbol type: function

#`fio_u2048_add`

uint64_t fio_u2048_add(fio_u2048 *result, const fio_u2048 *a, const fio_u2048 *b)

Performs A+B, storing in result. Return the carry bit (1 or 0).

Symbol type: function

#`fio_u2048_cmp`

int fio_u2048_cmp(const fio_u2048 *a, const fio_u2048 *b)

Returns -1, 0, or 1 if a < b, a == b or a > a (respectively).

Symbol type: function

#`fio_u2048_sub`

uint64_t fio_u2048_sub(fio_u2048 *result, const fio_u2048 *a, const fio_u2048 *b)

Performs A-B, storing in result. Returns the borrow bit (1 or 0).

Symbol type: function

#`fio_u4096_add`

uint64_t fio_u4096_add(fio_u4096 *result, const fio_u4096 *a, const fio_u4096 *b)

Performs A+B, storing in result. Return the carry bit (1 or 0).

Symbol type: function

#`fio_u4096_cmp`

int fio_u4096_cmp(const fio_u4096 *a, const fio_u4096 *b)

Returns -1, 0, or 1 if a < b, a == b or a > a (respectively).

Symbol type: function

#`fio_u4096_sub`

uint64_t fio_u4096_sub(fio_u4096 *result, const fio_u4096 *a, const fio_u4096 *b)

Performs A-B, storing in result. Returns the borrow bit (1 or 0).

Symbol type: function

#`fio_u128_montgomery_mul`

void fio_u128_montgomery_mul(fio_u128 *result, const fio_u128 *a, const fio_u128 *b, const fio_u128 *N, const fio_u128 *N_dash)

Symbol type: function

#`fio_u128_mul`

void fio_u128_mul(fio_u256 *result, const fio_u128 *a, const fio_u128 *b)

Multiplies A and B, storing the result in result.

Symbol type: function

#`fio_u256_montgomery_mul`

void fio_u256_montgomery_mul(fio_u256 *result, const fio_u256 *a, const fio_u256 *b, const fio_u256 *N, const fio_u256 *N_dash)

Symbol type: function

#`fio_u256_mul`

void fio_u256_mul(fio_u512 *result, const fio_u256 *a, const fio_u256 *b)

Multiplies A and B, storing the result in result.

Symbol type: function

#`fio_u512_montgomery_mul`

void fio_u512_montgomery_mul(fio_u512 *result, const fio_u512 *a, const fio_u512 *b, const fio_u512 *N, const fio_u512 *N_dash)

Symbol type: function

#`fio_u512_mul`

void fio_u512_mul(fio_u1024 *result, const fio_u512 *a, const fio_u512 *b)

Multiplies A and B, storing the result in result.

Symbol type: function

#`fio_u1024_montgomery_mul`

void fio_u1024_montgomery_mul(fio_u1024 *result, const fio_u1024 *a, const fio_u1024 *b, const fio_u1024 *N, const fio_u1024 *N_dash)

Symbol type: function

#`fio_u1024_mul`

void fio_u1024_mul(fio_u2048 *result, const fio_u1024 *a, const fio_u1024 *b)

Multiplies A and B, storing the result in result.

Symbol type: function

#`fio_u2048_montgomery_mul`

void fio_u2048_montgomery_mul(fio_u2048 *result, const fio_u2048 *a, const fio_u2048 *b, const fio_u2048 *N, const fio_u2048 *N_dash)

Symbol type: function

#`fio_u2048_mul`

void fio_u2048_mul(fio_u4096 *result, const fio_u2048 *a, const fio_u2048 *b)

Multiplies A and B, storing the result in result.

Symbol type: function

#`fio_cycle_counter`

inline uint64_t fio_cycle_counter(void)

Symbol type: function

#`fio_utf8_code_len`

inline FIO_CONST unsigned fio_utf8_code_len(uint32_t u)

Symbol type: function

#`fio_utf8_char_len_unsafe`

inline FIO_CONST unsigned fio_utf8_char_len_unsafe(uint8_t c)

Returns 1-4 (UTF-8 char length), 8 (middle of a char) or 0 (invalid).

Symbol type: function

#`fio_utf8_char_len`

inline unsigned fio_utf8_char_len(const void *str_)

Returns the number of valid UTF-8 bytes used by first char at str.

Symbol type: function

#`fio_utf8_write`

inline unsigned fio_utf8_write(void *dest_, uint32_t u)

Writes code point to dest using UFT-8. Returns number of bytes written.

Symbol type: function

#`fio_utf8_read`

inline uint32_t fio_utf8_read(char **str)

Decodes the first UTF-8 char at str and returns its code point value.

Advances the pointer at str by the number of bytes consumed (read).

Symbol type: function

#`fio_utf8_peek`

inline uint32_t fio_utf8_peek(const char *str)

Decodes the first UTF-8 char at str and returns its code point value.

Symbol type: function

#./fio-stl/000 core.h

#Definition / Code Generation Macros

#FIO_DEF_GET_FUNC_DEC

#FIO_DEF_GET_FUNC

#FIO_DEF_SET_FUNC_DEC

#FIO_DEF_SET_FUNC

#FIO_DEF_GETSET_FUNC

#FIO_DEF_GETSET_FUNC_DEC

#FIO_IFUNC_DEF_GET

#FIO_IFUNC_DEF_SET

#FIO_IFUNC_DEF_GETSET

#FIO_STATIC_ALLOC_DEF

#FIO_STATIC_SAFE_ALLOC_DEF

#FIO_UXXX_X64_DEF

#FIO_UXXX_X32_DEF

#FIO_UXXX_X16_DEF

#FIO_UXXX_X8_DEF

#Macros

#FIO_NOOP

#FIO_NOOP_FN

#FIO_NOOP_FN_NAME

#FIO_VERSION_MAJOR

#FIO_VERSION_MINOR

#FIO_VERSION_PATCH

#FIO_VERSION_BUILD

#FIO_VERSION_STRING

#FIO_LEAK_COUNTER

#FIO_USE_THREAD_MUTEX

#FIO_UNALIGNED_ACCESS

#FIO_LIMIT_INTRINSIC_BUFFER

#FIO_MEMORY_INITIALIZE_ALLOCATIONS_DEFAULT

#FIO_MEM_PAGE_SIZE_LOG

#FIO_MAP_WARNING_BITSIZE

#FIO_ALIGN

#FIO_COMPILER_GUARD

#FIO_COMPILER_GUARD_INSTRUCTION

#FIO_UNALIGNED_MEMORY_ACCESS_ENABLED

#FIO_OS_POSIX

#FIO_OS_WIN

#FIO_KILL_SELF

#FIO_HAVE_UNIX_TOOLS

#FIO_SIZE_T_ERROR

#FIO_MAYBE_UNUSED

#FIO_SFUNC

#FIO_IFUNC

#FIO_WARN_UNUSED

#FIO_MIFN

#FIO_CONST

#FIO_PURE

#FIO_WEAK

#FIO_WEAK_VAR

#FIO_CONSTRUCTOR

#FIO_DESTRUCTOR

#FIO_LIKELY

#FIO_UNLIKELY

#FIO_PREFETCH

#FIO_PREFETCH_W

#FIO_PREFETCH_NT

#FIO_MACRO2STR

#FIO_NAME

#FIO_NAME2

#FIO_NAME_BL

#FIO_NAME_TEST

#FIO_PTR_MATH_LMASK

#FIO_PTR_MATH_RMASK

#FIO_PTR_MATH_ADD

#FIO_PTR_MATH_SUB

#FIO_PTR_FIELD_OFFSET

#FIO_PTR_FROM_FIELD

#FIO_THREAD_WAIT

#FIO_THREAD_YIELD

#FIO_THREAD_RESCHEDULE

#FIO_LOCK_INIT

#FIO_LOCK_SUBLOCK

#FIO_STATIC_ALLOC_SAFE_CONCURRENCY_MAX

#FIO_LOG_LEVEL_NONE

#FIO_LOG_LEVEL_FATAL

#FIO_LOG_LEVEL_ERROR

#FIO_LOG_LEVEL_WARNING

#FIO_LOG_LEVEL_INFO

#`./fio-stl/000 core.h`

#`FIO_DEF_GET_FUNC_DEC`

#`FIO_DEF_GET_FUNC`

#`FIO_DEF_SET_FUNC_DEC`

#`FIO_DEF_SET_FUNC`

#`FIO_DEF_GETSET_FUNC`

#`FIO_DEF_GETSET_FUNC_DEC`

#`FIO_IFUNC_DEF_GET`

#`FIO_IFUNC_DEF_SET`

#`FIO_IFUNC_DEF_GETSET`

#`FIO_STATIC_ALLOC_DEF`

#`FIO_STATIC_SAFE_ALLOC_DEF`

#`FIO_UXXX_X64_DEF`

#`FIO_UXXX_X32_DEF`

#`FIO_UXXX_X16_DEF`

#`FIO_UXXX_X8_DEF`

#`FIO_NOOP`

#`FIO_NOOP_FN`

#`FIO_NOOP_FN_NAME`

#`FIO_VERSION_MAJOR`

#`FIO_VERSION_MINOR`

#`FIO_VERSION_PATCH`

#`FIO_VERSION_BUILD`

#`FIO_VERSION_STRING`

#`FIO_LEAK_COUNTER`

#`FIO_USE_THREAD_MUTEX`

#`FIO_UNALIGNED_ACCESS`

#`FIO_LIMIT_INTRINSIC_BUFFER`

#`FIO_MEMORY_INITIALIZE_ALLOCATIONS_DEFAULT`

#`FIO_MEM_PAGE_SIZE_LOG`

#`FIO_MAP_WARNING_BITSIZE`

#`FIO_ALIGN`

#`FIO_COMPILER_GUARD`

#`FIO_COMPILER_GUARD_INSTRUCTION`

#`FIO_UNALIGNED_MEMORY_ACCESS_ENABLED`

#`FIO_OS_POSIX`

#`FIO_OS_WIN`

#`FIO_KILL_SELF`

#`FIO_HAVE_UNIX_TOOLS`

#`FIO_SIZE_T_ERROR`

#`FIO_MAYBE_UNUSED`

#`FIO_SFUNC`

#`FIO_IFUNC`

#`FIO_WARN_UNUSED`

#`FIO_MIFN`

#`FIO_CONST`

#`FIO_PURE`

#`FIO_WEAK`

#`FIO_WEAK_VAR`

#`FIO_CONSTRUCTOR`

#`FIO_DESTRUCTOR`

#`FIO_LIKELY`

#`FIO_UNLIKELY`

#`FIO_PREFETCH`

#`FIO_PREFETCH_W`

#`FIO_PREFETCH_NT`

#`FIO_MACRO2STR`

#`FIO_NAME`

#`FIO_NAME2`

#`FIO_NAME_BL`

#`FIO_NAME_TEST`

#`FIO_PTR_MATH_LMASK`

#`FIO_PTR_MATH_RMASK`

#`FIO_PTR_MATH_ADD`

#`FIO_PTR_MATH_SUB`

#`FIO_PTR_FIELD_OFFSET`

#`FIO_PTR_FROM_FIELD`

#`FIO_THREAD_WAIT`

#`FIO_THREAD_YIELD`

#`FIO_THREAD_RESCHEDULE`

#`FIO_LOCK_INIT`

#`FIO_LOCK_SUBLOCK`

#`FIO_STATIC_ALLOC_SAFE_CONCURRENCY_MAX`

#`FIO_LOG_LEVEL_NONE`

#`FIO_LOG_LEVEL_FATAL`

#`FIO_LOG_LEVEL_ERROR`

#`FIO_LOG_LEVEL_WARNING`

#`FIO_LOG_LEVEL_INFO`

#`FIO_LOG_LEVEL_DEBUG`

#`FIO_LOG_LEVEL_SET`