evoasm 0.0.2.pre7

data/ext/evoasm_ext/evoasm-alloc.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#if defined (__unix__) || (defined (__APPLE__) && defined (__MACH__))
+#  if !defined(_DEFAULT_SOURCE)
+#    define _DEFAULT_SOURCE
+#  endif
+#  include <unistd.h>
+#  include <sys/mman.h>
+#  if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)
+#    define MAP_ANONYMOUS MAP_ANON
+#  endif
+#endif
+
+#include <string.h>
+#include <alloca.h>
+
+#if defined(_WIN32)
+#  include <malloc.h>
+#endif
+
+#include "evoasm-error.h"
+
+#ifdef __GNUC__
+#  define EVOASM_MALLOC_ATTRS  __attribute__((malloc))
+#  define EVOASM_CALLOC_ATTRS  __attribute__((malloc))
+#  define EVOASM_REALLOC_ATTRS __attribute__((malloc))
+#else
+#  define EVOASM_MALLOC_ATTRS
+#  define EVOASM_CALLOC_ATTRS
+#  define EVOASM_REALLOC_ATTRS
+#endif
+
+#if defined(_WIN32)
+#define EVOASM_MPROT_RW PAGE_READWRITE
+#define EVOASM_MPROT_RX PAGE_EXECUTE_READ
+#define EVOASM_MPROT_RWX PAGE_EXECUTE_READWRITE
+#elif defined(_POSIX_VERSION)
+#define EVOASM_MPROT_RW (PROT_READ|PROT_WRITE)
+#define EVOASM_MPROT_RX (PROT_READ|PROT_EXEC)
+#define EVOASM_MPROT_RWX (PROT_READ|PROT_WRITE|PROT_EXEC)
+#else
+#error
+#endif
+
+void *evoasm_malloc(size_t) EVOASM_MALLOC_ATTRS;
+void *evoasm_calloc(size_t, size_t) EVOASM_CALLOC_ATTRS;
+void *evoasm_realloc(void *, size_t) EVOASM_REALLOC_ATTRS;
+void evoasm_free(void *);
+
+void *evoasm_mmap(size_t size, void *p);
+evoasm_success evoasm_munmap(void *p, size_t size);
+evoasm_success evoasm_mprot(void *p, size_t size, int mode);
+long evoasm_page_size();
+
+#if defined(_WIN32)
+  #define evoasm_alloca(s) _malloca(s);
+#else
+  #define evoasm_alloca(s) alloca(s);
+#endif

data/ext/evoasm_ext/evoasm-arch.c

@@ -0,0 +1,44 @@
+#include "evoasm-arch.h"
+#include "evoasm-util.h"
+#include <string.h>
+#include <inttypes.h>
+
+EVOASM_DECL_LOG_TAG("arch")
+
+evoasm_success
+evoasm_inst_encode(evoasm_inst *inst, evoasm_arch *arch, evoasm_arch_param_val *param_vals, evoasm_bitmap *set_params) {
+  return inst->encode_func(arch, param_vals, set_params);
+}
+
+uint16_t
+evoasm_arch_insts(evoasm_arch *arch, const evoasm_inst **insts) {
+  return arch->cls->insts_func(arch, insts);
+}
+
+void
+evoasm_arch_reset(evoasm_arch *arch) {
+  arch->buf_start = EVOASM_ARCH_BUF_CAPA / 2;
+  arch->buf_end   = EVOASM_ARCH_BUF_CAPA / 2;
+}
+
+void
+evoasm_arch_init(evoasm_arch *arch, evoasm_arch_cls *cls) {
+  static evoasm_arch zero_arch = {0};
+  *arch = zero_arch;
+  evoasm_arch_reset(arch);
+  arch->cls = cls;
+}
+
+void
+evoasm_arch_destroy(evoasm_arch *arch) {
+}
+
+void
+evoasm_arch_save(evoasm_arch *arch, evoasm_buf *buf) {
+  uint8_t len = (uint8_t)(arch->buf_end - arch->buf_start);
+
+  memcpy(buf->data + buf->pos, arch->buf + arch->buf_start, len);
+  buf->pos += len;
+
+  evoasm_arch_reset(arch);
+}

data/ext/evoasm_ext/evoasm-arch.h

@@ -0,0 +1,161 @@
+#pragma once
+
+#include <stdint.h>
+#include "evoasm-error.h"
+#include "evoasm-param.h"
+#include "evoasm-buf.h"
+#include "evoasm-log.h"
+
+#define EVOASM_ARCH_BUF_CAPA 32
+#define EVOASM_ARCH_MAX_PARAMS 64
+
+typedef uint8_t evoasm_reg_id;
+#define EVOASM_REG_ID_MAX UINT8_MAX
+typedef uint16_t evoasm_inst_id;
+
+typedef enum {
+  EVOASM_OPERAND_SIZE_1,
+  EVOASM_OPERAND_SIZE_8,
+  EVOASM_OPERAND_SIZE_16,
+  EVOASM_OPERAND_SIZE_32,
+  EVOASM_OPERAND_SIZE_64,
+  EVOASM_OPERAND_SIZE_128,
+  EVOASM_OPERAND_SIZE_256,
+  EVOASM_OPERAND_SIZE_512,
+  EVOASM_N_OPERAND_SIZES,
+} evoasm_operand_size;
+
+#define EVOASM_OPERAND_SIZE_BITSIZE 3
+#define EVOASM_OPERAND_SIZE_BITSIZE_WITH_N 4
+
+struct evoasm_arch;
+struct evoasm_inst;
+
+typedef uint16_t (*evoasm_arch_insts_func)(struct evoasm_arch *arch, const struct evoasm_inst **insts);
+
+typedef enum {
+  EVOASM_ARCH_X64
+} evoasm_arch_id;
+
+typedef struct {
+  evoasm_arch_id id : 8;
+  uint16_t n_insts;
+  uint8_t n_params;
+  uint8_t max_inst_len;
+  evoasm_arch_insts_func insts_func;
+} evoasm_arch_cls;
+
+typedef enum {
+  EVOASM_ARCH_ERROR_CODE_NOT_ENCODABLE = EVOASM_N_ERROR_CODES,
+  EVOASM_ARCH_ERROR_CODE_MISSING_PARAM,
+  EVOASM_ARCH_ERROR_CODE_INVALID_ACCESS,
+  EVOASM_ARCH_ERROR_CODE_MISSING_FEATURE,
+} evoasm_arch_error_code;
+
+struct evoasm_arch;
+
+typedef struct {
+  struct evoasm_arch *arch;
+  uint8_t reg;
+  uint8_t param;
+  uint16_t inst;
+} evoasm_arch_error_data;
+
+_Static_assert(sizeof(evoasm_error_data) >= sizeof(evoasm_arch_error_data), "evoasm_arch_error_data exceeds evoasm_error_data size limit");
+
+typedef struct {
+  EVOASM_ERROR_HEADER
+  evoasm_arch_error_data data;
+} evoasm_arch_error;
+
+typedef struct evoasm_arch {
+  evoasm_arch_cls *cls;
+  uint8_t buf_end;
+  uint8_t buf_start;
+  uint8_t buf[EVOASM_ARCH_BUF_CAPA];
+  void *user_data;
+  /* must have a bit for every
+   * writable register    */
+  evoasm_bitmap128 acc;
+} evoasm_arch;
+
+typedef bool (*evoasm_inst_encode_func)(evoasm_arch *arch, evoasm_arch_param_val *param_vals, evoasm_bitmap *set_params);
+
+typedef struct evoasm_inst {
+  evoasm_inst_id id;
+  uint16_t params_len;
+  evoasm_arch_param *params;
+  evoasm_inst_encode_func encode_func;
+} evoasm_inst;
+
+uint16_t
+evoasm_arch_insts(evoasm_arch *arch, const evoasm_inst **insts);
+
+evoasm_success
+evoasm_inst_encode(evoasm_inst *inst, evoasm_arch *arch, evoasm_arch_param_val *param_vals, evoasm_bitmap *set_params);
+
+void
+evoasm_arch_reset(evoasm_arch *arch);
+
+void
+evoasm_arch_init(evoasm_arch *arch, evoasm_arch_cls *cls);
+
+void
+evoasm_arch_destroy(evoasm_arch *arch);
+
+void
+evoasm_arch_save(evoasm_arch *arch, evoasm_buf *buf);
+
+static inline void
+evoasm_arch_write8(evoasm_arch *arch, int64_t datum) {
+  uint8_t new_end = (uint8_t)(arch->buf_end + 1);
+  *((uint8_t *)(arch->buf + arch->buf_end)) = (uint8_t) datum;
+  arch->buf_end = new_end;
+}
+
+static inline void
+evoasm_arch_write16(evoasm_arch *arch, int64_t datum) {
+  uint8_t new_end = (uint8_t)(arch->buf_end + 2);
+  *((int16_t *)(arch->buf + arch->buf_end)) = (int16_t) datum;
+  arch->buf_end = new_end;
+}
+
+static inline void
+evoasm_arch_write32(evoasm_arch *arch, int64_t datum) {
+  uint8_t new_end = (uint8_t)(arch->buf_end + 4);
+  *((int32_t *)(arch->buf + arch->buf_end)) = (int32_t) datum;
+  arch->buf_end = new_end;
+}
+
+static inline void
+evoasm_arch_write64(evoasm_arch *arch, int64_t datum) {
+  uint8_t new_end = (uint8_t)(arch->buf_end + 8);
+  *((int64_t *)(arch->buf + arch->buf_end)) = (int64_t) datum;
+  arch->buf_end = new_end;
+}
+
+static inline void
+evoasm_arch_write_access(evoasm_arch *arch, evoasm_bitmap *acc, evoasm_reg_id reg) {
+  evoasm_bitmap_set(acc, (unsigned) reg);
+}
+
+static inline void
+evoasm_arch_undefined_access(evoasm_arch *arch, evoasm_bitmap *acc, evoasm_reg_id reg) {
+  evoasm_bitmap_unset(acc, (unsigned) reg);
+}
+
+static inline evoasm_success
+_evoasm_arch_read_access(evoasm_arch *arch, evoasm_bitmap *acc, evoasm_reg_id reg, evoasm_inst_id inst, const char *file, unsigned line) {
+  if(!evoasm_bitmap_get(acc, (unsigned) reg)) {
+    evoasm_arch_error_data error_data = {
+      .reg = (uint8_t) reg,
+      .inst = (uint16_t) inst,
+      .arch = arch
+    };
+    evoasm_set_error(EVOASM_ERROR_TYPE_ARCH, EVOASM_ARCH_ERROR_CODE_INVALID_ACCESS, &error_data, file, line, "read access violation");
+    return false;
+  }
+  return true;
+}
+
+#define evoasm_arch_read_access(arch, acc, reg, inst) _evoasm_arch_read_access(arch, acc, reg, inst, __FILE__, __LINE__)

data/ext/evoasm_ext/evoasm-bitmap.h

@@ -0,0 +1,114 @@
+#pragma once
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#define _EVOASM_BITMAP_INDEX_DECLS(key) \
+  unsigned size = sizeof(uint64_t) * 8;\
+  unsigned ary_idx = ((unsigned) key) / size;\
+  unsigned bit_idx = ((unsigned) key) % size;
+
+typedef struct {
+  uint64_t data[1];
+} evoasm_bitmap64;
+
+typedef struct {
+  uint64_t data[2];
+} evoasm_bitmap128;
+
+typedef struct {
+  uint64_t data[4];
+} evoasm_bitmap256;
+
+typedef struct {
+  uint64_t data[8];
+} evoasm_bitmap512;
+
+typedef struct {
+  uint64_t data[16];
+} evoasm_bitmap1024;
+
+typedef uint64_t evoasm_bitmap;
+
+static inline void
+evoasm_bitmap_set(evoasm_bitmap *bitmap, unsigned idx) {
+  _EVOASM_BITMAP_INDEX_DECLS(idx);
+  bitmap[ary_idx] |= (1ull << bit_idx);
+}
+
+static inline void
+evoasm_bitmap_unset(evoasm_bitmap *bitmap, unsigned idx) {
+  _EVOASM_BITMAP_INDEX_DECLS(idx);
+  /* unset values must be 0*/
+  bitmap[ary_idx] &= ~(1ull << bit_idx);
+}
+
+static inline bool
+evoasm_bitmap_get(evoasm_bitmap *bitmap, unsigned idx) {
+  _EVOASM_BITMAP_INDEX_DECLS(idx);
+  return !!(bitmap[ary_idx] & (1ull << bit_idx));
+}
+
+
+#define _EVOASM_BITMAP_DECL_UNOP(name, width, op) \
+  static inline void evoasm_bitmap ## width ## _ ## name (evoasm_bitmap##width *bitmap, evoasm_bitmap##width *result) { \
+    unsigned i;\
+    for(i = 0; i < width / 64; i++) {\
+      result->data[i] = op bitmap->data[i];\
+    }\
+  }
+
+#define _EVOASM_BITMAP_DECL_BINOP(name, width, op) \
+  static inline void evoasm_bitmap ## width ## _ ## name (evoasm_bitmap##width *bitmap1, evoasm_bitmap##width *bitmap2, evoasm_bitmap##width *result) { \
+    unsigned i;\
+    for(i = 0; i < width / 64; i++) {\
+      result->data[i] = bitmap1->data[i] op bitmap2->data[i];\
+    }\
+  }
+
+#define _EVOASM_BITMAP_DECL_EQL(width) \
+  static inline bool evoasm_bitmap ## width ## _ ## eql (evoasm_bitmap##width *bitmap1, evoasm_bitmap##width *bitmap2) { \
+    unsigned i;\
+    for(i = 0; i < width / 64; i++) {\
+      if(bitmap1->data[i] != bitmap2->data[i]) return false;\
+    } \
+    return true;\
+  }
+
+
+#ifdef __GNUC__
+#  define _EVOASM_BITMAP_DECL_POPCOUNT(width) \
+    static inline unsigned evoasm_bitmap ## width ## _ ## popcount (evoasm_bitmap##width *bitmap) { \
+      unsigned c = 0, i;\
+      for(i = 0; i < width / 64; i++) {\
+        c += (unsigned) __builtin_popcountll(bitmap->data[i]);\
+      } \
+      return c;\
+    }
+#else
+#  define _EVOASM_BITMAP_DECL_POPCOUNT(width) \
+    static inline unsigned evoasm_bitmap ## width ## _ ## popcount (evoasm_bitmap##width *bitmap) { \
+      unsigned c = 0, i;\
+      for(i = 0; i < width / 64; i++) {\
+        uint64_t x = bitmap->data[i]; \
+        for(; x > 0; x &= x - 1) c++;\
+      } \
+      return c;\
+    }
+#endif
+
+_EVOASM_BITMAP_DECL_UNOP(not, 128, ~)
+_EVOASM_BITMAP_DECL_BINOP(and, 128, &)
+_EVOASM_BITMAP_DECL_BINOP(or, 128, |)
+_EVOASM_BITMAP_DECL_BINOP(andn, 128, &~)
+_EVOASM_BITMAP_DECL_POPCOUNT(128)
+_EVOASM_BITMAP_DECL_EQL(128)
+
+_EVOASM_BITMAP_DECL_UNOP(not, 64, ~)
+_EVOASM_BITMAP_DECL_BINOP(and, 64, &)
+_EVOASM_BITMAP_DECL_BINOP(or, 64, |)
+_EVOASM_BITMAP_DECL_POPCOUNT(64)
+_EVOASM_BITMAP_DECL_EQL(64)
+
+
+_EVOASM_BITMAP_DECL_EQL(1024)

data/ext/evoasm_ext/evoasm-buf.c

@@ -0,0 +1,130 @@
+#include <string.h>
+
+#include "evoasm-buf.h"
+#include "evoasm-util.h"
+#include "evoasm-error.h"
+#include "evoasm-alloc.h"
+#include "evoasm-log.h"
+
+EVOASM_DECL_LOG_TAG("buf")
+
+static evoasm_success
+evoasm_buf_init_mmap(evoasm_buf *buf, size_t size) {
+  uint8_t *mem;
+
+  //size = EVOASM_ALIGN_UP(size, evoasm_page_size());
+  mem = evoasm_mmap(size, NULL);
+
+  if(mem) {
+    buf->capa = size;
+    buf->data = mem;
+    buf->pos = 0;
+    return true;
+  }
+  else {
+    return false;
+  }
+}
+
+static evoasm_success
+evoasm_buf_init_malloc(evoasm_buf *buf, size_t size) {
+  uint8_t *mem;
+
+  mem = malloc(size);
+
+  if(mem) {
+    buf->capa = size;
+    buf->data = mem;
+    buf->pos = 0;
+    return true;
+  }
+  else {
+    return false;
+  }
+}
+
+evoasm_success
+evoasm_buf_init(evoasm_buf *buf, evoasm_buf_type buf_type, size_t size)
+{
+  buf->type = buf_type;
+  switch(buf_type) {
+    case EVOASM_BUF_TYPE_MMAP: return evoasm_buf_init_mmap(buf, size);
+    case EVOASM_BUF_TYPE_MALLOC: return evoasm_buf_init_malloc(buf, size);
+    default: evoasm_assert_not_reached();
+  }
+}
+
+static evoasm_success
+evoasm_buf_destroy_mmap(evoasm_buf *buf) {
+  return evoasm_munmap(buf->data, buf->capa);
+}
+
+static evoasm_success
+evoasm_buf_destroy_malloc(evoasm_buf *buf) {
+  evoasm_free(buf->data);
+  return true;
+}
+
+evoasm_success
+evoasm_buf_destroy(evoasm_buf *buf)
+{
+  switch(buf->type) {
+    case EVOASM_BUF_TYPE_MMAP: return evoasm_buf_destroy_mmap(buf);
+    case EVOASM_BUF_TYPE_MALLOC: return evoasm_buf_destroy_malloc(buf);
+    default: evoasm_assert_not_reached();
+  }
+}
+
+void
+evoasm_buf_reset(evoasm_buf *buf) {
+  memset(buf->data, 0, buf->pos);
+  buf->pos = 0;
+}
+
+evoasm_success
+evoasm_buf_protect(evoasm_buf *buf, int mode) {
+  return evoasm_mprot(buf->data, buf->capa, mode);
+}
+
+intptr_t
+evoasm_buf_exec(evoasm_buf *buf) {
+  intptr_t (*func)(void);
+  intptr_t result = 0;
+  *(void **) (&func) = buf->data;
+  result = func();
+  return result;
+}
+
+void
+evoasm_buf_log(evoasm_buf *buf, evoasm_log_level log_level) {
+  unsigned i;
+
+  evoasm_log(log_level, EVOASM_LOG_TAG, "Evoasm::Buffer: capa: %zu, pos: %zu, addr: %p\n", buf->capa, buf->pos, (void *) buf->data);
+  for(i = 0; i < buf->pos; i++)
+  {
+    if (i > 0) evoasm_log(log_level, EVOASM_LOG_TAG, "   ");
+    evoasm_log(log_level, EVOASM_LOG_TAG, " %02X ", buf->data[i]);
+  }
+  evoasm_log(log_level, EVOASM_LOG_TAG, " \n ");
+}
+
+size_t
+evoasm_buf_append(evoasm_buf * restrict dst, evoasm_buf * restrict src) {
+  size_t free = dst->capa - dst->pos;
+  if(src->pos > free) {
+    evoasm_set_error(EVOASM_ERROR_TYPE_ARGUMENT, EVOASM_ERROR_CODE_NONE,
+      NULL, "buffer does not fit (need %zu bytes but only %zu free)", src->pos, free);
+    return src->pos - (dst->capa - dst->pos);
+  }
+  memcpy(dst->data + dst->pos, src->data, src->pos);
+  dst->pos += src->pos;
+  return 0;
+}
+
+evoasm_success
+evoasm_buf_clone(evoasm_buf * restrict buf, evoasm_buf * restrict cloned_buf) {
+  if(!evoasm_buf_init(cloned_buf, buf->type, buf->capa)) {
+    return false;
+  }
+  return evoasm_buf_append(cloned_buf, buf) == 0;
+}

data/ext/evoasm_ext/evoasm-buf.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "evoasm-error.h"
+#include "evoasm-log.h"
+
+typedef enum {
+  EVOASM_BUF_TYPE_MMAP,
+  EVOASM_BUF_TYPE_MALLOC,
+  EVOASM_N_BUF_TYPES
+} evoasm_buf_type;
+
+typedef struct {
+    size_t  capa;
+    size_t  pos;
+    evoasm_buf_type type : 2;
+    uint8_t *data;
+} evoasm_buf;
+
+evoasm_success
+evoasm_buf_init(evoasm_buf *buf, evoasm_buf_type buf_type, size_t size);
+
+evoasm_success
+evoasm_buf_destroy(evoasm_buf *buf);
+
+void
+evoasm_buf_reset(evoasm_buf *buf);
+
+size_t
+evoasm_buf_append(evoasm_buf * restrict dst, evoasm_buf * restrict src);
+
+evoasm_success
+evoasm_buf_protect(evoasm_buf *buf, int mode);
+
+intptr_t
+evoasm_buf_exec(evoasm_buf *buf);
+
+void
+evoasm_buf_log(evoasm_buf *buf, evoasm_log_level log_level);
+
+evoasm_success
+evoasm_buf_clone(evoasm_buf * restrict buf, evoasm_buf * restrict cloned_buf);
+

data/ext/evoasm_ext/evoasm-error.c

@@ -0,0 +1,31 @@
+#include "evoasm-error.h"
+
+_Thread_local evoasm_error evoasm_last_error;
+
+void
+evoasm_error_setv(evoasm_error *error, unsigned error_type, unsigned error_code,
+                 void *error_data, const char *file,
+                 unsigned line, const char *format, va_list args) {
+
+  error->type = (uint16_t) error_type;
+  error->code = (uint16_t) error_code;
+  error->line = line;
+  strncpy(error->filename, file, EVOASM_ERROR_MAX_FILENAME_LEN);
+  vsnprintf(error->msg, EVOASM_ERROR_MAX_MSG_LEN, format, args);
+
+  if(error_data != NULL) {
+    memcpy(&error->data, error_data, sizeof(evoasm_error_data));
+  }
+}
+
+void
+evoasm_error_set(evoasm_error *error, unsigned error_type, unsigned error_code,
+                void *error_data, const char *file,
+                unsigned line, const char *format, ...) {
+  va_list args;
+  va_start(args, format);
+  evoasm_error_setv(error, error_type, error_code,
+                   error_data, file, line,
+                   format, args);
+  va_end(args);
+}

data/ext/evoasm_ext/evoasm-error.h

@@ -0,0 +1,75 @@
+#pragma once
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+#include <stdarg.h>
+#include <setjmp.h>
+
+#include "evoasm-util.h"
+
+#define EVOASM_ERROR_MAX_FILENAME_LEN 128
+#define EVOASM_ERROR_MAX_MSG_LEN 128
+
+#define EVOASM_ERROR_HEADER \
+  uint16_t type; \
+  uint16_t code; \
+  uint32_t line; \
+  char filename[EVOASM_ERROR_MAX_FILENAME_LEN]; \
+  char msg[EVOASM_ERROR_MAX_MSG_LEN];
+
+typedef enum {
+  EVOASM_ERROR_CODE_NONE,
+  EVOASM_N_ERROR_CODES
+} evoasm_error_code;
+
+typedef enum {
+  EVOASM_ERROR_TYPE_INVALID,
+  EVOASM_ERROR_TYPE_ARGUMENT,
+  EVOASM_ERROR_TYPE_MEMORY,
+  EVOASM_ERROR_TYPE_ARCH,
+  EVOASM_ERROR_TYPE_GRAPH,
+} evoasm_error_type;
+
+typedef struct {
+  uint8_t data[64];
+} evoasm_error_data;
+
+typedef struct {
+  EVOASM_ERROR_HEADER
+  evoasm_error_data data;
+} evoasm_error;
+
+
+void
+evoasm_error_setv(evoasm_error *error, unsigned error_type, unsigned error_code,
+                 void *error_data, const char *file,
+                 unsigned line, const char *format, va_list args);
+
+void
+evoasm_error_set(evoasm_error *error, unsigned error_type, unsigned error_code,
+                void *error_data, const char *file,
+                unsigned line, const char *format, ...);
+
+
+extern _Thread_local evoasm_error evoasm_last_error;
+
+#define EVOASM_TRY(label, func, ...) \
+  do { if(!func(__VA_ARGS__)) {goto label;} } while(0)
+
+#define evoasm_success evoasm_check_return bool
+
+#define evoasm_set_error(type, code, data, ...) \
+  evoasm_error_set(&evoasm_last_error, (type), (code), (data),\
+                   __FILE__, __LINE__, __VA_ARGS__)
+
+#define evoasm_assert_not_reached() \
+  evoasm_assert_not_reached_full(__FILE__, __LINE__)
+
+static inline _Noreturn void evoasm_assert_not_reached_full(const char *file, unsigned line) {
+  fprintf(stderr, "FATAL: %s:%d should not be reached\n", file, line);
+  abort();
+}