asmjit 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c624450e0bd1c3f5275f6bab3417f3a147f90efb595c26ca58ae93dd6828aa74
-  data.tar.gz: 36fab728b2acc6bcca18b8fc415f4e7aca02ed919914f162242bba4f397533a3
+  metadata.gz: bcda0d9ba5d87e102ebf2fabf636aa07c3c8b24eca8c66c740fcb8700cd769cb
+  data.tar.gz: 4ecec0d43302ffce529cc54ed2a0c46d88035a589897b8a2ceaf3b022dc017a9
 SHA512:
-  metadata.gz: 0ff819f0ecbc9750048a3ac529275ee49846b074c30097b182553a99733d149aa14096cf191e6ce50856a0d26a242c020c715801fab1442e2fc9666991106091
-  data.tar.gz: 62e66a1ab2106832491749cef583d5248649eaf8c77bd29649d4afd39f2f00857a9a5e04f3fe192b38580fa57133b92196e733b3d3b077cf59dc61f2b48e2fc3
+  metadata.gz: 1e66beaefdfaa62ff6d9b27a3b984192cc3a7c6906f77ea96a3de303c7e342196b0aef7cd1f00596883720b490403bed9bd9e09ce526fca2c11e1700c9ec1fc3
+  data.tar.gz: b649c8f79ab822fb77beb840be1a8174fd71ba7e131320d80d87e8ae79539a18095311eb80492a0901182f4a4aa55c4496e3afd6254514049409829222e9291c

data/Gemfile.lock

@@ -1,11 +1,12 @@
 PATH
   remote: .
   specs:
-    asmjit (0.1.0)
+    asmjit (0.2.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    hatstone (1.0.0)
     minitest (5.15.0)
     rake (13.0.6)
     rake-compiler (1.2.0)
@@ -16,6 +17,7 @@ PLATFORMS
 
 DEPENDENCIES
   asmjit!
+  hatstone
   minitest (~> 5.0)
   rake (~> 13.0)
   rake-compiler

data/README.md

@@ -1,8 +1,6 @@
-# Asmjit
+# AsmJit Ruby
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/asmjit`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+Ruby bindings for [AsmJit](https://asmjit.com/), a lightweight library for machine code generation.
 
 ## Installation
 
@@ -24,9 +22,12 @@ Or install it yourself as:
 
 ```
 f = AsmJIT.assemble do |a|
-  a.mov(:eax, 1)
-  a.ret()
-end.to_func
+  a.mov :eax, 123
+  a.ret
+end.to_fiddle
+
+f.call
+# => 123
 ```
 
 ## Development

data/asmjit.gemspec

@@ -29,9 +29,5 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
   spec.extensions = ["ext/asmjit/extconf.rb"]
 
-  # Uncomment to register a new dependency of your gem
-  # spec.add_dependency "example-gem", "~> 1.0"
-
-  # For more information and examples about making a new gem, check out our
-  # guide at: https://bundler.io/guides/creating_gem.html
+  spec.add_development_dependency "hatstone"
 end

data/ext/asmjit/asmjit.cc

@@ -9,6 +9,9 @@ using namespace asmjit;
 
 static VALUE rb_mAsmjit;
 static VALUE rb_eAsmJITError;
+static VALUE rb_cOperand;
+static VALUE cX86Reg;
+static VALUE cX86Mem;
 
 static JitRuntime jit_runtime;
 
@@ -54,17 +57,8 @@ VALUE code_holder_initialize(VALUE self) {
     TypedData_Get_Struct(self, CodeHolderWrapper, &code_holder_type, wrapper);
 
     CodeHolder *code = wrapper->code;
-
     code->init(jit_runtime.environment());
 
-    //x86::Assembler a(code);
-
-    //a.mov(x86::eax, 1);
-    //a.ret();
-
-    //int (*fn)(void);
-    //Error err = jit_runtime.add(&fn, code);
-
     return self;
 }
 
@@ -80,24 +74,162 @@ VALUE code_holder_to_ptr(VALUE self) {
     return ULL2NUM(uintptr_t(fn));
 }
 
-struct x86AssemblerWrapper {
-    x86::Assembler *assembler;
+#define rb_define_method_id_original rb_define_method_id
+
+VALUE code_holder_define_method(VALUE self, VALUE mod, VALUE name, VALUE arity_val) {
+    CodeHolderWrapper *wrapper;
+    TypedData_Get_Struct(self, CodeHolderWrapper, &code_holder_type, wrapper);
+
+    CodeHolder *code = wrapper->code;
+
+    int arity = FIX2INT(arity_val);
+    ID id = rb_sym2id(name);
+
+    VALUE (*fn)(ANYARGS);
+    jit_runtime.add(&fn, code);
+
+    // avoid cxxanyargs
+#undef rb_define_method_id
+    rb_define_method_id(mod, id, fn, arity);
+
+    return name;
+}
+
+VALUE code_holder_binary(VALUE self) {
+    CodeHolderWrapper *wrapper;
+    TypedData_Get_Struct(self, CodeHolderWrapper, &code_holder_type, wrapper);
+
+    CodeHolder *code = wrapper->code;
+
+    CodeBuffer buffer = code->sectionById(0)->buffer();
+    return rb_str_new(
+            reinterpret_cast<const char *>(buffer.data()),
+            buffer.size()
+            );
+}
+
+static const rb_data_type_t operand_type = {
+    .wrap_struct_name = "AsmJIT::Operand",
+    .function = {
+        .dmark = NULL,
+        .dfree = RUBY_DEFAULT_FREE,
+        .dsize = NULL,
+    },
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+struct OperandWrapper {
+    Operand opnd;
+};
+
+static VALUE build_register(const char *c_name, x86::Reg reg) {
+    OperandWrapper *wrapper = static_cast<OperandWrapper *>(xmalloc(sizeof(OperandWrapper)));
+    wrapper->opnd = reg;
+
+    VALUE name = ID2SYM(rb_intern(c_name));
+    VALUE obj = TypedData_Wrap_Struct(cX86Reg, &operand_type, wrapper);
+    rb_iv_set(obj, "@name", name);
+    return obj;
+}
+
+static VALUE build_label(Label label) {
+    OperandWrapper *wrapper = static_cast<OperandWrapper *>(xmalloc(sizeof(OperandWrapper)));
+    wrapper->opnd = label;
+
+    VALUE obj = TypedData_Wrap_Struct(cX86Reg, &operand_type, wrapper);
+    return obj;
+}
+
+
+static Operand opnd_get(VALUE val) {
+    OperandWrapper *wrapper;
+    TypedData_Get_Struct(val, OperandWrapper, &operand_type, wrapper);
+    return wrapper->opnd;
+}
+
+static Label label_get(VALUE val) {
+    Operand opnd = opnd_get(val);
+    if (!opnd.isLabel()) {
+        rb_raise(rb_eTypeError, "operand is not label");
+    }
+    return opnd.as<Label>();
+}
+
+static x86::Reg x86_reg_get(VALUE val) {
+    Operand opnd = opnd_get(val);
+    if (!opnd.isReg()) {
+        rb_raise(rb_eTypeError, "operand is not reg");
+    }
+    return opnd.as<x86::Reg>();
+}
+
+static x86::Mem x86_mem_get(VALUE val) {
+    Operand opnd = opnd_get(val);
+    if (!opnd.isMem()) {
+        rb_raise(rb_eTypeError, "operand is not mem");
+    }
+    return opnd.as<x86::Mem>();
+}
+
+static VALUE x86_ptr(VALUE _self, VALUE regv, VALUE offsetv, VALUE sizev) {
+    OperandWrapper *wrapper = static_cast<OperandWrapper *>(xmalloc(sizeof(OperandWrapper)));
+
+    x86::Reg reg = x86_reg_get(regv);
+    if (!reg.isGp()) {
+        rb_raise(rb_eAsmJITError, "reg must be Gp");
+    }
+    int32_t offset = NUM2INT(offsetv);
+    uint32_t size = NUM2UINT(sizev);
+    x86::Mem mem = x86::ptr(reg.as<x86::Gp>(), offset, size);
+    wrapper->opnd = mem;
+
+    VALUE obj = TypedData_Wrap_Struct(cX86Mem, &operand_type, wrapper);
+    return obj;
+}
+
+static VALUE build_registers_hash() {
+    VALUE hash = rb_hash_new();
+
+#define REGISTER(name) rb_hash_aset(hash, ID2SYM(rb_intern(#name)), build_register((#name), x86::name))
+
+    REGISTER(eax);
+    REGISTER(ebx);
+    REGISTER(ecx);
+    REGISTER(edx);
+    REGISTER(edi);
+    REGISTER(esi);
+
+    REGISTER(rax);
+    REGISTER(rbx);
+    REGISTER(rcx);
+    REGISTER(rdx);
+    REGISTER(rdi);
+    REGISTER(rsi);
+
+#undef REGISTER
+
+    return hash;
+}
+
+struct BaseEmitterWrapper {
+    BaseEmitter *emitter;
     VALUE code_holder;
 };
 
 void x86_assembler_free(void *data) {
-    x86AssemblerWrapper *wrapper = static_cast<x86AssemblerWrapper *>(data);
-    delete wrapper->assembler;
+    BaseEmitterWrapper *wrapper = static_cast<BaseEmitterWrapper *>(data);
+    delete wrapper->emitter;
     xfree(wrapper);
 }
 
 void x86_assembler_mark(void *data) {
-    x86AssemblerWrapper *wrapper = static_cast<x86AssemblerWrapper *>(data);
+    BaseEmitterWrapper *wrapper = static_cast<BaseEmitterWrapper *>(data);
     rb_gc_mark(wrapper->code_holder);
 }
 
-static const rb_data_type_t x86_assembler_type = {
-    .wrap_struct_name = "AsmJIT::Assembler",
+static const rb_data_type_t base_emitter_type = {
+    .wrap_struct_name = "AsmJIT::BaseEmitter",
     .function = {
         .dmark = NULL,
         .dfree = x86_assembler_free,
@@ -107,59 +239,73 @@ static const rb_data_type_t x86_assembler_type = {
     .flags = RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
-VALUE x86_assembler_alloc(VALUE self) {
-    x86AssemblerWrapper *wrapper = static_cast<x86AssemblerWrapper *>(xmalloc(sizeof(CodeHolderWrapper)));
-    wrapper->assembler = NULL;
-    wrapper->code_holder = Qnil;
-
-    return TypedData_Wrap_Struct(self, &x86_assembler_type, wrapper);
-}
-
-VALUE x86_assembler_initialize(VALUE self, VALUE code_holder) {
-    x86AssemblerWrapper *wrapper;
-    TypedData_Get_Struct(self, x86AssemblerWrapper, &x86_assembler_type, wrapper);
+VALUE x86_assembler_new(VALUE self, VALUE code_holder) {
+    BaseEmitterWrapper *wrapper = static_cast<BaseEmitterWrapper *>(xmalloc(sizeof(CodeHolderWrapper)));
 
     CodeHolderWrapper *code_wrapper;
     TypedData_Get_Struct(code_holder, CodeHolderWrapper, &code_holder_type, code_wrapper);
 
+    x86::Assembler *assembler = new x86::Assembler(code_wrapper->code);
+    assembler->addDiagnosticOptions(DiagnosticOptions::kValidateAssembler);
+
     wrapper->code_holder = code_holder;
-    wrapper->assembler = new x86::Assembler(code_wrapper->code);
+    wrapper->emitter = assembler;
 
-    return self;
+    return TypedData_Wrap_Struct(self, &base_emitter_type, wrapper);
 }
 
 Operand parse_operand(VALUE val) {
     if (FIXNUM_P(val)) {
         return Imm(NUM2LL(val));
-    } else if (RB_TYPE_P(val, T_SYMBOL)) {
-        if (val == ID2SYM(rb_intern("eax"))) {
-            return x86::eax;
-        } else if (val == ID2SYM(rb_intern("rax"))) {
-            return x86::rax;
-        }
+    } else if (rb_obj_is_kind_of(val, rb_cOperand)) {
+        return opnd_get(val);
     }
     rb_raise(rb_eAsmJITError, "bad operand: %" PRIsVALUE, val);
 }
 
-VALUE x86_assembler_emit(int argc, VALUE* argv, VALUE self) {
-    x86AssemblerWrapper *wrapper;
-    TypedData_Get_Struct(self, x86AssemblerWrapper, &x86_assembler_type, wrapper);
+VALUE base_emitter_new_label(VALUE self) {
+    BaseEmitterWrapper *wrapper;
+    TypedData_Get_Struct(self, BaseEmitterWrapper, &base_emitter_type, wrapper);
+    BaseEmitter *emitter = wrapper->emitter;
+
+    Label label = emitter->newLabel();
+    return build_label(label);
+}
+
+VALUE base_emitter_bind(VALUE self, VALUE labelv) {
+    BaseEmitterWrapper *wrapper;
+    TypedData_Get_Struct(self, BaseEmitterWrapper, &base_emitter_type, wrapper);
+    BaseEmitter *emitter = wrapper->emitter;
 
-    x86::Assembler *assembler = wrapper->assembler;
+    Label label = label_get(labelv);
+
+    int err = emitter->bind(label);
+    if (err) {
+        rb_raise(rb_eAsmJITError, "error binding label");
+    }
+
+    return labelv;
+}
+
+VALUE base_emitter_emit(int argc, VALUE* argv, VALUE self) {
+    BaseEmitterWrapper *wrapper;
+    TypedData_Get_Struct(self, BaseEmitterWrapper, &base_emitter_type, wrapper);
+
+    BaseEmitter *emitter = wrapper->emitter;
 
     if (argc < 1) return Qnil;
     if (argc > 7) return Qnil;
 
     VALUE insn_name = argv[0];
-    InstId inst_id = InstAPI::stringToInstId(assembler->arch(), RSTRING_PTR(insn_name), RSTRING_LEN(insn_name));
+    Check_Type(insn_name, T_STRING);
+    InstId inst_id = InstAPI::stringToInstId(emitter->arch(), RSTRING_PTR(insn_name), RSTRING_LEN(insn_name));
 
     Operand operands[6];
     for (int i = 0; i < argc - 1; i++) {
         operands[i] = parse_operand(argv[i + 1]);
     }
 
-    //assembler->emit(inst_id);
-    assembler->emitOpArray(inst_id, &operands[0], argc - 1);
+    emitter->emitOpArray(inst_id, &operands[0], argc - 1);
 
     return self;
 }
@@ -177,17 +323,32 @@ Init_asmjit(void)
 
     rb_eAsmJITError = rb_define_class_under(rb_mAsmjit, "Error", rb_eStandardError);
 
-	VALUE cCodeHolder = rb_define_class_under(rb_mAsmjit, "CodeHolder", rb_cObject);
-	rb_define_alloc_func(cCodeHolder, code_holder_alloc);
-	rb_define_method(cCodeHolder, "initialize", code_holder_initialize, 0);
-	rb_define_method(cCodeHolder, "to_ptr", code_holder_to_ptr, 0);
+    VALUE cCodeHolder = rb_define_class_under(rb_mAsmjit, "CodeHolder", rb_cObject);
+    rb_define_alloc_func(cCodeHolder, code_holder_alloc);
+    rb_define_method(cCodeHolder, "initialize", code_holder_initialize, 0);
+    rb_define_method(cCodeHolder, "to_ptr", code_holder_to_ptr, 0);
+    rb_define_method(cCodeHolder, "def_method", code_holder_define_method, 3);
+    rb_define_method(cCodeHolder, "binary", code_holder_binary, 0);
+
+    VALUE rb_mX86 = rb_define_module_under(rb_mAsmjit, "X86");
+
+    VALUE rb_cBaseEmitter = rb_define_class_under(rb_mAsmjit, "BaseEmitter", rb_cObject);
+    rb_undef_alloc_func(rb_cBaseEmitter);
+    rb_define_method(rb_cBaseEmitter, "_emit", base_emitter_emit, -1);
+    rb_define_method(rb_cBaseEmitter, "new_label", base_emitter_new_label, 0);
+    rb_define_method(rb_cBaseEmitter, "bind", base_emitter_bind, 1);
+
+    VALUE cX86Assembler = rb_define_class_under(rb_mX86, "Assembler", rb_cBaseEmitter);
+    rb_define_singleton_method(cX86Assembler, "new", x86_assembler_new, 1);
+
+    rb_cOperand = rb_define_class_under(rb_mAsmjit, "Operand", rb_cObject);
+    rb_undef_alloc_func(rb_cOperand);
 
-	VALUE rb_mX86 = rb_define_module_under(rb_mAsmjit, "X86");
+    cX86Reg = rb_define_class_under(rb_mX86, "Reg", rb_cOperand);
+    rb_define_attr(cX86Reg, "name", 1, 0);
 
-	VALUE cX86Assembler = rb_define_class_under(rb_mX86, "Assembler", rb_cObject);
-	rb_define_alloc_func(cX86Assembler, x86_assembler_alloc);
-	rb_define_method(cX86Assembler, "initialize", x86_assembler_initialize, 1);
-	rb_define_method(cX86Assembler, "emit", x86_assembler_emit, -1);
+    cX86Mem = rb_define_class_under(rb_mX86, "Mem", rb_cOperand);
+    rb_define_singleton_method(cX86Mem, "new", x86_ptr, 3);
 
     VALUE instructions = rb_ary_new();
 
@@ -203,4 +364,5 @@ Init_asmjit(void)
     }
 
     rb_define_const(rb_mX86, "INSTRUCTIONS", instructions);
+    rb_define_const(rb_mX86, "REGISTERS", build_registers_hash());
 }

data/lib/asmjit/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AsmJIT
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/asmjit.rb

@@ -3,14 +3,80 @@
 require_relative "asmjit/version"
 require_relative "asmjit/asmjit"
 
+AsmJit = AsmJIT
 module AsmJIT
+  def self.assemble
+    code = CodeHolder.new
+    yield code.assembler
+    code
+  end
+
+  class CodeHolder
+    def assembler
+      X86::Assembler.new(self)
+    end
+
+    def to_fiddle(inputs: nil, output: nil)
+      ptr = to_ptr
+
+      Fiddle::Function.new(
+        ptr,
+        inputs || [],
+        output || Fiddle::TYPE_INT
+      )
+    end
+
+    def def_module(arity, method_name: :call)
+      mod = Module.new
+      self.def_method(mod, method_name, arity)
+      mod
+    end
+
+    def def_class(arity, method_name: :call)
+      mod = Class.new
+      self.def_method(mod, method_name, arity)
+      mod
+    end
+  end
+
   module X86
+    module Helpers
+      extend self
+
+      def parse_operand(arg)
+        if Symbol === arg && reg = REGISTERS[arg]
+          reg
+        else
+          arg
+        end
+      end
+    end
+
+    class << self
+      def ptr(base, offset, size)
+        X86::Mem.new(Helpers.parse_operand(base), offset, size)
+      end
+
+      def qword_ptr(base, offset)
+        ptr(base, offset, 8)
+      end
+    end
+
     class Assembler
+      def emit(*args)
+        _emit(*(args.map { |arg| Helpers.parse_operand(arg) }))
+      end
+
       INSTRUCTIONS.each do |name|
         define_method(name) do |*args|
           emit(name, *args)
         end
       end
     end
+    class Reg
+      def inspect
+        "#<#{self.class} #{name}>"
+      end
+    end
   end
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: asmjit
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - John Hawthorn
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-05-07 00:00:00.000000000 Z
-dependencies: []
+date: 2022-09-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hatstone
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 'Ruby wrapper for asmjit: a lightweight library for machine code generation'
 email:
 - john@hawthorn.email
@@ -53,7 +67,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: 'Ruby wrapper for asmjit: a lightweight library for machine code generation'