about summary refs log tree commit diff stats
path: root/subx/ex5.subx
diff options
context:
space:
mode:
authorKartik Agaram <vc@akkartik.com>2018-07-25 20:53:43 -0700
committerKartik Agaram <vc@akkartik.com>2018-07-25 20:53:43 -0700
commit431f739ddca73eb105bced65c169963a335e3134 (patch)
tree114163fff365fcea38cb47ae5d1fae7684f58170 /subx/ex5.subx
parent1a33d221c1a23c218d3457dfe2a4344c2a33f9a1 (diff)
downloadmu-431f739ddca73eb105bced65c169963a335e3134.tar.gz
4414 - subx: syntax checking
This is a large patch, and there's a few things wrong with it:

a) Helpers are incredibly messy. I want to use has_metadata in layer 24,
but can't since it also does error checking. There must be a better
basis set of primitives for managing metadata.

b) Layer 22 introduces operands for checking, but programs with operands
don't actually run until layer 24. So I can't write non-error scenarios
in layer 22. That seems ugly. But if I try to introduce layer 24 first
there's nothing left to check after it.

I *could* play tricks with ordering layers vs transforms. Mu does that a
bit, but it becomes hard to mess with, so I'm trying to avoid that. My
current plan is for layers within an "abstraction level" to be run in
order. Higher layers will necessarily need to come before lower ones.
But hopefully this level of hierarchy will help manage the chaos.

c) The check for whether an instruction is all hex bytes makes me
nervous. I do want to check that an instruction that's just:
  cd
tells the programmer that an operand is missing. The check I currently
have is likely not perfectly correct.

I *could* put layer 25 in its own commit. But I guess I'm not doing
that now.

We have a new example program: hello world!
Diffstat (limited to 'subx/ex5.subx')
-rw-r--r--subx/ex5.subx39
1 files changed, 18 insertions, 21 deletions
diff --git a/subx/ex5.subx b/subx/ex5.subx
index be7266a4..b74af463 100644
--- a/subx/ex5.subx
+++ b/subx/ex5.subx
@@ -5,47 +5,44 @@
 #   $ subx run ex5
 
 == 0x08048054  # code segment, after leaving room for ELF header and segment headers
-# opcode        ModR/M                    SIB                   displacement    immediate
-# instruction   mod, reg, Reg/Mem bits    scale, index, base
-# 1-3 bytes     0/1 byte                  0/1 byte              0/1/2/4 bytes   0/1/2/4 bytes
+# instruction                     effective address                                         operand     displacement    immediate
+# op          subop               mod           rm32          base      index     scale     r32
+# 1-3 bytes                                                                                             0/1/2/4 bytes   0/1/2/4 bytes
 
 ## function main
   # prolog
-  55                                                                                          # push EBP
-  89            e5                                                                            # copy ESP to EBP
-                # ModR/M: 11 (direct mode) 100 (src ESP) 101 (dest EBP)
+  55                                                                                                                                  # push EBP
+  89                              3/mod/direct  5/rm32/EBP                                  4/r32/ESP                                 # copy ESP to EBP
   # allocate x on the stack
-  81            ec                                                              4/imm32       # subtract 4 bytes from ESP
-                # ModR/M: 11 (direct mode) 101 (subtract imm32) 100 (dest EBP)
+  81            5/subop/subtract  3/mod/direct  4/rm32/ESP                                                              4/imm32       # subtract 4 bytes from ESP
 
   ## read(stdin, x, 1)
   # fd = 0 (stdin)
-  bb                                                                            0/imm32       # copy 0 to EBX
+  bb                                                                                                                    0/imm32       # copy 0 to EBX
   # set location to read character to
-  89            e9                                                                            # copy EBP to ECX
-                # ModR/M: 11 (direct mode) 101 (src EBP) 001 (dest ECX)
+  89                              3/mod/direct  1/rm32/ECX                                  5/r32/EBP                                 # copy EBP to ECX
   # size = 1 character
-  ba                                                                            1/imm32       # copy 1 to EDX
+  ba                                                                                                                    1/imm32       # copy 1 to EDX
   # syscall = read
-  b8                                                                            3/imm32       # copy 3 to EAX
+  b8                                                                                                                    3/imm32       # copy 3 to EAX
   # call
-  cd                                                                            128/imm8      # int 80h
+  cd                                                                                                                    0x80/imm8     # int 80h
 
   ## write(stdout, x, 1)
   # fd = 1 (stdout)
-  bb                                                                            1/imm32       # copy 1 to EBX
+  bb                                                                                                                    1/imm32       # copy 1 to EBX
   # set location of character to write out
-  89            e9                                                                            # copy EBP to ECX
+  89                              3/mod/direct  1/rm32/ECX                                  5/r32/EBP                                 # copy EBP to ECX
                 # ModR/M: 11 (direct mode) 101 (src EBP) 001 (dest ECX)
   # size = 1 character
-  ba                                                                            1/imm32       # copy 1 to EDX
+  ba                                                                                                                    1/imm32       # copy 1 to EDX
   # syscall = write
-  b8                                                                            4/imm32       # copy 4 to EAX
+  b8                                                                                                                    4/imm32       # copy 4 to EAX
   # call
-  cd                                                                            128/imm8      # int 80h
+  cd                                                                                                                    0x80/imm8     # int 80h
 
   ## exit(EBX)
-  b8                                                                            1/imm32       # copy 1 to EAX
-  cd                                                                            128/imm8      # int 80h
+  b8                                                                                                                    1/imm32       # copy 1 to EAX
+  cd                                                                                                                    0x80/imm8     # int 80h
 
 # vim:ft=subx:nowrap