evoasm 0.0.2.pre7 → 0.1.0.pre2

data/ext/evoasm_ext/libevoasm/src/evoasm-alloc.h

@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2016 Julian Aron Prenner <jap@polyadic.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "evoasm-util.h"
+
+#ifdef EVOASM_UNIX
+#  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))
+#  define EVOASM_ALIGNED_ALLOC_ATTRS __attribute__((malloc))
+#  define EVOASM_ALIGNED_CALLOC_ATTRS __attribute__((malloc))
+#else
+#  define EVOASM_MALLOC_ATTRS
+#  define EVOASM_CALLOC_ATTRS
+#  define EVOASM_REALLOC_ATTRS
+#  define EVOASM_ALIGNED_ALLOC_ATTRS
+#  define EVOASM_ALIGNED_CALLOC_ATTRS
+#endif
+
+typedef enum {
+  EVOASM_MPROT_MODE_RW,
+  EVOASM_MPROT_MODE_RX,
+  EVOASM_MPROT_MODE_RWX,
+} evoasm_mprot_mode_t;
+
+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_aligned_alloc(size_t, size_t) EVOASM_ALIGNED_ALLOC_ATTRS;
+void *evoasm_aligned_calloc(size_t align, size_t n, size_t size) EVOASM_ALIGNED_CALLOC_ATTRS;
+void evoasm_free(void *);
+
+void *evoasm_mmap(size_t size, void *p);
+evoasm_success_t evoasm_munmap(void *p, size_t size);
+evoasm_success_t evoasm_mprot(void *p, size_t size, evoasm_mprot_mode_t mode);
+size_t evoasm_get_page_size();
+
+#define EVOASM_TRY_ALLOC(label, func, var, ...) \
+do { \
+  if(!(var = evoasm_##func(__VA_ARGS__))) goto label; \
+} while(0);
+
+#if defined(_WIN32)
+  #define evoasm_alloca(s) _malloca(s);
+#else
+  #define evoasm_alloca(s) alloca(s);
+#endif
+
+#ifndef EVOASM_CACHE_LINE_SIZE
+#define EVOASM_CACHE_LINE_SIZE 64
+#endif

data/ext/evoasm_ext/libevoasm/src/evoasm-arch.c

@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2016 Julian Aron Prenner <jap@polyadic.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "evoasm-arch.h"
+
+EVOASM_DEF_LOG_TAG("arch")
+
+evoasm_arch_info_t _evoasm_arch_infos[] = {
+    {
+        EVOASM_ARCH_X64,
+        EVOASM_X64_PARAM_NONE,
+        15,
+        EVOASM_X64_INST_NONE,
+        0ull
+    }
+};
+
+evoasm_arch_id_t _evoasm_current_arch = EVOASM_ARCH_NONE;
+
+evoasm_arch_info_t *
+evoasm_get_arch_info(evoasm_arch_id_t arch_id) {
+  return &_evoasm_arch_infos[arch_id];
+}
+
+evoasm_arch_id_t
+evoasm_get_current_arch() {
+  return _evoasm_current_arch;
+}
+
+#define EVOASM_ARCH_INFO_DEF_GETTER(field, type) EVOASM_DEF_GETTER(arch_info, field, type)
+
+EVOASM_ARCH_INFO_DEF_GETTER(id, evoasm_arch_id_t)
+EVOASM_ARCH_INFO_DEF_GETTER(n_params, size_t)
+EVOASM_ARCH_INFO_DEF_GETTER(max_inst_len, size_t)
+EVOASM_ARCH_INFO_DEF_GETTER(n_insts, size_t)
+EVOASM_ARCH_INFO_DEF_GETTER(features, uint64_t)
+
+

data/ext/evoasm_ext/libevoasm/src/evoasm-arch.h

@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2016 Julian Aron Prenner <jap@polyadic.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <stdint.h>
+#include <gen/evoasm-x64-enums.h>
+
+#include "evoasm-error.h"
+#include "evoasm-param.h"
+#include "evoasm-buf.h"
+#include "evoasm-log.h"
+
+#define EVOASM_ARCH_MAX_PARAMS 32
+
+typedef uint8_t evoasm_reg_id_t;
+#define EVOASM_REG_ID_MAX UINT8_MAX
+
+typedef uint16_t evoasm_inst_id_t;
+
+typedef enum {
+  EVOASM_ARCH_X64,
+  EVOASM_ARCH_NONE
+} evoasm_arch_id_t;
+
+typedef struct {
+  uint8_t id;
+  uint8_t n_params;
+  uint8_t max_inst_len;
+  uint16_t n_insts;
+  uint64_t features;
+} evoasm_arch_info_t;
+
+
+typedef enum {
+  EVOASM_ARCH_ERROR_CODE_NOT_ENCODABLE,
+  EVOASM_ARCH_ERROR_CODE_MISSING_PARAM,
+  EVOASM_ARCH_ERROR_CODE_MISSING_FEATURE,
+} evoasm_arch_error_code_t;
+
+typedef struct {
+  uint8_t reg;
+  uint8_t param;
+  uint16_t inst;
+} evoasm_enc_error_data_t;
+
+typedef struct {
+  EVOASM_ERROR_HEADER
+  evoasm_enc_error_data_t data;
+} evoasm_enc_error_t;
+
+_Static_assert(sizeof(evoasm_error_data_t) >= sizeof(evoasm_enc_error_data_t), "evoasm_enc_error_data_t exceeds evoasm_error_data_t size limit");
+
+evoasm_arch_info_t *
+evoasm_get_arch_info(evoasm_arch_id_t arch_id);
+
+evoasm_arch_id_t
+evoasm_get_current_arch();
+
+#if 0
+static inline void
+evoasm_enc_ctx_write_access(evoasm_buf_ref_t *arch_id, evoasm_bitmap_t *acc, evoasm_reg_id_t reg) {
+  evoasm_bitmap_set(acc, (size_t) reg);
+}
+
+static inline void
+evoasm_enc_ctx_undefined_access(evoasm_buf_ref_t *arch_id, evoasm_bitmap_t *acc, evoasm_reg_id_t reg) {
+  evoasm_bitmap_unset(acc, (size_t) reg);
+}
+
+static inline evoasm_success_t
+evoasm_enc_ctx_read_access_(evoasm_buf_ref_t *arch_id, evoasm_bitmap_t *acc, evoasm_reg_id_t reg,
+                             evoasm_inst_id_t inst, const char *file, unsigned line) {
+  if(!evoasm_bitmap_get(acc, (size_t) reg)) {
+    evoasm_enc_error_data_t error_data = {
+      .reg = (uint8_t) reg,
+      .inst = (uint16_t) inst,
+      .arch = arch_id
+    };
+    evoasm_error(EVOASM_ERROR_TYPE_ENC, EVOASM_ENC_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__)
+#endif
+

data/ext/evoasm_ext/libevoasm/src/evoasm-bitmap.h

@@ -0,0 +1,158 @@
+/*
+ * Copyright (C) 2016 Julian Aron Prenner <jap@polyadic.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+#define EVOASM_BITMAP_IDX_DECLS(key) \
+  size_t size = sizeof(uint64_t) * 8;\
+  size_t ary_idx = ((size_t) key) / size;\
+  size_t bit_idx = ((size_t) key) % size;
+
+typedef struct {
+  uint64_t data[1];
+} evoasm_bitmap64_t;
+
+typedef struct {
+  uint64_t data[2];
+} evoasm_bitmap128_t;
+
+typedef struct {
+  uint64_t data[4];
+} evoasm_bitmap256_t;
+
+typedef struct {
+  uint64_t data[8];
+} evoasm_bitmap512_t;
+
+typedef struct {
+  uint64_t data[16];
+} evoasm_bitmap1024_t;
+
+typedef uint64_t evoasm_bitmap_t;
+
+static inline void
+evoasm_bitmap_set(evoasm_bitmap_t *bitmap, size_t idx) {
+  EVOASM_BITMAP_IDX_DECLS(idx);
+  bitmap[ary_idx] |= (1ull << bit_idx);
+}
+
+static inline void
+evoasm_bitmap_unset(evoasm_bitmap_t *bitmap, size_t idx) {
+  EVOASM_BITMAP_IDX_DECLS(idx);
+  /* unset values must be 0*/
+  bitmap[ary_idx] &= ~(1ull << bit_idx);
+}
+
+static inline bool
+evoasm_bitmap_get(evoasm_bitmap_t *bitmap, size_t idx) {
+  EVOASM_BITMAP_IDX_DECLS(idx);
+  return (bitmap[ary_idx] & (1ull << bit_idx)) != 0;
+}
+
+static inline void
+evoasm_bitmap_set64(evoasm_bitmap_t *bitmap, size_t idx, uint64_t bits) {
+  EVOASM_BITMAP_IDX_DECLS(idx);
+  (void) bit_idx;
+  bitmap[ary_idx] = bits;
+}
+
+static inline void
+evoasm_bitmap_or64(evoasm_bitmap_t *bitmap, size_t idx, uint64_t bits) {
+  EVOASM_BITMAP_IDX_DECLS(idx);
+  (void) bit_idx;
+  bitmap[ary_idx] |= bits;
+}
+
+
+#define EVOASM_BITMAP_DECL_IS_ZERO(width) \
+  static inline bool evoasm_bitmap ## width ## _is_zero(evoasm_bitmap##width##_t *bitmap) { \
+    size_t i;\
+    for(i = 0; i < width / 64; i++) {\
+      if(bitmap->data[i] != 0) return false;\
+    }\
+    return true;\
+  }
+
+#define EVOASM_BITMAP_DECL_UNOP(name, width, op) \
+  static inline void evoasm_bitmap ## width ## _ ## name (evoasm_bitmap##width##_t *bitmap, evoasm_bitmap##width##_t *result) { \
+    size_t 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##_t *bitmap1, evoasm_bitmap##width##_t *bitmap2, evoasm_bitmap##width##_t *result) { \
+    size_t 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##_t *bitmap1, evoasm_bitmap##width##_t *bitmap2) { \
+    size_t 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 size_t evoasm_bitmap ## width ## _ ## popcount (evoasm_bitmap##width##_t *bitmap) { \
+      size_t c = 0; \
+      size_t i;\
+      for(i = 0; i < width / 64; i++) {\
+        c += (size_t) __builtin_popcountll(bitmap->data[i]);\
+      } \
+      return c;\
+    }
+#else
+#  define EVOASM_BITMAP_DECL_POPCOUNT(width) \
+    static inline size_t evoasm_bitmap_t ## width ## _ ## popcount (evoasm_bitmap##width##_t *bitmap) { \
+      size_t 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_BINOP(andn, 512, &~)
+EVOASM_BITMAP_DECL_IS_ZERO(512)
+
+EVOASM_BITMAP_DECL_EQL(1024)

data/ext/evoasm_ext/libevoasm/src/evoasm-buf.c

@@ -0,0 +1,204 @@
+/*
+ * Copyright (C) 2016 Julian Aron Prenner <jap@polyadic.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <string.h>
+
+#include "evoasm-buf.h"
+#include "evoasm-alloc.h"
+#include "evoasm-util.h"
+#include "evoasm-signal.h"
+#include "evoasm.h"
+
+EVOASM_DEF_LOG_TAG("buf")
+
+static evoasm_success_t
+evoasm_buf_init_mmap(evoasm_buf_t *buf, size_t size) {
+  uint8_t *mem;
+
+  //size = EVOASM_ALIGN_UP(size, evoasm_get_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_t
+evoasm_buf_init_malloc(evoasm_buf_t *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_t
+evoasm_buf_init(evoasm_buf_t *buf, evoasm_buf_type_t 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_t
+evoasm_buf_destroy_mmap(evoasm_buf_t *buf) {
+  if(buf->data != NULL) {
+    return evoasm_munmap(buf->data, buf->capa);
+  }
+  return true;
+}
+
+static evoasm_success_t
+evoasm_buf_destroy_malloc(evoasm_buf_t *buf) {
+  evoasm_free(buf->data);
+  return true;
+}
+
+evoasm_success_t
+evoasm_buf_destroy(evoasm_buf_t *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_t *buf) {
+  memset(buf->data, 0, buf->pos);
+  buf->pos = 0;
+}
+
+evoasm_success_t
+evoasm_buf_protect(evoasm_buf_t *buf, evoasm_mprot_mode_t mode) {
+  return evoasm_mprot(buf->data, buf->capa, mode);
+}
+
+intptr_t
+evoasm_buf_exec(evoasm_buf_t *buf) {
+  intptr_t (*func)(void);
+  intptr_t result = 0;
+  *(void **) (&func) = buf->data;
+  result = func();
+  return result;
+}
+
+evoasm_success_t
+evoasm_buf_safe_exec(evoasm_buf_t *buf, uint64_t exception_mask, intptr_t *retval) {
+  bool success;
+
+  evoasm_signal_set_exception_mask(exception_mask);
+
+  if(EVOASM_SIGNAL_TRY()) {
+    *retval = evoasm_buf_exec(buf);
+    success = true;
+  } else {
+    *retval = evoasm_signal_get_last_exception();
+    success = false;
+  }
+
+  evoasm_signal_clear_exception_mask();
+
+  return success;
+}
+
+void
+evoasm_buf_log(evoasm_buf_t *buf, evoasm_log_level_t log_level) {
+  if(_evoasm_log_level > log_level) return;
+
+  evoasm_log(log_level, EVOASM_LOG_TAG, "Evoasm::Buffer: capa: %zu, pos: %zu, addr: %p\n",
+             buf->capa, buf->pos, (void *) buf->data);
+  for(size_t 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 ");
+}
+
+void
+evoasm_buf_to_buf_ref(evoasm_buf_t *buf, evoasm_buf_ref_t *buf_ref) {
+  buf_ref->data = buf->data;
+  buf_ref->pos = &buf->pos;
+}
+
+size_t
+evoasm_buf_write(evoasm_buf_t *buf, uint8_t *data, size_t len) {
+  size_t free = buf->capa - buf->pos;
+  if(len > free) {
+    evoasm_error(EVOASM_ERROR_TYPE_BUF, EVOASM_BUF_ERROR_CODE_NO_SPACE,
+                 "buffer does not fit (need %zu bytes but only %zu free)", len, free);
+    return len - free;
+  }
+  memcpy(buf->data + buf->pos, data, len);
+  buf->pos += len;
+  return 0;
+}
+
+size_t
+evoasm_buf_append(evoasm_buf_t *restrict dst, evoasm_buf_t *restrict src) {
+  return evoasm_buf_write(dst, src->data, src->pos);
+}
+
+evoasm_success_t
+evoasm_buf_clone(evoasm_buf_t *restrict buf, evoasm_buf_t *restrict cloned_buf) {
+  if(!evoasm_buf_init(cloned_buf, (evoasm_buf_type_t) buf->type, buf->capa)) {
+    return false;
+  }
+  return evoasm_buf_append(cloned_buf, buf) == 0;
+}
+
+uint8_t *
+evoasm_buf_data(evoasm_buf_t *buf) {
+  return buf->data;
+}
+
+
+EVOASM_DEF_ALLOC_FREE_FUNCS(buf_ref)
+
+EVOASM_DEF_ALLOC_FREE_FUNCS(buf)
+
+EVOASM_DEF_GETTER(buf, capa, size_t)
+EVOASM_DEF_GETTER(buf, pos, size_t)
+EVOASM_DEF_GETTER(buf, type, evoasm_buf_type_t)
+EVOASM_DEF_GETTER(buf, data, const uint8_t *)
+
+void
+evoasm_buf_ref_init(evoasm_buf_ref_t *buf_ref, uint8_t *data, size_t *pos) {
+  buf_ref->data = data;
+  buf_ref->pos = pos;
+}
+