about summary refs log tree commit diff
path: root/hex.hex
diff options
context:
space:
mode:
Diffstat (limited to 'hex.hex')
-rw-r--r--hex.hex72
1 files changed, 36 insertions, 36 deletions
diff --git a/hex.hex b/hex.hex
index 1c30eae..28a5ed2 100644
--- a/hex.hex
+++ b/hex.hex
@@ -54,14 +54,14 @@
   ~ and keep it there. We've made sure our load origin fits in 32 bits, so
   ~ we can use imm32 for that. We're going to want to do an indirect load
   ~ from it, so we can't use rbp for this.
-  48 c7 c3 d8 01 00 08                  ~ 0x080001d8 :rbx mov-reg64-imm32
+  48 c7 c3 d8 01 00 08                  ~ 0x80001d8 :rbx mov-reg64-imm32
 
-  e8 88 00 00 00                        ~ 0x00000088 call-rel-imm32
+  e8 88 00 00 00                        ~ 0x88 call-rel-imm32
 
   ~   If the length is 0, we got EOF. If it's less than zero, we got a read
   ~ error. Either way, we exit. This is a signed comparison, as it needs to
   ~ be.
-  48 83 f8 00                           ~ 0x00 :rax cmp-reg64-imm8
+  48 83 f8 00                           ~ 0x0 :rax cmp-reg64-imm8
   74 72                                 ~ 0x72 :cc-equal jmp-cc-rel-imm8
   7c ee                                 ~ 0xee :cc-less jmp-cc-rel-imm8
 
@@ -72,7 +72,7 @@
   48 83 f8 20                           ~ 0x20 :rax cmp-reg64-imm8
                                         ~ ASCII space
   74 ea                                 ~ 0xffffffffffffffea :cc-equal jmp-cc-rel-imm8
-  48 83 f8 0a                           ~ 0x0a :rax cmp-reg64-imm8
+  48 83 f8 0a                           ~ 0xa :rax cmp-reg64-imm8
                                         ~ ASCII linefeed
   74 e4                                 ~ 0xffffffffffffffe4 :cc-equal jmp-cc-rel-imm8
   ~ If it's a comment, skip the whole thing.
@@ -81,17 +81,17 @@
   74 43                                 ~ 0x43 :cc-equal jmp-cc-rel-imm8
 
   ~ Decode the value, or exit with an error.
-  e8 79 00 00 00                        ~ 0x00000079 call-rel-imm32
+  e8 79 00 00 00                        ~ 0x79 call-rel-imm32
 
   ~ We use rbp as a place to stash the high nibble.
   48 89 c5                              ~ :rax :rbp mov-reg64-reg64
-  48 c1 c5 04                           ~ 0x04 :rbp rol-reg64-imm8
+  48 c1 c5 04                           ~ 0x4 :rbp rol-reg64-imm8
 
   ~ Now we read another byte.
-  e8 5a 00 00 00                        ~ 0x0000005a call-rel-imm32
+  e8 5a 00 00 00                        ~ 0x5a call-rel-imm32
 
   ~ Handle the length. A second hex digit is required here.
-  48 83 f8 00                           ~ 0x00 :rax cmp-reg64-imm8
+  48 83 f8 00                           ~ 0x0 :rax cmp-reg64-imm8
   74 ac                                 ~ 0xac :cc-equal jmp-cc-rel-imm8
   7c c0                                 ~ 0xc0 :cc-less jmp-cc-rel-imm8
 
@@ -99,20 +99,20 @@
   48 8b 03                              ~ :rbx :rax mov-reg64-indirect-reg64
 
   ~ Decode the value, or exit with an error.
-  e8 5d 00 00 00                        ~ 0x0000005d call-rel-imm32
+  e8 5d 00 00 00                        ~ 0x5d call-rel-imm32
 
   ~ We OR in the low nibble.
   48 0b e8                              ~ :rax :rbp or-reg64-reg64
 
   ~ Output the byte. We reuse the buffer as a place to store it.
-  48 89 2b                              ~ :rbx :rbp mov-indirect-reg64-reg64
+  48 89 2b                              ~ :rbp :rbx mov-indirect-reg64-reg64
   48 89 de                              ~ :rbx :rsi mov-reg64-reg64
                                         ~ buffer pointer
-  48 c7 c2 01 00 00 00                  ~ 0x00000001 :rdx mov-reg64-imm32
+  48 c7 c2 01 00 00 00                  ~ 0x1 :rdx mov-reg64-imm32
                                         ~ buffer length
-  48 c7 c0 01 00 00 00                  ~ 0x00000001 :rax mov-reg64-imm32
+  48 c7 c0 01 00 00 00                  ~ 0x1 :rax mov-reg64-imm32
                                         ~ syscall number for sys-write
-  48 c7 c7 01 00 00 00                  ~ 0x00000001 :rdi mov-reg64-imm32
+  48 c7 c7 01 00 00 00                  ~ 0x1 :rdi mov-reg64-imm32
                                         ~ file descriptor 1 is stdout
   0f 05                                 ~ syscall
 
@@ -120,18 +120,18 @@
   eb 9b                                 ~ 0xffffffffffffff9b jmp-rel-imm8
 
   ~ Read a byte for the comment.
-  e8 23 00 00 00                        ~ 0x00000023 call-rel-imm32
+  e8 23 00 00 00                        ~ 0x23 call-rel-imm32
 
   ~ Handle the length. We're allowed to end in a comment.
-  48 83 f8 00                           ~ 0x00 :rax cmp-reg64-imm8
-  74 0d                                 ~ 0x0d :cc-equal jmp-cc-rel-imm8
+  48 83 f8 00                           ~ 0x0 :rax cmp-reg64-imm8
+  74 0d                                 ~ 0xd :cc-equal jmp-cc-rel-imm8
   7c 89                                 ~ 0x89 :cc-less jmp-cc-rel-imm8
 
   ~ Now that the length is handled, retrieve the input byte.
   48 8b 03                              ~ :rbx :rax mov-reg64-indirect-reg64
 
   ~ If it's linefeed, the comment is over.
-  48 83 f8 0a                           ~ 0x0a :rax cmp-reg64-imm8
+  48 83 f8 0a                           ~ 0xa :rax cmp-reg64-imm8
                                         ~ ASCII linefeed
   74 85                                 ~ 0xffffffffffffff85 :cc-equal jmp-cc-rel-imm8
 
@@ -139,9 +139,9 @@
   eb e8                                 ~ 0xffffffffffffffe8 jmp-rel-imm8
 
 ~ This is the routine named "exit".
-  48 c7 c0 3c 00 00 00                  ~ 0x0000003c :rax mov-reg64-imm32
+  48 c7 c0 3c 00 00 00                  ~ 0x3c :rax mov-reg64-imm32
                                         ~ syscall number for sys-exit
-  48 c7 c7 00 00 00 00                  ~ 0x00000000 :rdi mov-reg64-imm32
+  48 c7 c7 00 00 00 00                  ~ 0x0 :rdi mov-reg64-imm32
                                         ~ exit code
   0f 05                                 ~ syscall
 
@@ -154,7 +154,7 @@
   48 89 de                              ~ :rbx :rsi mov-reg64-reg64
                                         ~ buffer pointer
   ~ We read one byte at a time, because it makes the loop structure simple.
-  48 c7 c2 01 00 00 00                  ~ 0x00000001 :rdx mov-reg64-imm32
+  48 c7 c2 01 00 00 00                  ~ 0x1 :rdx mov-reg64-imm32
                                         ~ buffer length
   0f 05                                 ~ syscall
   c3                                    ~ ret
@@ -163,41 +163,41 @@
   48 83 e8 30                           ~ 0x30 :rax sub-reg64-imm8
                                         ~ ASCII zero
   7c 29                                 ~ 0x29 :cc-less jmp-cc-rel-imm8
-  48 83 f8 0a                           ~ 0x0a :rax cmp-reg64-imm8
+  48 83 f8 0a                           ~ 0xa :rax cmp-reg64-imm8
   72 22                                 ~ 0x22 :cc-below jmp-cc-rel-imm8
   48 83 e8 11                           ~ 0x11 :rax sub-reg64-imm8
                                         ~ ASCII capital A
   7c 1d                                 ~ 0x1d :cc-less jmp-cc-rel-imm8
-  48 83 c0 0a                           ~ 0x0a :rax add-reg64-imm8
+  48 83 c0 0a                           ~ 0xa :rax add-reg64-imm8
   48 83 f8 10                           ~ 0x10 :rax cmp-reg64-imm8
   72 12                                 ~ 0x12 :cc-below jmp-cc-rel-imm8
   48 83 e8 2a                           ~ 0x2a :rax sub-reg64-imm8
                                         ~ ASCII lowercase a
-  7c 0d                                 ~ 0x0d :cc-less jmp-cc-rel-imm8
-  48 83 c0 0a                           ~ 0x0a :rax add-reg64-imm8
+  7c 0d                                 ~ 0xd :cc-less jmp-cc-rel-imm8
+  48 83 c0 0a                           ~ 0xa :rax add-reg64-imm8
   48 83 f8 10                           ~ 0x10 :rax cmp-reg64-imm8
-  72 02                                 ~ 0x02 :cc-below jmp-cc-rel-imm8
-  eb 01                                 ~ 0x01 jmp-rel-imm8
+  72 02                                 ~ 0x2 :cc-below jmp-cc-rel-imm8
+  eb 01                                 ~ 0x1 jmp-rel-imm8
   c3                                    ~ ret
 
 
 ~ These are the error handler routines.
-  48 be ae 01 00 08 00 00 00 00         ~ 0x00000000080001ae :rsi mov-reg64-imm64
-  48 ba 0e 00 00 00 00 00 00 00         ~ 0x000000000000000e :rdx mov-reg64-imm64
+  48 be ae 01 00 08 00 00 00 00         ~ 0x80001ae :rsi mov-reg64-imm64
+  48 ba 0e 00 00 00 00 00 00 00         ~ 0xe :rdx mov-reg64-imm64
   eb 2a                                 ~ 0x2a jmp-rel-imm8
-  48 be c8 01 00 08 00 00 00 00         ~ 0x00000000080001c8 :rsi mov-reg64-imm64
-  48 ba 10 00 00 00 00 00 00 00         ~ 0x0000000000000010 :rdx mov-reg64-imm64
+  48 be c8 01 00 08 00 00 00 00         ~ 0x80001c8 :rsi mov-reg64-imm64
+  48 ba 10 00 00 00 00 00 00 00         ~ 0x10 :rdx mov-reg64-imm64
   eb 14                                 ~ 0x14 jmp-rel-imm8
-  48 be bc 01 00 08 00 00 00 00         ~ 0x00000000080001bc :rsi mov-reg64-imm64
-  48 ba 0c 00 00 00 00 00 00 00         ~ 0x000000000000000c :rdx mov-reg64-imm64
-  48 c7 c0 01 00 00 00                  ~ 0x00000001 :rax mov-reg64-imm32
+  48 be bc 01 00 08 00 00 00 00         ~ 0x80001bc :rsi mov-reg64-imm64
+  48 ba 0c 00 00 00 00 00 00 00         ~ 0xc :rdx mov-reg64-imm64
+  48 c7 c0 01 00 00 00                  ~ 0x1 :rax mov-reg64-imm32
                                         ~ syscall number for sys-write
-  48 c7 c7 02 00 00 00                  ~ 0x00000002 :rdi mov-reg64-imm32
+  48 c7 c7 02 00 00 00                  ~ 0x2 :rdi mov-reg64-imm32
                                         ~ file descriptor 2 is stderr
   0f 05                                 ~ syscall
-  48 c7 c0 3c 00 00 00                  ~ 0x0000003c :rax mov-reg64-imm32
+  48 c7 c0 3c 00 00 00                  ~ 0x3c :rax mov-reg64-imm32
                                         ~ syscall number for sys-exit
-  48 c7 c7 01 00 00 00                  ~ 0x00000001 :rdi mov-reg64-imm32
+  48 c7 c7 01 00 00 00                  ~ 0x1 :rdi mov-reg64-imm32
                                         ~ exit code
   0f 05                                 ~ syscall