evoasm 0.0.2.pre7

data/ext/evoasm_ext/evoasm-free-list.c.tmpl

@@ -0,0 +1,121 @@
+#include <assert.h>
+#include <errno.h>
+
+#include "$-s.h"
+#include "evoasm-alloc.h"
+
+$includes
+
+void
+$s_clear($s *free_list, $s_index start, $s_index end) {
+  for($s_index i = start; i < end - 1; i++) {
+    $S_DATA(free_list)[i].free = true;
+    $S_DATA(free_list)[i].next_free = i + 1;
+  }
+  $S_DATA(free_list)[end - 1].next_free = $S_NULL_IDX;
+  $S_DATA(free_list)[end - 1].free = true;
+
+  free_list->last_free = end - 1;
+}
+
+
+$e *
+$s_data($s *free_list) {
+ return $S_DATA(free_list);
+}
+
+evoasm_success
+$s_init($s *free_list, $s_index capa) {
+
+#if $embed > 0
+  free_list->data = NULL;
+  free_list->capa = EVOASM_SEQ_EMBED_N;
+#else
+  size_t size = sizeof($e) * capa;
+  free_list->data = evoasm_malloc(size);
+  if(free_list->data == NULL) {
+    evoasm_set_error(EVOASM_ERROR_TYPE_MEMORY, EVOASM_ERROR_CODE_NONE,
+        NULL, "Allocationg buffer of size %zu failed: %s", size, strerror(errno));
+    return false;
+  }
+  free_list->capa = capa;
+#endif
+
+  free_list->first_free = 0;
+  free_list->len = 0;
+
+  $s_clear(free_list, 0, free_list->capa);
+  return true;
+}
+
+evoasm_success
+_$s_grow($s *free_list) {
+  $s_index new_capa = free_list->capa + free_list->capa / 2;
+
+#if $embed > 0
+  if(free_list->data == NULL) {
+    free_list->data = malloc(sizeof($e) * new_capa);
+    memcpy(free_list->data, free_list->_data, sizeof($e) * free_list->capa);
+    goto update;
+  }
+#endif
+
+  {
+    size_t size = sizeof($e) * new_capa;
+    $e *new_data = evoasm_realloc(free_list->data, size);
+
+    if(EVOASM_UNLIKELY(new_data == NULL)) {
+      evoasm_set_error(EVOASM_ERROR_TYPE_MEMORY, EVOASM_ERROR_CODE_NONE,
+          NULL, "Reallocationg buffer of size %zu failed: %s", size, strerror(errno));
+      return false;
+    }
+  }
+update:
+  free_list->first_free = free_list->capa;
+  $s_clear(free_list, free_list->capa, new_capa);
+  free_list->capa = new_capa;
+  return true;
+}
+
+$e *
+$s_delete($s *free_list, $e *e) {
+  $s_index idx = $s_index(free_list, e);
+
+  e->next_free = free_list->first_free;
+  e->free = true;
+
+  // only free slot
+  if(free_list->last_free == $S_NULL_IDX) {
+    free_list->last_free = idx;
+  }
+
+  free_list->first_free = idx;
+  free_list->len--;
+  return e;
+}
+
+bool
+$s_eql($s *a, $s *b) {
+  $eql
+}
+
+bool
+$s_find($s *free_list, $e *value, $s_index *index) {
+
+  if(free_list->len == 0) return false;
+
+  for($s_index i = 0; i < free_list->capa; i++) {
+    if(!$S_DATA(free_list)[i].free) {
+      if($s_cmp(value, &$S_DATA(free_list)[i])) {
+        if(index != NULL) *index = i;
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+void
+$s_destroy($s *free_list) {
+  evoasm_free(free_list->data);
+}

data/ext/evoasm_ext/evoasm-free-list.h.tmpl

@@ -0,0 +1,86 @@
+#pragma once
+
+#include <stdint.h>
+#include "evoasm-error.h"
+
+$includes
+
+#if $embed > 0
+#  define $S_DATA(free_list) (free_list->data != NULL ? free_list->data : free_list->_data)
+#else
+#  define $S_DATA(free_list) (free_list->data)
+#endif
+
+#define $S_NULL_IDX ((uint$w_t)-1)
+
+typedef uint$w_t $s_index;
+
+typedef struct $s {
+  $s_index capa;
+  $s_index len;
+  $s_index first_free;
+  $s_index last_free;
+  $e *data;
+
+#if $embed > 0
+  $e _data[$embed];
+#endif
+} $s;
+
+static inline uint32_t
+$s_get_index($s *free_list, $e *e) {
+  return (uint32_t)(e - $S_DATA(free_list));
+}
+
+static inline $e *
+$s_get($s *free_list, $s_index index) {
+#if 0
+  if(index >= free_list->capa) {
+    return NULL;
+  }
+  return $S_DATA(free_list)[index].free ? NULL : &$S_DATA(free_list)[index];
+#endif
+  return &$S_DATA(free_list)[index];
+}
+
+evoasm_success _$s_grow($s *free_list);
+
+static inline evoasm_success
+$s_push($s *free_list, $e **ee, $s_index *ridx) {
+  if(free_list->first_free == $S_NULL_IDX) {
+    if(!_$s_grow(free_list)) {
+      return false;
+    }
+  }
+
+  {
+    $e *entry = &$S_DATA(free_list)[free_list->first_free];
+
+    $s_index idx = free_list->first_free;
+
+    // used up last free slot
+    if(entry->next_free == $S_NULL_IDX){
+      assert(idx == free_list->last_free);
+      free_list->last_free = $S_NULL_IDX;
+    }
+
+    free_list->first_free = entry->next_free;
+
+    entry->free = false;
+    entry->next_free = $S_NULL_IDX;
+
+    free_list->len++;
+
+    *ee = entry;
+    if(ridx) {
+      *ridx = idx;
+    }
+    return true;
+  }
+}
+
+void $s_clear($s *free_list, uint32_t start, uint32_t end);
+evoasm_success $s_init($s *free_list, $s_index capa);
+$e *$s_delete($s *free_list, $e *e);
+void $s_destroy($s *free_list);
+$e * $s_data($s *free_list);

data/ext/evoasm_ext/evoasm-log.c

@@ -0,0 +1,108 @@
+#define _DEFAULT_SOURCE
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <alloca.h>
+
+#ifdef _WIN32
+#include <io.h>
+#define isatty _isatty
+#else
+#include <unistd.h>
+#endif
+
+#include "evoasm-log.h"
+#include "evoasm-alloc.h"
+
+evoasm_log_level evoasm_min_log_level = EVOASM_LOG_LEVEL_WARN;
+FILE *          evoasm_log_file;
+
+static const char *const log_levels[EVOASM_N_LOG_LEVELS] = {
+  "TRACE",
+  "DEBUG",
+  "INFO",
+  "WARN",
+  "ERROR",
+  "FATAL"
+};
+
+static const char *const log_colors[EVOASM_N_LOG_LEVELS] = {
+  "\x1b[30;1m",
+  "\x1b[30;1m",
+  "\x1b[32;1m",
+  "\x1b[33;1m",
+  "\x1b[31;1m",
+  "\x1b[31;1m",
+};
+
+
+void
+evoasm_log(evoasm_log_level level, const char *tag, const char *format, ...)
+{
+  if(level < evoasm_min_log_level) return;
+
+  va_list args;
+
+  static const char *prefix = "evoasm:";
+  static const char *sep1 = ":";
+  static const char *sep2 = ": ";
+  static const char *color_reset = "\x1b[0m";
+  bool is_tty = isatty(fileno(evoasm_log_file));
+
+  size_t prefix_len = strlen(prefix);
+  size_t color_len = is_tty ? strlen(log_colors[level]) : 0;
+  size_t level_len = strlen(log_levels[level]);
+  size_t color_reset_len = is_tty ? strlen(color_reset) : 0;
+  size_t tag_len = strlen(tag);
+  size_t sep1_len = strlen(sep1);
+  size_t sep2_len = strlen(sep2);
+  bool print_prefix = format[0] != ' ';
+  const char *format_ = format + (print_prefix ? 0 : 1);
+  size_t format_len = strlen(format_);
+  bool print_new_line = format_[format_len - 1] != ' ';
+  if(!print_new_line) format_len--;
+  char *full_format = evoasm_alloca(prefix_len
+                             + color_len
+                             + level_len
+                             + color_reset_len
+                             + sep1_len
+                             + tag_len
+                             + sep2_len
+                             + format_len
+                             + 2);
+  size_t i = 0;
+
+
+
+#define __CPY(s, l) \
+  memcpy(full_format + i, (s), (l)); i+= (l);
+
+  if(print_prefix) {
+    __CPY(prefix, prefix_len)
+    __CPY(log_colors[level], color_len)
+    __CPY(log_levels[level], level_len)
+    __CPY(color_reset, color_reset_len)
+    __CPY(sep1, sep1_len)
+    __CPY(tag, tag_len)
+    __CPY(sep2, sep2_len)
+  }
+  __CPY(format_, format_len)
+
+#undef __CPY
+
+  if(print_new_line) {
+    full_format[i] = '\n'; i++;
+  }
+  full_format[i] = '\0'; i++;
+
+  //fprintf(stderr, "printing '%s'\n", full_format);
+  va_start(args, format);
+  vfprintf(evoasm_log_file, full_format, args);
+  va_end(args);
+}
+
+

data/ext/evoasm_ext/evoasm-log.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+
+typedef uint8_t evoasm_log_level;
+#define EVOASM_LOG_LEVEL_TRACE   0
+#define EVOASM_LOG_LEVEL_DEBUG   1
+#define EVOASM_LOG_LEVEL_INFO    2
+#define EVOASM_LOG_LEVEL_WARN    3
+#define EVOASM_LOG_LEVEL_ERROR   4
+#define EVOASM_LOG_LEVEL_FATAL   5
+#define EVOASM_N_LOG_LEVELS      6
+
+#ifndef EVOASM_MIN_LOG_LEVEL
+#  define EVOASM_MIN_LOG_LEVEL EVOASM_LOG_LEVEL_INFO
+#endif
+
+extern evoasm_log_level evoasm_min_log_level;
+extern FILE *          evoasm_log_file;
+
+#ifdef __GNUC__
+#  define EVOASM_LOG_ATTRS __attribute__ ((format(printf, 3, 4)))
+#else
+#  define EVOASM_LOG_ATTRS
+#endif
+
+#define EVOASM_DECL_LOG_TAG(tag) evoasm_used static const char *_evoasm_log_tag = tag;
+#define EVOASM_LOG_TAG _evoasm_log_tag
+
+void
+evoasm_log(evoasm_log_level level, const char *tag, const char *format, ...) EVOASM_LOG_ATTRS;
+
+#if EVOASM_MIN_LOG_LEVEL <= EVOASM_LOG_LEVEL_TRACE
+#  define evoasm_trace(...) evoasm_log(EVOASM_LOG_LEVEL_TRACE, EVOASM_LOG_TAG, __VA_ARGS__)
+#else
+#  define evoasm_trace(...)
+#endif
+
+#if EVOASM_MIN_LOG_LEVEL <= EVOASM_LOG_LEVEL_DEBUG
+#  define evoasm_debug(...) evoasm_log(EVOASM_LOG_LEVEL_DEBUG, EVOASM_LOG_TAG, __VA_ARGS__)
+#else
+#  define evoasm_debug(...)
+#endif
+
+#if EVOASM_MIN_LOG_LEVEL <= EVOASM_LOG_LEVEL_INFO
+#  define evoasm_info(...) evoasm_log(EVOASM_LOG_LEVEL_INFO, EVOASM_LOG_TAG, __VA_ARGS__)
+#else
+#  define evoasm_info(...)
+#endif
+
+#if EVOASM_MIN_LOG_LEVEL <= EVOASM_LOG_LEVEL_WARN
+#  define evoasm_warn(...) evoasm_log(EVOASM_LOG_LEVEL_WARN, EVOASM_LOG_TAG, __VA_ARGS__)
+#else
+#  define evoasm_warn(...)
+#endif
+
+#if EVOASM_MIN_LOG_LEVEL <= EVOASM_LOG_LEVEL_ERROR
+#  define evoasm_error(...) evoasm_log(EVOASM_LOG_LEVEL_ERROR, EVOASM_LOG_TAG, __VA_ARGS__)
+#else
+#  define evoasm_error(...)
+#endif
+
+#if EVOASM_MIN_LOG_LEVEL <= EVOASM_LOG_LEVEL_FATAL
+#  define evoasm_fatal(...) evoasm_log(EVOASM_LOG_LEVEL_FATAL, EVOASM_LOG_TAG, __VA_ARGS__)
+#else
+#  define evoasm_fatal(...)
+#endif

data/ext/evoasm_ext/evoasm-misc.c

@@ -0,0 +1,23 @@
+#include "evoasm.h"
+#include "evoasm-util.h"
+
+//static const char *_evoasm_log_tag = "general";
+
+void
+evoasm_prng64_init(struct evoasm_prng64 *prng, evoasm_prng64_seed *seed) {
+  prng->s = *seed;
+}
+
+void
+evoasm_prng64_destroy(struct evoasm_prng64 *prng) {
+}
+
+void
+evoasm_prng32_init(struct evoasm_prng32 *prng, evoasm_prng32_seed *seed) {
+  prng->s = *seed;
+}
+
+void
+evoasm_prng32_destroy(struct evoasm_prng32 *prng) {
+}
+

data/ext/evoasm_ext/evoasm-misc.h

@@ -0,0 +1,282 @@
+#pragma once
+
+#include "evoasm-error.h"
+
+#define _EVOASM_DOMAIN_HEADER \
+  evoasm_domain_type type: 8; \
+  unsigned index         :24;
+
+#define _EVOASM_ENUM_HEADER \
+  _EVOASM_DOMAIN_HEADER \
+  uint16_t len;
+
+#define _EVOASM_DECL_ENUM_TYPE(l) \
+  typedef struct { \
+    _EVOASM_ENUM_HEADER \
+    int64_t vals[l]; \
+  } evoasm_enum ## l;
+
+
+#define EVOASM_ENUM_MAX_LEN 32
+
+#define EVOASM_ENUM_VALS_SIZE(len) ((size_t)(len) * sizeof(int64_t))
+#define EVOASM_ENUM_SIZE(len) (sizeof(evoasm_enum) + EVOASM_ENUM_VALS_SIZE(len))
+
+typedef enum {
+  EVOASM_DOMAIN_TYPE_ENUM,
+  EVOASM_DOMAIN_TYPE_INTERVAL,
+  EVOASM_DOMAIN_TYPE_INTERVAL64,
+  EVOASM_N_DOMAIN_TYPES
+} evoasm_domain_type;
+
+typedef struct {
+  _EVOASM_DOMAIN_HEADER
+  int64_t pad[EVOASM_ENUM_MAX_LEN];
+} evoasm_domain;
+
+typedef struct {
+  _EVOASM_DOMAIN_HEADER
+  int64_t min;
+  int64_t max;
+} evoasm_interval;
+
+typedef struct {
+  _EVOASM_ENUM_HEADER
+  int64_t vals[];
+} evoasm_enum;
+
+_EVOASM_DECL_ENUM_TYPE(2)
+_EVOASM_DECL_ENUM_TYPE(3)
+_EVOASM_DECL_ENUM_TYPE(4)
+_EVOASM_DECL_ENUM_TYPE(8)
+_EVOASM_DECL_ENUM_TYPE(11)
+_EVOASM_DECL_ENUM_TYPE(16)
+
+typedef struct {
+  uint64_t data[16];
+} evoasm_prng64_seed;
+
+typedef struct {
+  uint32_t data[4];
+} evoasm_prng32_seed;
+
+typedef struct evoasm_prng64 {
+  /* xorshift1024star */
+  evoasm_prng64_seed s;
+  int p;
+} evoasm_prng64;
+
+typedef struct evoasm_prng32 {
+  /* xorshift128 */
+  evoasm_prng32_seed s;
+  int p;
+} evoasm_prng32;
+
+void
+evoasm_prng64_init(struct evoasm_prng64 *prng, evoasm_prng64_seed *seed);
+
+void
+evoasm_prng64_destroy(struct evoasm_prng64 *prng);
+
+void
+evoasm_prng32_init(struct evoasm_prng32 *prng, evoasm_prng32_seed *seed);
+
+void
+evoasm_prng32_destroy(struct evoasm_prng32 *prng);
+
+/* From: https://en.wikipedia.org/wiki/Xorshift */
+static inline uint64_t
+evoasm_prng64_rand(struct evoasm_prng64 *prng) {
+  uint64_t *s = prng->s.data;
+  const uint64_t s0 = s[prng->p];
+  uint64_t s1 = s[prng->p = (prng->p + 1) & 15];
+  s1 ^= s1 << 31; // a
+  s[prng->p] = s1 ^ s0 ^ (s1 >> 11) ^ (s0 >> 30); // b,c
+  return s[prng->p] * UINT64_C(1181783497276652981);
+}
+
+static inline uint32_t
+evoasm_prng32_rand(struct evoasm_prng32 *prng) {
+  uint32_t *s = prng->s.data;
+  uint32_t t = s[0];
+  t ^= t << 11;
+  t ^= t >> 8;
+  s[0] = s[1]; s[1] = s[2]; s[2] = s[3];
+  s[3] ^= s[3] >> 19;
+  s[3] ^= t;
+  return s[3];
+}
+
+static inline int64_t
+evoasm_prng64_rand_between(struct evoasm_prng64 *prng, int64_t min, int64_t max) {
+  return min + (int64_t)(evoasm_prng64_rand(prng) % (uint64_t)(max - min + 1ll));
+}
+
+static inline int32_t
+evoasm_prng32_rand_between(struct evoasm_prng32 *prng, int32_t min, int32_t max) {
+  return min + (int32_t)(evoasm_prng32_rand(prng) % (uint32_t)(max - min + 1ll));
+}
+
+static inline int64_t
+evoasm_domain_rand(evoasm_domain *domain, struct evoasm_prng64 *prng) {
+  switch(domain->type) {
+    case EVOASM_DOMAIN_TYPE_INTERVAL: {
+      evoasm_interval *interval = (evoasm_interval *) domain;
+      return evoasm_prng64_rand_between(prng, interval->min, interval->max);
+    }
+    case EVOASM_DOMAIN_TYPE_INTERVAL64: {
+      return (int64_t) evoasm_prng64_rand(prng);
+    }
+    case EVOASM_DOMAIN_TYPE_ENUM: {
+      evoasm_enum *enm = (evoasm_enum *) domain;
+      return enm->vals[evoasm_prng64_rand(prng) % enm->len];
+    }
+    default:
+      evoasm_assert_not_reached();
+      return 0;
+  }
+}
+
+static inline size_t
+evoasm_domain_size(evoasm_domain *domain) {
+  switch(domain->type){
+    case EVOASM_DOMAIN_TYPE_INTERVAL:
+    case EVOASM_DOMAIN_TYPE_INTERVAL64: return sizeof(evoasm_interval);
+    case EVOASM_DOMAIN_TYPE_ENUM: return EVOASM_ENUM_SIZE(((evoasm_enum *) domain)->len);
+    default:
+      evoasm_assert_not_reached();
+      return 0;
+  }
+}
+
+static inline void
+evoasm_domain_clone(evoasm_domain * restrict domain, evoasm_domain * restrict domain_dst) {
+  domain_dst->type = domain->type;
+
+  switch(domain->type) {
+    case EVOASM_DOMAIN_TYPE_INTERVAL:
+    case EVOASM_DOMAIN_TYPE_INTERVAL64: {
+      evoasm_interval *interval = (evoasm_interval *) domain;
+      evoasm_interval *interval_dst = (evoasm_interval *) domain_dst;
+      interval_dst->min = interval->min;
+      interval_dst->max = interval->max;
+      break;
+    }
+    case EVOASM_DOMAIN_TYPE_ENUM: {
+      evoasm_enum *enm = (evoasm_enum *) domain;
+      evoasm_enum *enm_dst = (evoasm_enum *) domain_dst;
+      enm_dst->len = enm->len;
+      memcpy(enm_dst->vals, enm->vals, EVOASM_ENUM_VALS_SIZE(enm->len));
+      break;
+    }
+    default: evoasm_assert_not_reached();
+  }
+}
+
+
+static inline void
+evoasm_domain_intersect(evoasm_domain * restrict domain1, evoasm_domain * restrict domain2, evoasm_domain * restrict domain_dst) {
+
+#define _EVOASM_DOMAIN_TYPES2(type_a, type_b) (int)(((type_a) << 8) | (type_b))
+
+  switch(_EVOASM_DOMAIN_TYPES2(domain1->type, domain2->type)) {
+    case _EVOASM_DOMAIN_TYPES2(EVOASM_DOMAIN_TYPE_INTERVAL, EVOASM_DOMAIN_TYPE_INTERVAL64):
+    case _EVOASM_DOMAIN_TYPES2(EVOASM_DOMAIN_TYPE_INTERVAL, EVOASM_DOMAIN_TYPE_INTERVAL):
+    case _EVOASM_DOMAIN_TYPES2(EVOASM_DOMAIN_TYPE_INTERVAL64, EVOASM_DOMAIN_TYPE_INTERVAL64):
+    case _EVOASM_DOMAIN_TYPES2(EVOASM_DOMAIN_TYPE_INTERVAL64, EVOASM_DOMAIN_TYPE_INTERVAL): {
+      evoasm_interval *interval1 = (evoasm_interval *) domain1;
+      evoasm_interval *interval2 = (evoasm_interval *) domain2;
+      evoasm_interval *interval_dst = (evoasm_interval *) domain_dst;
+
+      interval_dst->min = EVOASM_MAX(interval1->min, interval2->min);
+      interval_dst->max = EVOASM_MIN(interval1->max, interval2->max);
+      break;
+    }
+    case _EVOASM_DOMAIN_TYPES2(EVOASM_DOMAIN_TYPE_ENUM, EVOASM_DOMAIN_TYPE_ENUM): {
+      unsigned i = 0, j = 0;
+      evoasm_enum *enum1 = (evoasm_enum *) domain1;
+      evoasm_enum *enum2 = (evoasm_enum *) domain2;
+      evoasm_enum *enum_dst = (evoasm_enum *) domain_dst;
+
+      enum_dst->len = 0;
+      /*
+       * NOTE: vals are sorted (INC)
+       */
+
+      while(i < enum1->len && j < enum2->len) {
+        int64_t v1 = enum1->vals[i];
+        int64_t v2 = enum2->vals[j];
+
+        if(v1 < v2) {
+          i++;
+        }
+        else if(v2 < v1) {
+          j++;
+        }
+        else {
+          enum_dst->vals[enum_dst->len++] = v1;
+          i++;
+          j++;
+        }
+      }
+      break;
+    }
+    {
+      evoasm_enum *enm;
+      evoasm_interval *interval;
+      unsigned i;
+
+      case _EVOASM_DOMAIN_TYPES2(EVOASM_DOMAIN_TYPE_ENUM, EVOASM_DOMAIN_TYPE_INTERVAL):
+      case _EVOASM_DOMAIN_TYPES2(EVOASM_DOMAIN_TYPE_ENUM, EVOASM_DOMAIN_TYPE_INTERVAL64):
+        enm = (evoasm_enum *) domain1;
+        interval = (evoasm_interval *) domain2;
+        goto intersect;
+      case _EVOASM_DOMAIN_TYPES2(EVOASM_DOMAIN_TYPE_INTERVAL, EVOASM_DOMAIN_TYPE_ENUM):
+      case _EVOASM_DOMAIN_TYPES2(EVOASM_DOMAIN_TYPE_INTERVAL64, EVOASM_DOMAIN_TYPE_ENUM):
+        enm = (evoasm_enum *) domain2;
+        interval = (evoasm_interval *) domain1;
+    intersect: {
+          evoasm_enum *enum_dst = (evoasm_enum *) domain_dst;
+          enum_dst->len = 0;
+          for(i = 0; i < enm->len; i++) {
+            if(enm->vals[i] >= interval->min && enm->vals[i] <= interval->max) {
+              enum_dst->vals[enum_dst->len++] = enm->vals[i];
+            }
+          }
+        }
+        break;
+    }
+    default:
+      evoasm_assert_not_reached();
+  }
+
+#undef _EVOASM_DOMAIN_TYPES2
+}
+
+static inline bool
+evoasm_domain_contains_p(evoasm_domain *domain, int64_t val) {
+  switch(domain->type) {
+    case EVOASM_DOMAIN_TYPE_INTERVAL: {
+      evoasm_interval *interval = (evoasm_interval *) domain;
+      return val >= interval->min && val <= interval->max;
+    }
+    case EVOASM_DOMAIN_TYPE_ENUM: {
+      unsigned i;
+      evoasm_enum *enm = (evoasm_enum *) domain;
+      for(i = 0; i < enm->len; i++) {
+        if(enm->vals[i] == val) return true;
+      }
+      return false;
+    }
+    default:
+      evoasm_assert_not_reached();
+      return false;
+  }
+}
+
+static inline int64_t
+evoasm_log2(int64_t num) {
+  uint64_t log = 0;
+  while (num >>= 1) ++log;
+  return (int64_t)log;
+}