asmrepl 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d89ea7a3b6af16e72444221e66fa9c2af2ceaebaae8c4e48d7a30d4b419283f5
-  data.tar.gz: 7b9e86750882fe36a9fdf5ee311e7cdb483c19faf3ffa8a46bdb85808a93e455
+  metadata.gz: 7045e3fe0facfdc15e21bb3dfebcaf5232eb68c144ac07e6bf61588979ca3c7f
+  data.tar.gz: 158f3aea1088ae25397dccfc6bf593449df3482f031c025c6dbf33ce372f6a53
 SHA512:
-  metadata.gz: c583255650ca956401117259c068faa6cae8f8df435b88d447186a883a8c32b45a6e6e8d16aae0fc082f4b6b979156ee88aeea6c27bf4296f73fe0c15b7b85f0
-  data.tar.gz: 349bcb373b93a9dec96421be445005dba162325acea07eb3e20850fd7078550d67576059ea81c33be9d99fe9f6147e8e3bde1d2945989372671e1d5418b3b141
+  metadata.gz: d039b567f9cb938f56f86c1ea02a9c16a3c266748fb16d37b5c710c66618010dba32b13755d778c9dded6a56bb521fb61198281297543aad9f3f6c39028510b4
+  data.tar.gz: 7f37562a9568489d61d9eb3144310d3c372fd5fe7ab07b3b0786c268bc8a2b20077a52736723d0f684930924614083cc4df2a817e6f91f8f6b7afae438aeb0fc

data/README.md

@@ -4,27 +4,34 @@ This is a REPL for assembly language.
 
 ## Usage
 
-I haven't made a gem yet, so use it like this:
+Install the gem:
 
 ```
-$ bundle install
-$ sudo ruby -I lib:test bin/asmrepl
+$ gem install asmrepl
 ```
 
+Then start the repl like this:
+
+```
+$ asmrepl
+```
+
+If you're on macOS, you'll need to start the repl with `sudo`.
+
 When the REPL starts, it will display all register values and flags:
 
 ```
 ================== CPU STATE ===================
-rax  000000000000000000  r8   0x0000600001782be0
-rbx  000000000000000000  r9   0x00007fbf9b0068c0
-rcx  0x0000000109dae951  r10  000000000000000000
-rdx  0x000000000000000c  r11  0x000000010999c000
-rdi  0x00007ff7b6b2bbf0  r12  000000000000000000
-rsi  0x00000001096315fd  r13  0x00007ff7b6b2bdc0
-rbp  0x00007ff7b6b2bc40  r14  000000000000000000
-rsp  0x00007ff7b6b2bc38  r15  000000000000000000
-
-rip     0x000000010999c001
+rax  000000000000000000  r8   0x00007f89d0f04640
+rbx  000000000000000000  r9   0x0000000000000004
+rcx  0x00007f89d0f04a50  r10  000000000000000000
+rdx  0x..fc611d3f0aa2900d4  r11  0x00000001033a4000
+rdi  0x00007ff7bd126148  r12  000000000000000000
+rsi  000000000000000000  r13  0x00007ff7bd125dc0
+rbp  0x00007ff7bd125c40  r14  000000000000000000
+rsp  0x00007ff7bd125c38  r15  000000000000000000
+
+rip     0x00000001033a4001
 rflags  0x0000000000000246
 cs      0x000000000000002b
 fs      000000000000000000
@@ -32,46 +39,58 @@ gs      000000000000000000
 
 FLAGS: ["PF", "ZF", "IF"]
 
->> 
+(rip 0x00000001033a4001)>
 ```
 
 Then you can issue commands and inspect register values.  Let's write to the
 `rax` register and inspect its value:
 
 ```
->> mov rax, 5
->> rax
+(rip 0x00000001033a4001)> mov rax, 5
+=============== REGISTER CHANGES ===============
+rax     000000000000000000 => 0x0000000000000005
+
+(rip 0x00000001033a4009)> rax
 0x0000000000000005
->> 
+(rip 0x00000001033a4009)>
 ```
 
 Now let's write to the `rbx` register and add the two values:
 
 ```
->> mov rbx, 3
->> add rax, rbx
->> rax
+(rip 0x00000001033a4009)> mov rbx, 3
+=============== REGISTER CHANGES ===============
+rbx     000000000000000000 => 0x0000000000000003
+
+(rip 0x00000001033a4011)> add rax, rbx
+=============== REGISTER CHANGES ===============
+rax     0x0000000000000005 => 0x0000000000000008
+rflags  0x0000000000000246 => 0x0000000000000202
+
+FLAGS: ["IF"]
+
+(rip 0x00000001033a4015)> rax
 0x0000000000000008
->> rbx
+(rip 0x00000001033a4015)> rbx
 0x0000000000000003
->> 
+(rip 0x00000001033a4015)>
 ```
 
 Finally, lets check all values in the CPU:
 
 ```
->> cpu
+(rip 0x00000001033a4015)> cpu
 ================== CPU STATE ===================
-rax  0x0000000000000008  r8   0x0000600001d848a0
-rbx  0x0000000000000003  r9   0x00007fced316f850
-rcx  0x00000001017da951  r10  000000000000000000
-rdx  0x000000000000000c  r11  0x00000001013cc000
-rdi  0x00007ff7bf0fdbf0  r12  000000000000000000
-rsi  0x000000010105f5fd  r13  0x00007ff7bf0fddc0
-rbp  0x00007ff7bf0fdc40  r14  000000000000000000
-rsp  0x00007ff7bf0fdc38  r15  000000000000000000
-
-rip     0x00000001013cc029
+rax  0x0000000000000008  r8   0x00007f89d0f04640
+rbx  0x0000000000000003  r9   0x0000000000000004
+rcx  0x00007f89d0f04a50  r10  000000000000000000
+rdx  0x..fc611d3f0aa2900d4  r11  0x00000001033a4000
+rdi  0x00007ff7bd126148  r12  000000000000000000
+rsi  000000000000000000  r13  0x00007ff7bd125dc0
+rbp  0x00007ff7bd125c40  r14  000000000000000000
+rsp  0x00007ff7bd125c38  r15  000000000000000000
+
+rip     0x00000001033a4015
 rflags  0x0000000000000202
 cs      0x000000000000002b
 fs      000000000000000000
@@ -79,5 +98,5 @@ gs      000000000000000000
 
 FLAGS: ["IF"]
 
->> 
+(rip 0x00000001033a4015)>
 ```

data/asmrepl.gemspec

@@ -20,5 +20,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'minitest', '~> 5.14'
   s.add_development_dependency 'crabstone', '~> 4.0'
   s.add_development_dependency 'rake', '~> 13.0'
-  s.add_dependency 'fisk', '~> 2'
+  s.add_dependency 'fisk', '~> 2.3.1'
 end

data/lib/asmrepl/repl.rb

@@ -1,6 +1,5 @@
 require "fiddle"
 require "fisk/helpers"
-require "crabstone"
 require "reline"
 
 if RUBY_PLATFORM =~ /darwin/
@@ -9,17 +8,6 @@ else
   require "asmrepl/linux"
 end
 
-class Crabstone::Binding::Instruction
-  class << self
-    alias :old_release :release
-  end
-
-  # Squelch error in crabstone
-  def self.release obj
-    nil
-  end
-end
-
 module ASMREPL
   class REPL
     include Fiddle
@@ -39,13 +27,40 @@ module ASMREPL
     end
 
     def display_state state
-      puts " CPU STATE ".center(48, "=")
+      puts bold(" CPU STATE ".center(48, "="))
       puts state
       puts
       puts "FLAGS: #{state.flags.inspect}"
       puts
     end
 
+    def display_state_change last_state, state
+      puts bold(" REGISTER CHANGES ".center(48, "="))
+      show_flags = false
+
+      state.fields.each do |field|
+        next if field == "rip"
+
+        if last_state[field] != state[field]
+          print "#{field.ljust(6)}  "
+          print sprintf("%#018x", last_state[field])
+          print " => "
+          puts bold(sprintf("%#018x", state[field]))
+        end
+      end
+
+      if last_state.flags != state.flags
+        puts
+        puts "FLAGS: #{state.flags.inspect}"
+      end
+
+      puts
+    end
+
+    def bold string
+      "\e[1m#{string}\e[0m"
+    end
+
     def start
       pid = fork {
         CFuncs.traceme
@@ -54,49 +69,73 @@ module ASMREPL
 
       tracer = CFuncs::Tracer.new pid
       should_cpu = true
+      last_state = nil
+
       while tracer.wait
         state = tracer.state
 
         # Show CPU state once on boot
-        if should_cpu
+        if last_state.nil?
           display_state state
-          should_cpu = false
+          last_state = state
+        else
+          display_state_change last_state, state
+          last_state = state
         end
 
         # Move the JIT buffer to the current instruction pointer
         pos = (state.rip - @buffer.memory.to_i)
         @buffer.seek pos
         use_history = true
-        loop do
-          cmd = nil
-          text = Reline.readmultiline(">> ", use_history) do |multiline_input|
-            if multiline_input =~ /\A\s*(\w+)\s*\Z/
-              register = $1
-              cmd = [:read, register]
-            else
-              cmd = :run
+        begin
+          loop do
+            cmd = nil
+            prompt = sprintf("(rip %#018x)> ", state.rip)
+            text = Reline.readmultiline(prompt, use_history) do |multiline_input|
+              if multiline_input =~ /\A\s*(\w+)\s*\Z/
+                register = $1
+                cmd = [:read, register]
+              else
+                cmd = :run
+              end
+              true
             end
-            true
-          end
 
-          case cmd
-          in :run
-            break if text.chomp.empty?
-            binary = @assembler.assemble @parser.parse text.chomp
-            binary.bytes.each { |byte| @buffer.putc byte }
-            break
-          in [:read, "cpu"]
-            display_state state
-          in [:read, reg]
-            val = state[reg]
-            if val
-              puts sprintf("%#018x", state[reg])
+            case cmd
+            in :run
+              break if text.chomp.empty?
+              begin
+                parser_result = @parser.parse text.chomp
+              rescue
+                puts "Invalid intruction"
+                next
+              end
+
+              begin
+                binary = @assembler.assemble parser_result
+                binary.bytes.each { |byte| @buffer.putc byte }
+              rescue Fisk::Errors::InvalidInstructionError => e
+                # Print an error message when the instruction is invalid
+                puts e.message
+                next
+              end
+              break
+            in [:read, "cpu"]
+              display_state state
+            in [:read, reg]
+              val = state[reg]
+              if val
+                puts sprintf("%#018x", state[reg])
+              else
+                puts "Unknown command: "
+                puts "  " + text
+              end
             else
-              puts "Unknown command: "
-              puts "  " + text
             end
-          else
           end
+        rescue Interrupt
+          puts ""
+          exit 0
         end
         tracer.continue
       end

data/lib/asmrepl/version.rb

@@ -1,3 +1,3 @@
 module ASMREPL
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end

data/lib/asmrepl.rb

@@ -1,3 +1,11 @@
+require "fiddle"
+
+module Fiddle
+  unless Fiddle.const_defined?(:SIZEOF_INT64_T)
+    SIZEOF_INT64_T = Fiddle::SIZEOF_UINTPTR_T
+  end
+end
+
 require "asmrepl/parser"
 require "asmrepl/assembler"
 require "asmrepl/repl"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: asmrepl
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Aaron Patterson
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-11-24 00:00:00.000000000 Z
+date: 2021-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2'
+        version: 2.3.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2'
+        version: 2.3.1
 description: Tired of writing assembly and them assembling it? Now you can write assembly
   and evaluate it!
 email: tenderlove@ruby-lang.org