evoasm 0.0.2.pre7

data/data/templates/evoasm-x64.c.erb

@@ -0,0 +1,319 @@
+/* AUTOGENERATED FILE, DO NOT EDIT */
+
+#include "evoasm-x64.h"
+#include "evoasm-error.h"
+#include "evoasm-alloc.h"
+
+static const char *_evoasm_log_tag = "x64";
+
+uint8_t evoasm_x64_reg_type_sizes[EVOASM_X64_N_REG_TYPES] = {0};
+
+static int64_t
+evoasm_x64_disp_size(evoasm_x64 *x64, evoasm_arch_param_val *param_vals, evoasm_bitmap *set_params) {
+  evoasm_arch_param_val val = param_vals[EVOASM_X64_PARAM_DISP];
+  if(!evoasm_bitmap_get(set_params, EVOASM_X64_PARAM_DISP)) return 0;
+  if(val >= INT8_MIN && val <= INT8_MAX) return 8;
+  if(val >= INT32_MIN && val <= INT32_MAX) return 32;
+  return 0;
+}
+
+static int8_t
+evoasm_x64_reg_code(evoasm_x64 *x64, evoasm_x64_reg_id reg) {
+  switch(reg) {
+<% Evoasm::Gen::X64::REGISTERS.fetch_values(:gp, :mm, :xmm, :zmm).each do |regs| %>
+<% regs.each_with_index do |reg, index| %>
+    case <%= reg_name_to_c reg %>: return <%= index %>;
+<%end %>
+<%end %>
+  default:
+    evoasm_fatal("invalid register id %d", reg);
+    evoasm_assert_not_reached();
+  }
+}
+
+/* PERMUTATION TABLES */
+<%= permutation_tables %>
+/* ------------------- */
+
+/* FUNCS */
+<%= called_funcs %>
+/* ------------------- */
+
+<%= pref_funcs %>
+<%= inst_funcs %>
+<%= param_domains %>
+<%= inst_params %>
+<%= inst_operands %>
+
+<%= insts_c %>
+
+static evoasm_x64_reg_id evoasm_x64_sysv_callee_save_regs[] = {
+  EVOASM_X64_REG_BP,
+  EVOASM_X64_REG_B,
+  EVOASM_X64_REG_12,
+  EVOASM_X64_REG_13,
+  EVOASM_X64_REG_14,
+  EVOASM_X64_REG_15,
+};
+
+static evoasm_success
+evoasm_x64_func_prolog_or_epilog(evoasm_x64 *x64, evoasm_buf *buf, evoasm_x64_abi abi, bool prolog) {
+  evoasm_arch *arch = (evoasm_arch *) x64;
+  unsigned i;
+  size_t regs_len = EVOASM_ARY_LEN(evoasm_x64_sysv_callee_save_regs);
+  evoasm_x64_params params = {0};
+
+  /* touch RSP and RBX so we don't get a read access violation for PUSH */
+  //evoasm_arch_write_access(arch, (evoasm_bitmap *) &arch->acc, EVOASM_X64_REG_SP);
+
+  for(i = 0; i < regs_len; i++) {
+    evoasm_x64_reg_id reg = evoasm_x64_sysv_callee_save_regs[prolog ? i : (regs_len - 1 - i)];
+    evoasm_arch_write_access(arch, (evoasm_bitmap *) &arch->acc, reg);
+    EVOASM_X64_SET(EVOASM_X64_PARAM_REG0, reg);
+
+    if(prolog) {
+      EVOASM_X64_ENC(push_r64);
+    }
+    else {
+      EVOASM_X64_ENC(pop_r64);
+    }
+    evoasm_arch_save(arch, buf);
+  }
+
+  if(!prolog) {
+    EVOASM_X64_ENC(ret);
+    evoasm_arch_save(arch, buf);
+  }
+
+  return true;
+
+enc_failed:
+  return false;
+}
+
+evoasm_success
+evoasm_x64_func_prolog(evoasm_x64 *x64, evoasm_buf *buf, evoasm_x64_abi abi) {
+  return evoasm_x64_func_prolog_or_epilog(x64, buf, abi, true);
+}
+
+evoasm_success
+evoasm_x64_func_epilog(evoasm_x64 *x64, evoasm_buf *buf, evoasm_x64_abi abi) {
+  return evoasm_x64_func_prolog_or_epilog(x64, buf, abi, false);
+}
+
+static evoasm_success
+evoasm_x64_load_cpuid(evoasm_x64 *x64) {
+  evoasm_buf buf;
+  evoasm_x64_params params = {0};
+  bool retval = true;
+
+  uint32_t vals[<%= Evoasm::Gen::X64::CPUID.size %>][<%= Evoasm::Gen::X64::CPUID.max_by{|k, v| v.size}.size %>] = {0};
+  evoasm_arch *arch = (evoasm_arch *) x64;
+
+  evoasm_debug("Running CPUID...");
+
+  EVOASM_TRY(alloc_failed, evoasm_buf_init, &buf, EVOASM_BUF_TYPE_MMAP, 512);
+
+  EVOASM_TRY(enc_failed, evoasm_x64_func_prolog, x64, &buf, EVOASM_X64_ABI_SYSV);
+
+<% remaining_flags = features.keys %>
+<% io = StrIO.new %>
+<% Evoasm::Gen::X64::CPUID.each_with_index do |((eax_val, ecx_val), out_regs), index0| %>
+
+  EVOASM_X64_SET(EVOASM_X64_PARAM_REG0, EVOASM_X64_REG_A);
+  EVOASM_X64_SET(EVOASM_X64_PARAM_IMM0, <%= eax_val %>);
+  EVOASM_X64_ENC(mov_r32_imm32);
+  evoasm_arch_save(arch, &buf);
+
+  <% if ecx_val %>
+  EVOASM_X64_SET(EVOASM_X64_PARAM_REG0, EVOASM_X64_REG_C);
+  EVOASM_X64_SET(EVOASM_X64_PARAM_IMM0, <%= ecx_val %>);
+  EVOASM_X64_ENC(mov_r32_imm32);
+  evoasm_arch_save(arch, &buf);
+  <% end %>
+
+  EVOASM_X64_ENC(cpuid);
+  evoasm_arch_save(arch, &buf);
+
+  <% out_regs.each.with_index do |(reg, flags), index1| %>
+
+  {
+    evoasm_arch_param_val addr_imm;
+    addr_imm = (evoasm_arch_param_val)(uintptr_t) &vals[<%= index0 %>][<%= index1 %>];
+    EVOASM_X64_SET(EVOASM_X64_PARAM_REG0, EVOASM_X64_REG_DI);
+    EVOASM_X64_SET(EVOASM_X64_PARAM_IMM0, addr_imm);
+    EVOASM_X64_ENC(mov_r64_imm64);
+    evoasm_arch_save(arch, &buf);
+
+    EVOASM_X64_SET(EVOASM_X64_PARAM_REG1, <%= reg_name_to_c reg %>);
+    EVOASM_X64_SET(EVOASM_X64_PARAM_REG_BASE, EVOASM_X64_REG_DI);
+    EVOASM_X64_ENC(mov_rm32_r32);
+    evoasm_arch_save(arch, &buf);
+    EVOASM_X64_UNSET(EVOASM_X64_PARAM_ADDRESS_SIZE);
+    EVOASM_X64_UNSET(EVOASM_X64_PARAM_REG_BASE);
+
+    <% flags.each_with_index do |flag, bit_index| %>
+      <% if remaining_flags.delete(flag) %>
+        <% io.indent 1 do %>
+          <% io.puts "if(vals[#{index0}][#{index1}] & (1 << #{bit_index})) {" %>
+          <% io.puts "  x64->features |= #{feature_name_to_c flag};" %>
+          <% io.puts %{  evoasm_info("Found support for #{flag.upcase}");} %>
+          <% io.puts "} else {" %>
+          <% io.puts %{  evoasm_info("Missing support for #{flag.upcase}");} %>
+          <% io.puts "}" %>
+        <% end %>
+      <% end %>
+    <% end %>
+  }
+  <% end%>
+<% end %>
+
+  EVOASM_TRY(enc_failed, evoasm_x64_func_epilog, x64, &buf, EVOASM_X64_ABI_SYSV);
+
+  /*evoasm_buf_dump(&buf, stderr);*/
+
+  EVOASM_TRY(enc_failed, evoasm_buf_protect, &buf, EVOASM_MPROT_RX);
+  evoasm_buf_exec(&buf);
+
+<%= io.string %>
+
+cleanup:
+  EVOASM_TRY(destroy_failed, evoasm_buf_destroy, &buf);
+  return retval;
+enc_failed:
+  retval = false;
+  goto cleanup;
+destroy_failed:
+  return false;
+alloc_failed:
+  return false;
+
+}
+
+static uint16_t
+evoasm_x64_insts(evoasm_x64 *x64, const evoasm_x64_inst **insts) {
+  uint16_t len = 0;
+  const evoasm_x64_inst *inst;
+  /* Assuming that at least some feature is found */
+
+  <% insts.each do |inst| %>
+  inst = &<%= insts_var_name %>[<%= inst.index %>];
+  if((inst->features & ~x64->features) == 0) insts[len++] = inst;
+  <% end %>
+
+  return len;
+}
+
+const evoasm_x64_inst *
+evoasm_x64_get_inst(evoasm_x64 *x64, unsigned index, bool ignore_features) {
+  const evoasm_x64_inst *inst = &<%= insts_var_name %>[index];
+  if(ignore_features || (inst->features & ~x64->features) == 0) return inst;
+  return NULL;
+}
+
+static evoasm_arch_cls evoasm_x64_cls = {
+  EVOASM_ARCH_X64,
+  EVOASM_X64_N_INSTS,
+  EVOASM_X64_N_PARAMS,
+  15,
+  (evoasm_arch_insts_func) evoasm_x64_insts,
+};
+
+
+evoasm_success
+evoasm_x64_init(evoasm_x64 *x64) {
+  static evoasm_x64 zero_x64 = {0};
+  evoasm_arch *arch = (evoasm_arch *) x64;
+  *x64 = zero_x64;
+
+  evoasm_arch_init(arch, &evoasm_x64_cls);
+  EVOASM_TRY(cpuid_failed, evoasm_x64_load_cpuid, x64);
+
+  evoasm_x64_reg_type_sizes[EVOASM_X64_REG_TYPE_GP] = 8;
+
+#ifdef EVOASM_X64_ENABLE_AVX512
+  uint64_t avx512 = EVOASM_X64_FEATURE_AVX512F |
+                    EVOASM_X64_FEATURE_AVX512DQ |
+                    EVOASM_X64_FEATURE_AVX512IFMA |
+                    EVOASM_X64_FEATURE_AVX512PF |
+                    EVOASM_X64_FEATURE_AVX512ER |
+                    EVOASM_X64_FEATURE_AVX512CD |
+                    EVOASM_X64_FEATURE_AVX512BW |
+                    EVOASM_X64_FEATURE_AVX512VL;
+
+  if(x64->features & avx512) {
+    evoasm_x64_reg_type_sizes[EVOASM_X64_REG_TYPE_XMM] = 64;
+    evoasm_x64_reg_type_sizes[EVOASM_X64_REG_TYPE_ZMM] = 64;
+  }
+  else
+#endif
+  if(x64->features & EVOASM_X64_FEATURE_AVX2) {
+    evoasm_x64_reg_type_sizes[EVOASM_X64_REG_TYPE_XMM] = 32;
+  } else {
+    evoasm_x64_reg_type_sizes[EVOASM_X64_REG_TYPE_XMM] = 16;
+  }
+  return true;
+
+cpuid_failed:
+  evoasm_arch_destroy(arch);
+  return false;
+}
+
+void
+evoasm_x64_destroy(evoasm_x64 *x64) {
+  evoasm_arch *arch = (evoasm_arch *) x64;
+  evoasm_arch_destroy(arch);
+}
+
+<% if options[:ruby] %>
+
+extern VALUE evoasm_cX64Instruction;
+
+static ID _rb_x64_inst_ids[<%= insts.size %>];
+static ID _rb_x64_reg_ids[<%= reg_names.n %>];
+static ID _rb_x64_param_ids[<%= param_names.n %>];
+static ID _rb_x64_reg_type_ids[<%= Evoasm::Gen::X64::REGISTERS.size %>];
+static ID _rb_x64_operand_type_ids[<%= Evoasm::Gen::X64::REGISTERS.size %>];
+
+ID *rb_x64_inst_ids =_rb_x64_inst_ids ;
+ID *rb_x64_reg_ids = _rb_x64_reg_ids;
+ID *rb_x64_param_ids = _rb_x64_param_ids;
+ID *rb_x64_operand_type_ids= _rb_x64_operand_type_ids;
+ID *rb_x64_reg_type_ids = _rb_x64_reg_type_ids;
+
+void evoasm_x64_ruby_define_consts() {
+
+<% Evoasm::Gen::X64::Inst::OPERAND_TYPES.each_with_index do |operand_type, index| %>
+  rb_x64_operand_type_ids[<%= index %>] = rb_intern("<%= operand_type %>");
+<% end %>
+
+
+<% Evoasm::Gen::X64::REGISTERS.keys.each_with_index do |reg_type, index| %>
+  rb_x64_reg_type_ids[<%= index %>] = rb_intern("<%= reg_type.to_s %>");
+<% end %>
+
+<% param_names.each do |name, index| %>
+  rb_x64_param_ids[<%= index %>] = rb_intern("<%= name.to_s %>");
+<% end %>
+
+<% features.each do |name, index| %>
+  rb_define_const(evoasm_cX64Instruction,
+      "FEATURE_<%= name.upcase %>",
+      INT2FIX(<%= feature_name_to_c name %>));
+<% end %>
+
+<% inst_flags.each do |name, index| %>
+  rb_define_const(evoasm_cX64Instruction,
+      "FLAG_<%= name.upcase %>",
+      INT2FIX(<%= inst_flag_to_c name %>));
+<% end %>
+
+<% insts.each_with_index do |inst, index| %>
+  rb_x64_inst_ids[<%= index %>] = rb_intern("<%= inst.name.to_s %>");
+<% end %>
+
+<% reg_names.each do |name, index| %>
+  rb_x64_reg_ids[<%= index %>] = rb_intern("<%= name =~ /^\d/ ? 'R' : '' %><%= name.to_s %>");
+<% end %>
+}
+<% end %>

data/data/templates/evoasm-x64.h.erb

@@ -0,0 +1,126 @@
+/* vim: set filetype=c: */
+/* AUTOGENERATED FILE, DO NOT EDIT */
+
+#pragma once
+
+#include "evoasm.h"
+#include "evoasm-util.h"
+
+#include <stdint.h>
+
+<%= features.to_c %>
+
+<%= inst_flags.to_c %>
+
+<%= exceptions.to_c %>
+
+<%= reg_types.to_c typedef: false %>
+
+extern uint8_t evoasm_x64_reg_type_sizes[EVOASM_X64_N_REG_TYPES];
+
+<%= reg_names.to_c %>
+
+static inline enum evoasm_x64_reg_type
+evoasm_x64_reg_type(evoasm_x64_reg_id reg) {
+  switch(reg) {
+<% Evoasm::Gen::X64::REGISTERS.each do |reg_type, regs| %>
+  <% regs.each do |reg| %>
+    case <%= reg_name_to_c reg %>: return <%= reg_type_to_c reg_type %>;
+  <% end %>
+<% end %>
+    default: evoasm_assert_not_reached();
+  }
+}
+
+<%= param_names.to_c %>
+
+typedef enum {
+<% insts.each do |inst| %>
+  <%= inst_name_to_c inst %> = <%= inst.index %>,
+<% end %>
+  EVOASM_X64_N_INSTS = <%= insts.size %>,
+} evoasm_x64_inst_id;
+
+typedef struct {
+  _EVOASM_ARCH_PARAMS_HEADER
+  evoasm_arch_param_val vals[EVOASM_X64_N_PARAMS];
+} evoasm_x64_params;
+
+_Static_assert(EVOASM_X64_N_PARAMS <= EVOASM_ARCH_MAX_PARAMS, "Too much parameters. Redeclar EVOASM_ARCH_MAX_PARAMS and evoasm_arch_params_bitmap.");
+
+typedef struct {
+  evoasm_arch base;
+  uint64_t features;
+} evoasm_x64;
+
+<%= operand_types.to_c %>
+
+<%= bit_masks.to_c %>
+#define <%= bit_mask_to_c 0..63 %> (<%= bit_mask_to_c 0..31 %> | <%= bit_mask_to_c 32..63 %>)
+#define <%= bit_mask_to_c 0..127 %> (<%= bit_mask_to_c 0..63 %> | <%= bit_mask_to_c 64..127 %>)
+
+typedef struct {
+  unsigned acc_r: 1;
+  unsigned acc_w: 1;
+  unsigned acc_u: 1;
+  unsigned acc_c: 1;
+  unsigned implicit: 1;
+  unsigned param_idx: 5;
+  unsigned type: EVOASM_X64_OPERAND_TYPE_BITSIZE;
+  unsigned size: EVOASM_OPERAND_SIZE_BITSIZE_WITH_N;
+  unsigned reg_id: EVOASM_X64_REG_BITSIZE_WITH_N;
+  unsigned reg_type: EVOASM_X64_REG_TYPE_BITSIZE_WITH_N;
+  unsigned acc_w_mask: EVOASM_X64_BIT_MASK_BITSIZE;
+} evoasm_x64_operand;
+
+typedef struct {
+  evoasm_inst base;
+  uint64_t features;
+  evoasm_x64_operand *operands;
+  uint8_t n_operands;
+  uint32_t exceptions;
+  uint32_t flags;
+} evoasm_x64_inst;
+
+#define EVOASM_X64_ENC(inst) \
+  EVOASM_TRY(enc_failed, evoasm_x64_##inst, x64, params.vals, (evoasm_bitmap *) &params.set)
+
+#define EVOASM_X64_SET(param, val) \
+  evoasm_arch_params_set(params.vals, (evoasm_bitmap *) &params.set, param, val)
+
+#define EVOASM_X64_UNSET(param) \
+  evoasm_arch_params_unset(params.vals, (evoasm_bitmap *) &params.set, param)
+
+typedef enum {
+  EVOASM_X64_ABI_SYSV
+} evoasm_x64_abi;
+
+void
+evoasm_x64_destroy(evoasm_x64 *x64);
+
+evoasm_success
+evoasm_x64_init(evoasm_x64 *x64);
+
+evoasm_success
+evoasm_x64_func_prolog(evoasm_x64 *x64, evoasm_buf *buf, evoasm_x64_abi abi);
+
+evoasm_success
+evoasm_x64_func_epilog(evoasm_x64 *x64, evoasm_buf *buf, evoasm_x64_abi abi);
+
+const evoasm_x64_inst *
+evoasm_x64_get_inst(evoasm_x64 *x64, unsigned index, bool ignore_features);
+
+<% insts.each do |inst| %>
+<%= func_prototype_to_c(inst.name, static: false) %>;
+<% end %>
+<% if options[:ruby] %>
+
+#include <ruby.h>
+
+extern ID *rb_x64_inst_ids;
+extern ID *rb_x64_reg_ids;
+extern ID *rb_x64_param_ids;
+extern ID *rb_x64_operand_type_ids;
+extern ID *rb_x64_reg_type_ids;
+void evoasm_x64_ruby_define_consts();
+<% end %>

data/evoasm.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'evoasm/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "evoasm"
+  spec.version       = Evoasm::VERSION
+  spec.authors       = ["Julian Aron Prenner (furunkel)"]
+  spec.email         = ["furunkel@polyadic.com"]
+  spec.summary       = %q{An AIMGP (Automatic Induction of Machine code by Genetic Programming) engine}
+  spec.homepage      = "https://github.com/furunkel/evoasm/"
+  spec.license       = "MPL-2.0"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.extensions    = spec.files.grep(%r{extconf.rb})
+
+  spec.add_dependency "pry", "~> 0.10"
+  spec.add_dependency "pastel", "~> 0.6"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake-compiler", "~> 0.9"
+  spec.add_development_dependency 'erubis', '~> 2.6'
+  spec.add_development_dependency "minitest", "~> 5.8"
+end

data/examples/abs.yml

@@ -0,0 +1,20 @@
+instructions:
+  grep_v: cmov
+  reg_types: [gp]
+examples:
+  1: 1
+  -1: 1
+  2: 2
+  -2: 2
+  100: 100
+  -100: 100
+  23: 23
+  1024: 1024
+  -1024: 1024
+  200000: 200000
+  -200000: 200000
+  1234: 1234
+  -1234: 1234
+
+program_size: 1..5
+population_size: 1600

data/examples/popcnt.yml

@@ -0,0 +1,17 @@
+instructions:
+  grep_v: 'popc'
+  reg_types: [gp]
+examples:
+  0b0: 0
+  0b1: 1
+  0b110: 2
+  0b101: 2
+  0b111: 3
+  0b100: 1
+  0b101010: 3
+  0b1010: 2
+  0b10000: 1
+  0b100001: 2
+  0b101011: 4
+program_size: 20..30
+population_size: 1600

data/examples/sym_reg.yml

@@ -0,0 +1,26 @@
+instructions:
+  reg_types: [xmm]
+  grep: (add|mul|sqrt).*?sd
+# sqrt(x**3 + 2 * x)
+examples:
+  0.0: 0.0
+  0.5: 1.0606601717798212
+  1.0: 1.7320508075688772
+  1.5: 2.5248762345905194
+  2.0: 3.4641016151377544
+  2.5: 4.541475531146237
+  3.0: 5.744562646538029
+  3.5: 7.0622234459127675
+  4.0: 8.48528137423857
+  4.5: 10.00624804809475
+  5.0: 11.61895003862225
+kernel_size: 5..15
+program_size: 1
+population_size: 1600
+max_loss: 0.0
+parameters: [reg0, reg1, reg2, reg3]
+domains:
+  reg0: &regs [XMM0, XMM1, XMM2, XMM3]
+  reg1: *regs
+  reg2: *regs
+  reg3: *regs

data/exe/evoasm-search

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# filetype=ruby
+
+begin
+  require 'evoasm'
+  require 'evoasm/cli'
+rescue LoadError
+  $LOAD_PATH.unshift File.expand_path File.join(__dir__, '../lib')
+  retry
+end
+
+search = Evoasm::Cli::Search.new ARGV[0], ARGV[1..-1]
+search.start!

data/ext/evoasm_ext/evoasm-alloc.c

@@ -0,0 +1,145 @@
+#include "evoasm-alloc.h"
+
+#include <stdlib.h>
+#include <errno.h>
+
+void *
+evoasm_malloc(size_t size) {
+  void *ptr = malloc(size);
+  if(EVOASM_UNLIKELY(!ptr)) {
+    evoasm_set_error(EVOASM_ERROR_TYPE_MEMORY, EVOASM_ERROR_CODE_NONE,
+      NULL, "Allocationg %zu bytes via malloc failed", size);
+    return NULL;
+  }
+  return ptr;
+}
+
+void *
+evoasm_calloc(size_t n, size_t size) {
+  void *ptr = calloc(n, size);
+
+  if(EVOASM_UNLIKELY(!ptr)) {
+    evoasm_set_error(EVOASM_ERROR_TYPE_MEMORY, EVOASM_ERROR_CODE_NONE,
+      NULL, "Allocationg %zux%zu () bytes via calloc failed", n, size, n * size);
+    return NULL;
+  }
+  return ptr;
+}
+
+void *
+evoasm_realloc(void *ptr, size_t size) {
+  void *new_ptr = realloc(ptr, size);
+
+  if(EVOASM_UNLIKELY(!ptr)) {
+    evoasm_set_error(EVOASM_ERROR_TYPE_MEMORY, EVOASM_ERROR_CODE_NONE,
+        NULL, "Allocating %zu bytes via realloc failed", size);
+    return NULL;
+  }
+  return new_ptr;
+}
+
+void
+evoasm_free(void *ptr) {
+  free(ptr);
+}
+
+void *
+evoasm_mmap(size_t size, void *p) {
+  /* Note that mmap considers the pointer passed soley as a hint address
+   * and returns a valid address (possibly at a different address) in any case.
+   * VirtualAlloc, on the other hand, will return NULL if the address is
+   * not available
+   */
+    void *mem;
+
+#if defined(_WIN32)
+retry:
+    mem = VirtualAlloc(p, size, MEM_COMMIT, PAGE_READWRITE);
+    if(mem == NULL) {
+      if(p != NULL) {
+        goto retry;
+      } else {
+        goto error;
+      }
+    }
+    return mem;
+#elif defined(_POSIX_VERSION)
+    mem = mmap(p, size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+    if(mem == MAP_FAILED) {
+      goto error;
+    }
+#else
+#error
+#endif
+  return mem;
+
+error:
+    evoasm_set_error(EVOASM_ERROR_TYPE_MEMORY, EVOASM_ERROR_CODE_NONE,
+        NULL, "Allocationg %zu bytes via mmap failed: %s", size, strerror(errno));
+    return NULL;
+}
+
+evoasm_success
+evoasm_munmap(void *p, size_t size) {
+  bool ret;
+#if defined(_WIN32)
+  ret = VirtualFree(p, size, MEM_DECOMMIT);
+#elif defined(_POSIX_VERSION)
+  ret = (munmap(p, size) == 0);
+#else
+#  error
+#endif
+
+  if(!ret) {
+    evoasm_set_error(EVOASM_ERROR_TYPE_MEMORY, EVOASM_ERROR_CODE_NONE,
+        NULL, "Unmapping %zu bytes via munmap failed: %s", size, strerror(errno));
+  }
+
+  return ret;
+}
+
+evoasm_success
+evoasm_mprot(void *p, size_t size, int mode)
+{
+
+#if defined(_WIN32)
+  if(VirtualProtect(p, size, mode, NULL) != 0) {
+    goto error;
+  }
+#elif defined(_POSIX_VERSION)
+  if(mprotect(p, size, mode) != 0) {
+    goto error;
+  }
+#else
+#error
+#endif
+  return true;
+
+error:
+  evoasm_set_error(EVOASM_ERROR_TYPE_MEMORY, EVOASM_ERROR_CODE_NONE,
+      NULL, "Changing memory protection failed: %s", strerror(errno));
+  return false;
+}
+
+static long _evoasm_page_size = -1;
+
+static long
+evoasm_query_page_size() {
+#if defined(_WIN32)
+  SYSTEM_INFO si;
+  GetSystemInfo(&si);
+  return si.dwPageSize;
+#elif defined(_POSIX_VERSION)
+  return sysconf(_SC_PAGESIZE);
+#else
+#error
+#endif
+}
+
+long
+evoasm_page_size() {
+  if(_evoasm_page_size == -1) {
+    _evoasm_page_size = evoasm_query_page_size();
+  }
+  return _evoasm_page_size;
+}