evoasm 0.0.2.pre7 → 0.1.0.pre2

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

@@ -0,0 +1,167 @@
+/*
+ * 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-pop-params.h"
+#include "evoasm-x64.h"
+#include "evoasm-program-io.h"
+
+#define EVOASM_KERNEL_MAX_OUTPUT_REGS 254
+#define EVOASM_KERNEL_MAX_INPUT_REGS 254
+
+#define EVOASM_KERNEL_REG_INFO_N_TRANS_REGS 2
+
+typedef struct {
+  bool input : 1;
+  bool written : 1;
+  bool output : 1;
+  /*registers in following kernels whose input is this register */
+} evoasm_kernel_x64_reg_info_reg_t;
+
+typedef struct {
+  evoasm_kernel_x64_reg_info_reg_t regs[EVOASM_X64_REG_NONE];
+
+  /* trans_regs[trans_idx][reg_id] stores the register in this kernel that is used
+   * to initialize reg_id in the trans_idx'th transition kernel.
+   * Right now, trans_idx=0 is the next kernel in line,
+   * while trans_idx=1 is the kernel jumped to using the programs jmp_offs table.
+   */
+  evoasm_x64_reg_id_t trans_regs[EVOASM_KERNEL_REG_INFO_N_TRANS_REGS][EVOASM_X64_REG_NONE];
+  unsigned written_flags : EVOASM_X64_RFLAGS_FLAGS_BITSIZE;
+} evoasm_kernel_x64_reg_info_t;
+
+typedef union {
+  evoasm_kernel_x64_reg_info_t x64;
+} evoasm_kernel_reg_info_t;
+
+
+typedef struct {
+  uint16_t size;
+  evoasm_inst_id_t *insts;
+  union {
+    evoasm_x64_basic_params_t *x64;
+  } params;
+  evoasm_kernel_reg_info_t reg_info;
+
+  union {
+    evoasm_x64_reg_id_t x64[EVOASM_KERNEL_MAX_OUTPUT_REGS];
+  } output_regs;
+
+  uint_fast8_t n_input_regs;
+  uint_fast8_t n_output_regs;
+  uint16_t idx;
+  uint16_t buf_start;
+  uint16_t buf_end;
+
+#ifdef EVOASM_ENABLE_PARANOID_MODE
+  evoasm_program_io_val_t rand_vals[EVOASM_X64_REG_NONE];
+#endif
+
+} evoasm_kernel_t;
+
+
+typedef enum {
+  EVOASM_PROGRAM_ERROR_CODE_NO_OUTPUT
+} evoasm_program_error_code_t;
+
+typedef enum {
+  EVOASM_PROGRAM_EMIT_FLAG_PREPARE = (1 << 0),
+  EVOASM_PROGRAM_EMIT_FLAG_EMIT_KERNELS = (1 << 1),
+  EVOASM_PROGRAM_EMIT_FLAG_EMIT_IO_LOAD_STORE = (1 << 2),
+  EVOASM_PROGRAM_EMIT_FLAG_SET_IO_MAPPING = (1 << 3)
+} evoasm_program_emit_flags_t;
+
+#define EVOASM_PROGRAM_MAX_SIZE 256
+#define EVOASM_KERNEL_MAX_SIZE 2048
+
+typedef struct {
+  evoasm_arch_info_t *arch_info;
+  evoasm_buf_t *buf;
+  evoasm_buf_t *body_buf;
+  bool reset_rflags : 1;
+  bool shallow : 1;
+  uint32_t recur_limit;
+  uint16_t size;
+  uint16_t max_tuples;
+  uint32_t exception_mask;
+  evoasm_program_io_val_type_t types[EVOASM_PROGRAM_OUTPUT_MAX_ARITY];
+  evoasm_program_io_val_t *output_vals;
+  evoasm_kernel_t *kernels;
+  int16_t *jmp_offs;
+  uint8_t *jmp_conds;
+  uint32_t *recur_counters;
+
+  /* these two are incomplete (values missig)
+   * We only need arity and types */
+  evoasm_program_input_t _input;
+  evoasm_program_output_t _output;
+
+  evoasm_reg_id_t output_regs[EVOASM_PROGRAM_IO_MAX_ARITY];
+  evoasm_buf_t _buf;
+  evoasm_buf_t _body_buf;
+
+  union {
+    /* register at index i has _input i % input_arity */
+    uint8_t x64[EVOASM_X64_REG_NONE];
+  } reg_inputs;
+
+} evoasm_program_t;
+
+evoasm_success_t
+evoasm_program_clone(evoasm_program_t *program, evoasm_program_t *cloned_program);
+
+evoasm_success_t
+evoasm_program_init(evoasm_program_t *program,
+                    evoasm_arch_info_t *arch_info,
+                    size_t program_size,
+                    size_t kernel_size,
+                    size_t max_tuples,
+                    size_t recur_limit,
+                    bool shallow);
+
+
+evoasm_program_output_t *
+evoasm_program_run(evoasm_program_t *program,
+               evoasm_program_input_t *input);
+
+
+evoasm_success_t
+evoasm_program_destroy(evoasm_program_t *program);
+
+evoasm_success_t
+evoasm_program_eliminate_introns(evoasm_program_t *program, evoasm_program_t *dest_program);
+
+evoasm_success_t
+evoasm_program_emit(evoasm_program_t *program,
+                evoasm_program_input_t *input,
+                evoasm_program_emit_flags_t emit_flags);
+
+evoasm_loss_t
+evoasm_program_eval(evoasm_program_t *program,
+                    evoasm_program_output_t *output);
+
+evoasm_success_t
+evoasm_program_detach(evoasm_program_t *program,
+                      evoasm_program_io_t *input,
+                      evoasm_program_io_t *output);
+
+
+void
+evoasm_program_log(evoasm_program_t *program, evoasm_log_level_t log_level);
+
+EVOASM_DECL_ALLOC_FREE_FUNCS(program)

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

@@ -0,0 +1,65 @@
+/*
+ * 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.h"
+#include "evoasm-util.h"
+#include "evoasm-rand.h"
+
+EVOASM_DEF_LOG_TAG("rand")
+
+EVOASM_DEF_ALLOC_FREE_FUNCS(prng)
+
+void
+evoasm_prng_init(evoasm_prng_t *prng, evoasm_prng_state_t *seed) {
+  prng->state = *seed;
+  prng->p = 0;
+}
+
+void
+evoasm_prng_destroy(evoasm_prng_t *prng) {
+}
+
+uint64_t
+evoasm_prng_rand64(evoasm_prng_t *prng) {
+  return evoasm_prng_rand64_(prng);
+}
+
+uint32_t
+evoasm_prng_rand32(evoasm_prng_t *prng) {
+  return evoasm_prng_rand32_(prng);
+}
+
+uint16_t
+evoasm_prng_rand16(evoasm_prng_t *prng) {
+  return evoasm_prng_rand16_(prng);
+}
+
+uint8_t
+evoasm_prng_rand8(evoasm_prng_t *prng) {
+  return evoasm_prng_rand8_(prng);
+}
+
+float
+evoasm_prng_randf(evoasm_prng_t *prng) {
+  return evoasm_prng_randf_(prng);
+}
+
+int64_t
+evoasm_prng_rand_between(evoasm_prng_t *prng, int64_t min, int64_t max) {
+  return evoasm_prng_rand_between_(prng, min, max);
+}
+

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

@@ -0,0 +1,76 @@
+/*
+ * 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-error.h"
+#include "evoasm-log.h"
+
+#define EVOASM_PRNG_SEED_LEN 16
+
+typedef struct {
+  uint64_t data[EVOASM_PRNG_SEED_LEN];
+} evoasm_prng_state_t;
+
+typedef struct evoasm_prng64 {
+  /* xorshift1024star */
+  evoasm_prng_state_t state;
+  int p;
+} evoasm_prng_t;
+
+void
+evoasm_prng_init(evoasm_prng_t *prng, evoasm_prng_state_t *seed);
+
+void
+evoasm_prng_destroy(evoasm_prng_t *prng);
+
+
+/* From: https://en.wikipedia.org/wiki/Xorshift */
+static inline uint64_t
+evoasm_prng_rand64_(evoasm_prng_t *prng) {
+  uint64_t *s = prng->state.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)) - 1;
+}
+
+static inline uint32_t
+evoasm_prng_rand32_(evoasm_prng_t *prng) {
+  return (uint32_t) (evoasm_prng_rand64_(prng) & UINT32_MAX);
+}
+
+static inline uint16_t
+evoasm_prng_rand16_(evoasm_prng_t *prng) {
+  return (uint16_t) (evoasm_prng_rand64_(prng) & UINT16_MAX);
+}
+
+static inline uint8_t
+evoasm_prng_rand8_(evoasm_prng_t *prng) {
+  return (uint8_t) (evoasm_prng_rand64_(prng) & UINT8_MAX);
+}
+
+static inline float
+evoasm_prng_randf_(evoasm_prng_t *prng) {
+  return (float) evoasm_prng_rand32_(prng) / (float) UINT32_MAX;
+}
+
+static inline int64_t
+evoasm_prng_rand_between_(evoasm_prng_t *prng, int64_t min, int64_t max) {
+  return min + (int64_t)(evoasm_prng_rand64_(prng) % (uint64_t)(max - min + 1ll));
+}

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

@@ -0,0 +1,106 @@
+/*
+ * 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-signal.h"
+
+#ifdef EVOASM_UNIX
+
+#define EVOASM_SIGNAL_EXCEPTION_MASK_GET(exc) (_evoasm_signal_ctx.exception_mask & (1u << exc))
+
+_Thread_local evoasm_signal_ctx_t _evoasm_signal_ctx;
+
+static void
+evoasm_signal_handler(int sig, siginfo_t *siginfo, void *ctx) {
+  bool handle = false;
+
+  switch(_evoasm_signal_ctx.arch_id) {
+    case EVOASM_ARCH_X64: {
+      switch(sig) {
+        case SIGFPE: {
+          int exception = EVOASM_X64_EXCEPTION_DE;
+          bool catch_div_by_zero = siginfo->si_code == FPE_INTDIV &&
+                                   EVOASM_SIGNAL_EXCEPTION_MASK_GET(exception);
+          _evoasm_signal_ctx.last_exception = exception;
+          handle = catch_div_by_zero;
+          break;
+        }
+        default:
+          break;
+      }
+      break;
+    }
+    default:
+      evoasm_assert_not_reached();
+  }
+
+  if(handle) {
+    siglongjmp(_evoasm_signal_ctx.env, 1);
+  } else {
+    evoasm_signal_uninstall();
+    raise(sig);
+  }
+}
+
+static struct sigaction prev_action;
+
+void
+evoasm_signal_install() {
+  struct sigaction action = {0};
+
+  evoasm_arch_id_t arch_id = evoasm_get_current_arch();
+  assert(arch_id != EVOASM_ARCH_NONE);
+
+  _evoasm_signal_ctx.arch_id = (volatile evoasm_arch_id_t) arch_id;
+  _evoasm_signal_ctx.exception_mask = 0;
+  _evoasm_signal_ctx.last_exception = 0;
+
+  action.sa_sigaction = evoasm_signal_handler;
+  sigemptyset(&action.sa_mask);
+  action.sa_flags = SA_SIGINFO;
+
+  if(sigaction(SIGFPE, &action, &prev_action) < 0) {
+    perror("sigaction");
+    exit(1);
+  }
+}
+
+void
+evoasm_signal_set_exception_mask(uint64_t exception_mask) {
+  _evoasm_signal_ctx.exception_mask = exception_mask;
+}
+
+void
+evoasm_signal_clear_exception_mask() {
+  _evoasm_signal_ctx.exception_mask = 0;
+}
+
+int
+evoasm_signal_get_last_exception() {
+  return _evoasm_signal_ctx.last_exception;
+}
+
+void
+evoasm_signal_uninstall() {
+  if(sigaction(SIGFPE, &prev_action, NULL) < 0) {
+    perror("sigaction");
+    exit(1);
+  }
+}
+
+#else
+#error
+#endif

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

@@ -0,0 +1,58 @@
+/*
+ * 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"
+#include "evoasm-arch.h"
+#include <stdint.h>
+
+#ifdef EVOASM_UNIX
+
+#include <setjmp.h>
+#include <signal.h>
+
+typedef struct  {
+  volatile uint64_t exception_mask;
+  volatile evoasm_arch_id_t arch_id;
+  sigjmp_buf env;
+  int last_exception;
+} evoasm_signal_ctx_t;
+
+extern _Thread_local evoasm_signal_ctx_t _evoasm_signal_ctx;
+
+#define EVOASM_SIGNAL_TRY() (sigsetjmp(_evoasm_signal_ctx.env, 1) == 0)
+#else
+#error
+#endif
+
+#include "evoasm-arch.h"
+
+int
+evoasm_signal_get_last_exception();
+
+void
+evoasm_signal_uninstall();
+
+void
+evoasm_signal_install();
+
+void
+evoasm_signal_set_exception_mask(uint64_t exception_mask);
+
+void
+evoasm_signal_clear_exception_mask();