asmjit 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de98dc21826687ba3eaf5dab23f2b223f87018bdede78fd6ba3d08c2e9378cac
-  data.tar.gz: 25f0372836707935c0dd32aa4ee711fd3a30823187c698cfdcc00a0918b1f847
+  metadata.gz: 841e0bc2866c0dc8be23dc5f79bd4fcf97dba35a516841932e0420beae3c0af2
+  data.tar.gz: b050d3e81b1616d2adc10ccd84d2a767e17102e409dd5fa4d0507ffa4483c9c9
 SHA512:
-  metadata.gz: b9827a4879f31537e28860448be8d042fc87a3018f4c1efdac2c2ba60484f2a42d10dfede47c79abddd4ccdbd4766db943421718c26ecba9d353bcb8b6b25f4c
-  data.tar.gz: 0ebbb002f38caa880aed25d78d592d08959923b614ddc0e9d33f951b47f508289462857c19e64295a7fffcdf47446ab19f4d027084c27a8c31d3c9839c9177bf
+  metadata.gz: fa3d2263a8a05e7420e1fa5c36b3af14aee7ee1bda312fa46cb866c5b6bafa5d14e7d0960cd8d4c20ef5c4771bb47dfa3505ab377a06dbb377317fe5edda03d7
+  data.tar.gz: ce9a931463e08ea916edc7b627bf4b41a56c538217fe659e0b9ebc864277d71799b4347efd9b0c8304435329b779c20c95c19b932f5915660cbcf8db4f608c12

data/Rakefile

@@ -4,10 +4,12 @@ require "bundler/gem_tasks"
 require "rake/testtask"
 
 Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  t.libs << "lib"
+  t.libs << "test" << "lib"
   t.test_files = FileList["test/**/test_*.rb"]
+  t.verbose = true
+  t.warning = true
 end
+task test: :compile
 
 require "rake/extensiontask"
 
@@ -17,4 +19,4 @@ Rake::ExtensionTask.new("asmjit") do |ext|
   ext.lib_dir = "lib/asmjit"
 end
 
-task default: %i[clobber compile test]
+task default: %i[test]

data/asmjit.gemspec

@@ -28,6 +28,4 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
   spec.extensions = ["ext/asmjit/extconf.rb"]
-
-  spec.add_development_dependency "hatstone"
 end

data/ext/asmjit/asmjit.cc

@@ -7,10 +7,14 @@ using namespace std;
 
 using namespace asmjit;
 
+static BaseEmitter *get_emitter(VALUE self);
+
 static VALUE rb_mAsmjit;
 static VALUE rb_eAsmJITError;
 static VALUE rb_cOperand;
 static VALUE cX86Reg;
+static VALUE cLabel;
+static VALUE cImm;
 static VALUE cX86Mem;
 
 static JitRuntime jit_runtime;
@@ -23,13 +27,32 @@ class RubyErrorHandler : public ErrorHandler {
 };
 RubyErrorHandler rubyErrorHandler;
 
+class RubyLogger : public Logger {
+    public:
+        RubyLogger(VALUE obj) : obj(obj) {}
+        VALUE obj;
+
+        Error _log(const char* data, size_t size) noexcept override {
+            VALUE string;
+            if (size == SIZE_MAX) {
+                string = rb_str_new_cstr(data);
+            } else {
+                string = rb_str_new(data, size);
+            }
+            rb_funcall(obj, rb_intern("<<"), 1, string);
+            return kErrorOk;
+        }
+};
+
 struct CodeHolderWrapper {
     CodeHolder *code;
+    RubyLogger *logger;
 };
 
 void code_holder_free(void *data) {
     CodeHolderWrapper *wrapper = static_cast<CodeHolderWrapper *>(data);
     delete wrapper->code;
+    delete wrapper->logger;
     xfree(wrapper);
 }
 
@@ -47,11 +70,41 @@ static const rb_data_type_t code_holder_type = {
 VALUE code_holder_alloc(VALUE self) {
     CodeHolderWrapper *wrapper = static_cast<CodeHolderWrapper *>(xmalloc(sizeof(CodeHolderWrapper)));
     wrapper->code = new CodeHolder();
+    wrapper->logger = NULL;
     wrapper->code->setErrorHandler(&rubyErrorHandler);
 
     return TypedData_Wrap_Struct(self, &code_holder_type, wrapper);
 }
 
+VALUE code_holder_set_logger(VALUE self, VALUE object) {
+    CodeHolderWrapper *wrapper;
+    TypedData_Get_Struct(self, CodeHolderWrapper, &code_holder_type, wrapper);
+
+    if (wrapper->logger) {
+        wrapper->code->resetLogger();
+        delete wrapper->logger;
+    }
+
+    if (RTEST(object)) {
+        wrapper->logger = new RubyLogger(object);
+        wrapper->logger->setFlags(FormatFlags::kHexImms);
+        wrapper->code->setLogger(wrapper->logger);
+    }
+
+    return object;
+}
+
+VALUE code_holder_get_logger(VALUE self) {
+    CodeHolderWrapper *wrapper;
+    TypedData_Get_Struct(self, CodeHolderWrapper, &code_holder_type, wrapper);
+
+    if (wrapper->logger) {
+        return wrapper->logger->obj;
+    } else {
+        return Qnil;
+    }
+}
+
 VALUE code_holder_initialize(VALUE self) {
     CodeHolderWrapper *wrapper;
     TypedData_Get_Struct(self, CodeHolderWrapper, &code_holder_type, wrapper);
@@ -133,21 +186,29 @@ static VALUE build_register(const char *c_name, x86::Reg reg) {
     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 VALUE operand_to_s(VALUE obj) {
+    Operand opnd = opnd_get(obj);
+    Arch arch = jit_runtime.arch();
+
+    const BaseEmitter *emitter = NULL;
+
+    VALUE emitterv = rb_iv_get(obj, "@emitter");
+    if (RTEST(emitterv)) {
+        emitter = get_emitter(emitterv);
+    }
+
+    String s;
+    Formatter::formatOperand(s, FormatFlags::kNone, emitter, arch, opnd);
+
+    return rb_str_new(s.data(), s.size());
+}
+
 static Label label_get(VALUE val) {
     Operand opnd = opnd_get(val);
     if (!opnd.isLabel()) {
@@ -188,17 +249,68 @@ static VALUE x86_ptr(VALUE _self, VALUE regv, VALUE offsetv, VALUE sizev) {
     return obj;
 }
 
+static VALUE imm_new(VALUE _self, VALUE val) {
+    Imm imm = Imm(NUM2LL(val));
+
+    OperandWrapper *wrapper = static_cast<OperandWrapper *>(xmalloc(sizeof(OperandWrapper)));
+    wrapper->opnd = imm;
+    return TypedData_Wrap_Struct(_self, &operand_type, wrapper);
+}
+
 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(ah);
+    REGISTER(bh);
+    REGISTER(ch);
+    REGISTER(dh);
+
+    REGISTER(al);
+    REGISTER(bl);
+    REGISTER(cl);
+    REGISTER(dl);
+    REGISTER(dil);
+    REGISTER(sil);
+    REGISTER(spl);
+    REGISTER(bpl);
+
+    REGISTER(r8b);
+    REGISTER(r9b);
+    REGISTER(r10b);
+    REGISTER(r11b);
+    REGISTER(r12b);
+    REGISTER(r13b);
+    REGISTER(r14b);
+    REGISTER(r15b);
+
+    REGISTER(ax);
+    REGISTER(bx);
+    REGISTER(cx);
+    REGISTER(dx);
+    REGISTER(di);
+    REGISTER(si);
+    REGISTER(sp);
+    REGISTER(bp);
+
+    REGISTER(r8w);
+    REGISTER(r9w);
+    REGISTER(r10w);
+    REGISTER(r11w);
+    REGISTER(r12w);
+    REGISTER(r13w);
+    REGISTER(r14w);
+    REGISTER(r15w);
+
     REGISTER(eax);
     REGISTER(ebx);
     REGISTER(ecx);
     REGISTER(edx);
     REGISTER(edi);
     REGISTER(esi);
+    REGISTER(esp);
+    REGISTER(ebp);
 
     REGISTER(r8d);
     REGISTER(r9d);
@@ -215,6 +327,8 @@ static VALUE build_registers_hash() {
     REGISTER(rdx);
     REGISTER(rdi);
     REGISTER(rsi);
+    REGISTER(rsp);
+    REGISTER(rbp);
 
     REGISTER(r8);
     REGISTER(r9);
@@ -257,6 +371,12 @@ static const rb_data_type_t base_emitter_type = {
     .flags = RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
+static BaseEmitter *get_emitter(VALUE self) {
+    BaseEmitterWrapper *wrapper;
+    TypedData_Get_Struct(self, BaseEmitterWrapper, &base_emitter_type, wrapper);
+    return wrapper->emitter;
+}
+
 VALUE x86_assembler_new(VALUE self, VALUE code_holder) {
     BaseEmitterWrapper *wrapper = static_cast<BaseEmitterWrapper *>(xmalloc(sizeof(CodeHolderWrapper)));
 
@@ -272,28 +392,21 @@ VALUE x86_assembler_new(VALUE self, VALUE code_holder) {
     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_obj_is_kind_of(val, rb_cOperand)) {
-        return opnd_get(val);
-    }
-    rb_raise(rb_eAsmJITError, "bad operand: %" PRIsVALUE, val);
-}
-
 VALUE base_emitter_new_label(VALUE self) {
-    BaseEmitterWrapper *wrapper;
-    TypedData_Get_Struct(self, BaseEmitterWrapper, &base_emitter_type, wrapper);
-    BaseEmitter *emitter = wrapper->emitter;
+    BaseEmitter *emitter = get_emitter(self);
 
     Label label = emitter->newLabel();
-    return build_label(label);
+
+    OperandWrapper *opnd_wrapper = static_cast<OperandWrapper *>(xmalloc(sizeof(OperandWrapper)));
+    opnd_wrapper->opnd = label;
+
+    VALUE obj = TypedData_Wrap_Struct(cLabel, &operand_type, opnd_wrapper);
+    rb_iv_set(obj, "@emitter", self);
+    return obj;
 }
 
 VALUE base_emitter_bind(VALUE self, VALUE labelv) {
-    BaseEmitterWrapper *wrapper;
-    TypedData_Get_Struct(self, BaseEmitterWrapper, &base_emitter_type, wrapper);
-    BaseEmitter *emitter = wrapper->emitter;
+    BaseEmitter *emitter = get_emitter(self);
 
     Label label = label_get(labelv);
 
@@ -306,10 +419,7 @@ VALUE base_emitter_bind(VALUE self, VALUE 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;
+    BaseEmitter *emitter = get_emitter(self);
 
     if (argc < 1) return Qnil;
     if (argc > 7) return Qnil;
@@ -320,7 +430,7 @@ VALUE base_emitter_emit(int argc, VALUE* argv, VALUE self) {
 
     Operand operands[6];
     for (int i = 0; i < argc - 1; i++) {
-        operands[i] = parse_operand(argv[i + 1]);
+        operands[i] = opnd_get(argv[i + 1]);
     }
 
     emitter->emitOpArray(inst_id, &operands[0], argc - 1);
@@ -348,6 +458,9 @@ Init_asmjit(void)
     rb_define_method(cCodeHolder, "def_method", code_holder_define_method, 3);
     rb_define_method(cCodeHolder, "binary", code_holder_binary, 0);
 
+    rb_define_method(cCodeHolder, "logger", code_holder_get_logger, 0);
+    rb_define_method(cCodeHolder, "logger=", code_holder_set_logger, 1);
+
     VALUE rb_mX86 = rb_define_module_under(rb_mAsmjit, "X86");
 
     VALUE rb_cBaseEmitter = rb_define_class_under(rb_mAsmjit, "BaseEmitter", rb_cObject);
@@ -361,6 +474,7 @@ Init_asmjit(void)
 
     rb_cOperand = rb_define_class_under(rb_mAsmjit, "Operand", rb_cObject);
     rb_undef_alloc_func(rb_cOperand);
+    rb_define_method(rb_cOperand, "to_s", operand_to_s, 0);
 
     cX86Reg = rb_define_class_under(rb_mX86, "Reg", rb_cOperand);
     rb_define_attr(cX86Reg, "name", 1, 0);
@@ -368,6 +482,11 @@ Init_asmjit(void)
     cX86Mem = rb_define_class_under(rb_mX86, "Mem", rb_cOperand);
     rb_define_singleton_method(cX86Mem, "new", x86_ptr, 3);
 
+    cImm = rb_define_class_under(rb_mAsmjit, "Imm", rb_cOperand);
+    rb_define_singleton_method(cImm, "new", imm_new, 1);
+
+    cLabel = rb_define_class_under(rb_mAsmjit, "Label", rb_cOperand);
+
     VALUE instructions = rb_ary_new();
 
     auto instid = x86::Inst::kIdNone;

data/ext/asmjit/extconf.rb

@@ -2,16 +2,16 @@
 
 require "mkmf"
 
-asmjit_dir = File.expand_path("asmjit/src/", __dir__)
+Dir.chdir __dir__ do
+  $srcs = [
+    Dir["*.cc"],
+    Dir["asmjit/src/**/*.cpp"]
+  ].flatten.map { |f| File.basename f }
 
-$INCFLAGS << " -I#{asmjit_dir} "
+  $VPATH.concat Dir["asmjit/src/**/"].map { |x| "$(srcdir)/#{x}" }
+end
 
-$CXXFLAGS << " -DASMJIT_EMBED "
-
-$srcs = []
-$srcs.concat Dir[File.join(__dir__, "*.cc")]
-$srcs.concat Dir[File.join(asmjit_dir, "**/*.cpp")]
-
-$objs = $srcs.map{|x| x.gsub(/\.(cc|cpp)\z/, ".o") }
+append_cppflags("-I$(srcdir)/asmjit/src")
+append_cppflags("-DASMJIT_EMBED")
 
 create_makefile("asmjit/asmjit")

data/lib/asmjit/version.rb

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

data/lib/asmjit.rb

@@ -5,8 +5,7 @@ require_relative "asmjit/asmjit"
 
 AsmJit = AsmJIT
 module AsmJIT
-  def self.assemble
-    code = CodeHolder.new
+  def self.assemble(code = CodeHolder.new)
     yield code.assembler
     code
   end
@@ -39,13 +38,24 @@ module AsmJIT
     end
   end
 
+  class Operand
+    def inspect
+      "#<#{self.class} #{to_s}>"
+    end
+  end
+
   module X86
     module Helpers
       extend self
 
       def parse_operand(arg)
-        if Symbol === arg && reg = REGISTERS[arg]
-          reg
+        case arg
+        when Operand
+          arg
+        when Symbol
+          REGISTERS.fetch(arg)
+        when Integer
+          Imm.new(arg)
         else
           arg
         end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: asmjit
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - John Hawthorn
 autorequire:
 bindir: exe
 cert_chain: []
-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'
+date: 2022-10-22 00:00:00.000000000 Z
+dependencies: []
 description: 'Ruby wrapper for asmjit: a lightweight library for machine code generation'
 email:
 - john@hawthorn.email
@@ -262,7 +248,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.0.dev
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: 'Ruby wrapper for asmjit: a lightweight library for machine code generation'