2019-05-25 07:43:19 +00:00
|
|
|
# Comparing arrays of numbers.
|
|
|
|
|
|
|
|
== code
|
|
|
|
|
2020-07-11 04:08:26 +00:00
|
|
|
array-equal?: # a: (addr array int), b: (addr array int) -> result/eax: boolean
|
2019-05-25 07:43:19 +00:00
|
|
|
# pseudocode:
|
2020-04-03 19:35:53 +00:00
|
|
|
# asize = a->size
|
|
|
|
# if (asize != b->size) return false
|
2019-05-25 07:43:19 +00:00
|
|
|
# i = 0
|
|
|
|
# curra = a->data
|
|
|
|
# currb = b->data
|
2020-04-03 19:35:53 +00:00
|
|
|
# while i < asize
|
2019-05-25 07:43:19 +00:00
|
|
|
# i1 = *curra
|
|
|
|
# i2 = *currb
|
|
|
|
# if (c1 != c2) return false
|
|
|
|
# i+=4, curra+=4, currb+=4
|
|
|
|
# return true
|
|
|
|
#
|
|
|
|
# registers:
|
2019-08-26 18:55:26 +00:00
|
|
|
# i: ecx
|
2020-04-03 19:35:53 +00:00
|
|
|
# asize: edx
|
2019-08-26 18:55:26 +00:00
|
|
|
# curra: esi
|
|
|
|
# currb: edi
|
|
|
|
# i1: eax
|
|
|
|
# i2: ebx
|
2019-05-25 07:43:19 +00:00
|
|
|
#
|
2019-10-16 02:35:19 +00:00
|
|
|
# . prologue
|
2019-08-26 18:55:26 +00:00
|
|
|
55/push-ebp
|
2020-01-14 09:16:25 +00:00
|
|
|
89/<- %ebp 4/r32/esp
|
2019-05-25 07:43:19 +00:00
|
|
|
# . save registers
|
2019-08-26 18:55:26 +00:00
|
|
|
51/push-ecx
|
|
|
|
52/push-edx
|
|
|
|
53/push-ebx
|
|
|
|
56/push-esi
|
|
|
|
57/push-edi
|
|
|
|
# esi = a
|
2020-01-14 09:16:25 +00:00
|
|
|
8b/-> *(ebp+8) 6/r32/esi
|
2019-08-26 18:55:26 +00:00
|
|
|
# edi = b
|
2020-01-14 09:16:25 +00:00
|
|
|
8b/-> *(ebp+0xc) 7/r32/edi
|
2020-04-03 19:35:53 +00:00
|
|
|
# var asize/edx: int = a->size
|
2020-01-14 09:16:25 +00:00
|
|
|
8b/-> *esi 2/r32/edx
|
2020-04-03 19:35:53 +00:00
|
|
|
$array-equal?:sizes:
|
|
|
|
# if (asize != b->size) return false
|
2020-01-14 09:16:25 +00:00
|
|
|
39/compare *edi 2/r32/edx
|
2020-01-17 02:31:12 +00:00
|
|
|
75/jump-if-!= $array-equal?:false/disp8
|
2020-01-27 08:36:44 +00:00
|
|
|
# var curra/esi: (addr byte) = a->data
|
2020-01-14 09:16:25 +00:00
|
|
|
81 0/subop/add %esi 4/imm32
|
2020-01-27 08:36:44 +00:00
|
|
|
# var currb/edi: (addr byte) = b->data
|
2020-01-14 09:16:25 +00:00
|
|
|
81 0/subop/add %edi 4/imm32
|
2020-01-27 08:36:44 +00:00
|
|
|
# var i/ecx: int = 0
|
6158 - standardize opcode names
At the lowest level, SubX without syntax sugar uses names without prepositions.
For example, 01 and 03 are both called 'add', irrespective of source and
destination operand. Horizontal space is at a premium, and we rely on the
comments at the end of each line to fully describe what is happening.
Above that, however, we standardize on a slightly different naming convention
across:
a) SubX with syntax sugar,
b) Mu, and
c) the SubX code that the Mu compiler emits.
Conventions, in brief:
- by default, the source is on the left and destination on the right.
e.g. add %eax, 1/r32/ecx ("add eax to ecx")
- prepositions reverse the direction.
e.g. add-to %eax, 1/r32/ecx ("add ecx to eax")
subtract-from %eax, 1/r32/ecx ("subtract ecx from eax")
- by default, comparisons are left to right while 'compare<-' reverses.
Before, I was sometimes swapping args to make the operation more obvious,
but that would complicate the code-generation of the Mu compiler, and it's
nice to be able to read the output of the compiler just like hand-written
code.
One place where SubX differs from Mu: copy opcodes are called '<-' and
'->'. Hopefully that fits with the spirit of Mu rather than the letter
of the 'copy' and 'copy-to' instructions.
2020-03-21 22:32:30 +00:00
|
|
|
31/xor-with %ecx 1/r32/ecx
|
2020-01-27 08:36:44 +00:00
|
|
|
# var vala/eax: int
|
|
|
|
# var valb/ebx: int
|
2019-05-25 07:43:19 +00:00
|
|
|
$array-equal?:loop:
|
2020-04-03 19:35:53 +00:00
|
|
|
# if (i >= asize) return true
|
2020-01-14 09:16:25 +00:00
|
|
|
39/compare %ecx 2/r32/edx
|
2020-01-17 02:31:12 +00:00
|
|
|
7d/jump-if->= $array-equal?:true/disp8
|
2020-01-27 08:36:44 +00:00
|
|
|
# var vala/eax: int = *curra
|
2020-01-14 09:16:25 +00:00
|
|
|
8b/-> *esi 0/r32/eax
|
2020-01-27 08:36:44 +00:00
|
|
|
# var valb/ebx: int = *currb
|
2020-01-14 09:16:25 +00:00
|
|
|
8b/-> *edi 3/r32/ebx
|
2019-12-08 21:56:46 +00:00
|
|
|
# if (vala != valb) return false
|
2020-01-14 09:16:25 +00:00
|
|
|
39/compare %eax 3/r32/ebx
|
2020-01-17 02:31:12 +00:00
|
|
|
75/jump-if-!= $array-equal?:false/disp8
|
2019-05-25 07:43:19 +00:00
|
|
|
# i += 4
|
2020-01-14 09:16:25 +00:00
|
|
|
81 0/subop/add %ecx 4/imm32
|
2019-05-25 07:43:19 +00:00
|
|
|
# currs += 4
|
2020-01-14 09:16:25 +00:00
|
|
|
81 0/subop/add %esi 4/imm32
|
2019-05-25 07:43:19 +00:00
|
|
|
# currb += 4
|
2020-01-14 09:16:25 +00:00
|
|
|
81 0/subop/add %edi 4/imm32
|
|
|
|
eb/jump $array-equal?:loop/disp8
|
2019-05-25 07:43:19 +00:00
|
|
|
$array-equal?:true:
|
2020-01-14 09:16:25 +00:00
|
|
|
b8/copy-to-eax 1/imm32
|
|
|
|
eb/jump $array-equal?:end/disp8
|
2019-05-25 07:43:19 +00:00
|
|
|
$array-equal?:false:
|
2020-01-14 09:16:25 +00:00
|
|
|
b8/copy-to-eax 0/imm32
|
2019-05-25 07:43:19 +00:00
|
|
|
$array-equal?:end:
|
|
|
|
# . restore registers
|
2019-08-26 18:55:26 +00:00
|
|
|
5f/pop-to-edi
|
|
|
|
5e/pop-to-esi
|
|
|
|
5b/pop-to-ebx
|
|
|
|
5a/pop-to-edx
|
|
|
|
59/pop-to-ecx
|
2019-10-16 02:35:19 +00:00
|
|
|
# . epilogue
|
2020-01-14 09:16:25 +00:00
|
|
|
89/<- %esp 5/r32/ebp
|
2019-08-26 18:55:26 +00:00
|
|
|
5d/pop-to-ebp
|
2019-05-25 07:43:19 +00:00
|
|
|
c3/return
|
|
|
|
|
|
|
|
test-compare-empty-with-empty-array:
|
2019-10-16 02:35:19 +00:00
|
|
|
# . prologue
|
2019-08-26 18:55:26 +00:00
|
|
|
55/push-ebp
|
2020-01-14 09:16:25 +00:00
|
|
|
89/<- %ebp 4/r32/esp
|
2020-01-27 08:36:44 +00:00
|
|
|
# var ecx: (array _) = []
|
2020-01-14 09:16:25 +00:00
|
|
|
68/push 0/imm32/size
|
|
|
|
89/<- %ecx 4/r32/esp
|
2020-01-27 08:36:44 +00:00
|
|
|
# var edx: (array _) = []
|
2020-01-14 09:16:25 +00:00
|
|
|
68/push 0/imm32/size
|
|
|
|
89/<- %edx 4/r32/esp
|
2020-03-21 22:07:59 +00:00
|
|
|
#
|
|
|
|
(array-equal? %ecx %edx) # => eax
|
|
|
|
(check-ints-equal %eax 1 "F - test-compare-empty-with-empty-array")
|
2019-10-16 02:35:19 +00:00
|
|
|
# . epilogue
|
2020-01-14 09:16:25 +00:00
|
|
|
89/<- %esp 5/r32/ebp
|
2019-08-26 18:55:26 +00:00
|
|
|
5d/pop-to-ebp
|
2019-05-25 07:43:19 +00:00
|
|
|
c3/return
|
|
|
|
|
2020-04-03 19:35:53 +00:00
|
|
|
test-compare-empty-with-non-empty-array: # also checks size-mismatch code path
|
2019-10-16 02:35:19 +00:00
|
|
|
# . prologue
|
2019-08-26 18:55:26 +00:00
|
|
|
55/push-ebp
|
2020-01-14 09:16:25 +00:00
|
|
|
89/<- %ebp 4/r32/esp
|
2020-01-27 08:36:44 +00:00
|
|
|
# var ecx: (array int) = [1]
|
2020-01-14 09:16:25 +00:00
|
|
|
68/push 1/imm32
|
|
|
|
68/push 4/imm32/size
|
|
|
|
89/<- %ecx 4/r32/esp
|
2020-01-27 08:36:44 +00:00
|
|
|
# var edx: (array int) = []
|
2020-01-14 09:16:25 +00:00
|
|
|
68/push 0/imm32/size
|
|
|
|
89/<- %edx 4/r32/esp
|
2020-03-21 22:07:59 +00:00
|
|
|
#
|
|
|
|
(array-equal? %ecx %edx) # => eax
|
|
|
|
(check-ints-equal %eax 0 "F - test-compare-empty-with-non-empty-array")
|
2019-10-16 02:35:19 +00:00
|
|
|
# . epilogue
|
2020-01-14 09:16:25 +00:00
|
|
|
89/<- %esp 5/r32/ebp
|
2019-08-26 18:55:26 +00:00
|
|
|
5d/pop-to-ebp
|
2019-05-25 07:43:19 +00:00
|
|
|
c3/return
|
|
|
|
|
|
|
|
test-compare-equal-arrays:
|
2019-10-16 02:35:19 +00:00
|
|
|
# . prologue
|
2019-08-26 18:55:26 +00:00
|
|
|
55/push-ebp
|
2020-01-14 09:16:25 +00:00
|
|
|
89/<- %ebp 4/r32/esp
|
2020-01-27 08:36:44 +00:00
|
|
|
# var ecx: (array int) = [1, 2, 3]
|
2020-01-14 09:16:25 +00:00
|
|
|
68/push 3/imm32
|
|
|
|
68/push 2/imm32
|
|
|
|
68/push 1/imm32
|
|
|
|
68/push 0xc/imm32/size
|
|
|
|
89/<- %ecx 4/r32/esp
|
2020-01-27 08:36:44 +00:00
|
|
|
# var edx: (array int) = [1, 2, 3]
|
2020-01-14 09:16:25 +00:00
|
|
|
68/push 3/imm32
|
|
|
|
68/push 2/imm32
|
|
|
|
68/push 1/imm32
|
|
|
|
68/push 0xc/imm32/size
|
|
|
|
89/<- %edx 4/r32/esp
|
2020-03-21 22:07:59 +00:00
|
|
|
#
|
|
|
|
(array-equal? %ecx %edx) # => eax
|
|
|
|
(check-ints-equal %eax 1 "F - test-compare-equal-arrays")
|
2019-10-16 02:35:19 +00:00
|
|
|
# . epilogue
|
2020-01-14 09:16:25 +00:00
|
|
|
89/<- %esp 5/r32/ebp
|
2019-08-26 18:55:26 +00:00
|
|
|
5d/pop-to-ebp
|
2019-05-25 07:43:19 +00:00
|
|
|
c3/return
|
|
|
|
|
2020-04-03 19:35:53 +00:00
|
|
|
test-compare-inequal-arrays-equal-sizes:
|
2019-10-16 02:35:19 +00:00
|
|
|
# . prologue
|
2019-08-26 18:55:26 +00:00
|
|
|
55/push-ebp
|
2020-01-14 09:16:25 +00:00
|
|
|
89/<- %ebp 4/r32/esp
|
2020-01-27 08:36:44 +00:00
|
|
|
# var ecx: (array int) = [1, 4, 3]
|
2020-01-14 09:16:25 +00:00
|
|
|
68/push 3/imm32
|
|
|
|
68/push 4/imm32
|
|
|
|
68/push 1/imm32
|
|
|
|
68/push 0xc/imm32/size
|
|
|
|
89/<- %ecx 4/r32/esp
|
2020-01-27 08:36:44 +00:00
|
|
|
# var edx: (array int) = [1, 2, 3]
|
2020-01-14 09:16:25 +00:00
|
|
|
68/push 3/imm32
|
|
|
|
68/push 2/imm32
|
|
|
|
68/push 1/imm32
|
|
|
|
68/push 0xc/imm32/size
|
|
|
|
89/<- %edx 4/r32/esp
|
2020-03-21 22:07:59 +00:00
|
|
|
#
|
|
|
|
(array-equal? %ecx %edx) # => eax
|
2020-04-03 19:35:53 +00:00
|
|
|
(check-ints-equal %eax 0 "F - test-compare-inequal-arrays-equal-sizes")
|
2019-10-16 02:35:19 +00:00
|
|
|
# . epilogue
|
2020-01-14 09:16:25 +00:00
|
|
|
89/<- %esp 5/r32/ebp
|
2019-08-26 18:55:26 +00:00
|
|
|
5d/pop-to-ebp
|
2019-05-25 07:43:19 +00:00
|
|
|
c3/return
|
|
|
|
|
2020-10-26 04:15:43 +00:00
|
|
|
_parse-array-of-ints: # ad: (addr allocation-descriptor), s: (addr array byte), out: (addr handle array int)
|
2019-05-26 06:47:49 +00:00
|
|
|
# pseudocode
|
2020-04-03 19:35:53 +00:00
|
|
|
# end = &s->data[s->size]
|
2019-05-26 06:47:49 +00:00
|
|
|
# curr = s->data
|
|
|
|
# size = 0
|
|
|
|
# while true
|
|
|
|
# if (curr >= end) break
|
|
|
|
# curr = skip-chars-matching-in-slice(curr, end, ' ')
|
|
|
|
# if (curr >= end) break
|
|
|
|
# curr = skip-chars-not-matching-in-slice(curr, end, ' ')
|
|
|
|
# ++size
|
2020-04-04 02:36:57 +00:00
|
|
|
# allocate-array(ad, size*4, out)
|
2020-01-27 08:36:44 +00:00
|
|
|
# var slice: slice = {s->data, 0}
|
2020-04-04 02:36:57 +00:00
|
|
|
# curr = lookup(out)->data
|
2019-05-26 06:47:49 +00:00
|
|
|
# while true
|
2019-07-09 00:02:09 +00:00
|
|
|
# if (slice->start >= end) break
|
|
|
|
# slice->start = skip-chars-matching-in-slice(slice->start, end, ' ')
|
|
|
|
# if (slice->start >= end) break
|
|
|
|
# slice->end = skip-chars-not-matching-in-slice(slice->start, end, ' ')
|
2020-04-04 02:36:57 +00:00
|
|
|
# *curr = parse-hex-int-from-slice(slice)
|
|
|
|
# curr += 4
|
2019-07-09 00:02:09 +00:00
|
|
|
# slice->start = slice->end
|
2019-05-26 06:47:49 +00:00
|
|
|
# return result
|
|
|
|
#
|
2019-10-16 02:35:19 +00:00
|
|
|
# . prologue
|
2019-08-26 18:55:26 +00:00
|
|
|
55/push-ebp
|
2020-01-14 09:16:25 +00:00
|
|
|
89/<- %ebp 4/r32/esp
|
2019-05-26 06:47:49 +00:00
|
|
|
# . save registers
|
2020-04-04 02:36:57 +00:00
|
|
|
50/push-eax
|
2019-08-26 18:55:26 +00:00
|
|
|
51/push-ecx
|
|
|
|
52/push-edx
|
|
|
|
53/push-ebx
|
|
|
|
56/push-esi
|
|
|
|
57/push-edi
|
|
|
|
# esi = s
|
2020-01-14 09:16:25 +00:00
|
|
|
8b/-> *(ebp+0xc) 6/r32/esi
|
2020-01-27 08:36:44 +00:00
|
|
|
# var curr/ecx: (addr byte) = s->data
|
2020-01-14 09:16:25 +00:00
|
|
|
8d/copy-address *(esi+4) 1/r32/ecx
|
2020-04-03 19:35:53 +00:00
|
|
|
# var end/edx: (addr byte) = &s->data[s->size]
|
|
|
|
# . edx = s->size
|
2020-01-14 09:16:25 +00:00
|
|
|
8b/-> *esi 2/r32/edx
|
2019-08-26 18:55:26 +00:00
|
|
|
# . edx += curr
|
6158 - standardize opcode names
At the lowest level, SubX without syntax sugar uses names without prepositions.
For example, 01 and 03 are both called 'add', irrespective of source and
destination operand. Horizontal space is at a premium, and we rely on the
comments at the end of each line to fully describe what is happening.
Above that, however, we standardize on a slightly different naming convention
across:
a) SubX with syntax sugar,
b) Mu, and
c) the SubX code that the Mu compiler emits.
Conventions, in brief:
- by default, the source is on the left and destination on the right.
e.g. add %eax, 1/r32/ecx ("add eax to ecx")
- prepositions reverse the direction.
e.g. add-to %eax, 1/r32/ecx ("add ecx to eax")
subtract-from %eax, 1/r32/ecx ("subtract ecx from eax")
- by default, comparisons are left to right while 'compare<-' reverses.
Before, I was sometimes swapping args to make the operation more obvious,
but that would complicate the code-generation of the Mu compiler, and it's
nice to be able to read the output of the compiler just like hand-written
code.
One place where SubX differs from Mu: copy opcodes are called '<-' and
'->'. Hopefully that fits with the spirit of Mu rather than the letter
of the 'copy' and 'copy-to' instructions.
2020-03-21 22:32:30 +00:00
|
|
|
01/add-to %edx 1/r32/ecx
|
2020-01-27 08:36:44 +00:00
|
|
|
# var size/ebx: int = 0
|
6158 - standardize opcode names
At the lowest level, SubX without syntax sugar uses names without prepositions.
For example, 01 and 03 are both called 'add', irrespective of source and
destination operand. Horizontal space is at a premium, and we rely on the
comments at the end of each line to fully describe what is happening.
Above that, however, we standardize on a slightly different naming convention
across:
a) SubX with syntax sugar,
b) Mu, and
c) the SubX code that the Mu compiler emits.
Conventions, in brief:
- by default, the source is on the left and destination on the right.
e.g. add %eax, 1/r32/ecx ("add eax to ecx")
- prepositions reverse the direction.
e.g. add-to %eax, 1/r32/ecx ("add ecx to eax")
subtract-from %eax, 1/r32/ecx ("subtract ecx from eax")
- by default, comparisons are left to right while 'compare<-' reverses.
Before, I was sometimes swapping args to make the operation more obvious,
but that would complicate the code-generation of the Mu compiler, and it's
nice to be able to read the output of the compiler just like hand-written
code.
One place where SubX differs from Mu: copy opcodes are called '<-' and
'->'. Hopefully that fits with the spirit of Mu rather than the letter
of the 'copy' and 'copy-to' instructions.
2020-03-21 22:32:30 +00:00
|
|
|
31/xor-with %ebx 3/r32/ebx
|
2020-10-26 04:15:43 +00:00
|
|
|
$_parse-array-of-ints:loop1:
|
2019-05-26 06:47:49 +00:00
|
|
|
# if (curr >= end) break
|
2020-01-14 09:16:25 +00:00
|
|
|
39/compare %ecx 2/r32/edx
|
2020-10-26 04:15:43 +00:00
|
|
|
73/jump-if-addr>= $_parse-array-of-ints:break1/disp8
|
2019-05-26 06:47:49 +00:00
|
|
|
# curr = skip-chars-matching-in-slice(curr, end, ' ')
|
2020-03-21 22:07:59 +00:00
|
|
|
(skip-chars-matching-in-slice %ecx %edx 0x20) # => eax
|
2020-01-14 09:16:25 +00:00
|
|
|
89/<- %ecx 0/r32/eax
|
2019-05-26 06:47:49 +00:00
|
|
|
# if (curr >= end) break
|
2020-01-14 09:16:25 +00:00
|
|
|
39/compare %ecx 2/r32/edx
|
2020-10-26 04:15:43 +00:00
|
|
|
73/jump-if-addr>= $_parse-array-of-ints:break1/disp8
|
2019-05-26 06:47:49 +00:00
|
|
|
# curr = skip-chars-not-matching-in-slice(curr, end, ' ')
|
2020-03-21 22:07:59 +00:00
|
|
|
(skip-chars-not-matching-in-slice %ecx %edx 0x20) # => eax
|
2020-01-14 09:16:25 +00:00
|
|
|
89/<- %ecx 0/r32/eax
|
2019-05-26 06:47:49 +00:00
|
|
|
# size += 4
|
2020-01-14 09:16:25 +00:00
|
|
|
81 0/subop/add %ebx 4/imm32
|
2020-10-26 04:15:43 +00:00
|
|
|
eb/jump $_parse-array-of-ints:loop1/disp8
|
|
|
|
$_parse-array-of-ints:break1:
|
2020-04-04 02:36:57 +00:00
|
|
|
(allocate-array *(ebp+8) %ebx *(ebp+0x10))
|
2020-10-26 04:15:43 +00:00
|
|
|
$_parse-array-of-ints:pass2:
|
2020-04-04 02:36:57 +00:00
|
|
|
# var slice/edi: slice = {s->data, 0}
|
2020-01-14 09:16:25 +00:00
|
|
|
68/push 0/imm32/end
|
2020-04-04 02:36:57 +00:00
|
|
|
8d/copy-address *(esi+4) 7/r32/edi
|
|
|
|
57/push-edi
|
|
|
|
89/<- %edi 4/r32/esp
|
|
|
|
# curr = lookup(out)->data
|
|
|
|
8b/-> *(ebp+0x10) 0/r32/eax
|
|
|
|
(lookup *eax *(eax+4)) # => eax
|
|
|
|
8d/copy-address *(eax+4) 1/r32/ecx
|
2020-10-26 04:15:43 +00:00
|
|
|
$_parse-array-of-ints:loop2:
|
2019-07-09 00:02:09 +00:00
|
|
|
# if (slice->start >= end) break
|
2020-04-04 02:36:57 +00:00
|
|
|
39/compare *edi 2/r32/edx
|
2020-10-26 04:15:43 +00:00
|
|
|
73/jump-if-addr>= $_parse-array-of-ints:end/disp8
|
2019-07-09 00:02:09 +00:00
|
|
|
# slice->start = skip-chars-matching-in-slice(slice->start, end, ' ')
|
2020-04-04 02:36:57 +00:00
|
|
|
(skip-chars-matching-in-slice *edi %edx 0x20) # => eax
|
|
|
|
89/<- *edi 0/r32/eax
|
2019-07-09 00:02:09 +00:00
|
|
|
# if (slice->start >= end) break
|
2020-04-04 02:36:57 +00:00
|
|
|
39/compare *edi 2/r32/edx
|
2020-10-26 04:15:43 +00:00
|
|
|
73/jump-if-addr>= $_parse-array-of-ints:end/disp8
|
2019-07-09 00:02:09 +00:00
|
|
|
# slice->end = skip-chars-not-matching-in-slice(slice->start, end, ' ')
|
2020-04-04 02:36:57 +00:00
|
|
|
(skip-chars-not-matching-in-slice *edi %edx 0x20) # => eax
|
|
|
|
89/<- *(edi+4) 0/r32/eax
|
|
|
|
# *curr = parse-hex-int-from-slice(slice)
|
|
|
|
(parse-hex-int-from-slice %edi)
|
2020-01-14 09:16:25 +00:00
|
|
|
89/<- *ecx 0/r32/eax
|
2020-04-04 02:36:57 +00:00
|
|
|
# curr += 4
|
|
|
|
81 0/subop/add %ecx 4/imm32
|
|
|
|
# slice->start = slice->end
|
|
|
|
8b/-> *(edi+4) 0/r32/eax
|
|
|
|
89/<- *edi 0/r32/eax
|
2020-10-26 04:15:43 +00:00
|
|
|
eb/jump $_parse-array-of-ints:loop2/disp8
|
|
|
|
$_parse-array-of-ints:end:
|
2019-05-26 06:47:49 +00:00
|
|
|
# . reclaim locals
|
2020-01-14 09:16:25 +00:00
|
|
|
81 0/subop/add %esp 8/imm32
|
2019-05-26 06:47:49 +00:00
|
|
|
# . restore registers
|
2019-08-26 18:55:26 +00:00
|
|
|
5f/pop-to-edi
|
|
|
|
5e/pop-to-esi
|
|
|
|
5b/pop-to-ebx
|
|
|
|
5a/pop-to-edx
|
|
|
|
59/pop-to-ecx
|
2020-04-04 02:36:57 +00:00
|
|
|
58/pop-to-eax
|
2019-10-16 02:35:19 +00:00
|
|
|
# . epilogue
|
2020-01-14 09:16:25 +00:00
|
|
|
89/<- %esp 5/r32/ebp
|
2019-08-26 18:55:26 +00:00
|
|
|
5d/pop-to-ebp
|
2019-05-26 06:47:49 +00:00
|
|
|
c3/return
|
|
|
|
|
|
|
|
test-parse-array-of-ints:
|
2019-10-16 02:35:19 +00:00
|
|
|
# . prologue
|
2019-08-26 18:55:26 +00:00
|
|
|
55/push-ebp
|
2020-01-14 09:16:25 +00:00
|
|
|
89/<- %ebp 4/r32/esp
|
2020-04-04 02:36:57 +00:00
|
|
|
# var h/esi: (handle array int)
|
|
|
|
68/push 0/imm32
|
|
|
|
68/push 0/imm32
|
|
|
|
89/<- %esi 4/r32/esp
|
2020-01-27 08:36:44 +00:00
|
|
|
# var ecx: (array int) = [1, 2, 3]
|
2020-01-14 09:16:25 +00:00
|
|
|
68/push 3/imm32
|
|
|
|
68/push 2/imm32
|
|
|
|
68/push 1/imm32
|
|
|
|
68/push 0xc/imm32/size
|
|
|
|
89/<- %ecx 4/r32/esp
|
2020-03-21 22:07:59 +00:00
|
|
|
#
|
2020-10-26 04:15:43 +00:00
|
|
|
(_parse-array-of-ints Heap "1 2 3" %esi)
|
2020-04-04 02:36:57 +00:00
|
|
|
(lookup *esi *(esi+4)) # => eax
|
2020-03-21 22:07:59 +00:00
|
|
|
(array-equal? %ecx %eax) # => eax
|
|
|
|
(check-ints-equal %eax 1 "F - test-parse-array-of-ints")
|
2019-10-16 02:35:19 +00:00
|
|
|
# . epilogue
|
2020-01-14 09:16:25 +00:00
|
|
|
89/<- %esp 5/r32/ebp
|
2019-08-26 18:55:26 +00:00
|
|
|
5d/pop-to-ebp
|
2019-05-26 06:47:49 +00:00
|
|
|
c3/return
|
|
|
|
|
|
|
|
test-parse-array-of-ints-empty:
|
|
|
|
# - empty string = empty array
|
2019-10-16 02:35:19 +00:00
|
|
|
# . prologue
|
2019-08-26 18:55:26 +00:00
|
|
|
55/push-ebp
|
2020-01-14 09:16:25 +00:00
|
|
|
89/<- %ebp 4/r32/esp
|
2020-04-04 02:36:57 +00:00
|
|
|
# var h/esi: handle
|
|
|
|
68/push 0/imm32
|
|
|
|
68/push 0/imm32
|
|
|
|
89/<- %esi 4/r32/esp
|
2020-03-21 22:07:59 +00:00
|
|
|
#
|
2020-10-26 04:15:43 +00:00
|
|
|
(_parse-array-of-ints Heap "" %esi)
|
2020-04-04 02:36:57 +00:00
|
|
|
(lookup *esi *(esi+4)) # => eax
|
2020-03-21 22:07:59 +00:00
|
|
|
(check-ints-equal *eax 0 "F - test-parse-array-of-ints-empty")
|
2019-10-16 02:35:19 +00:00
|
|
|
# . epilogue
|
2020-01-14 09:16:25 +00:00
|
|
|
89/<- %esp 5/r32/ebp
|
2019-08-26 18:55:26 +00:00
|
|
|
5d/pop-to-ebp
|
2019-05-26 06:47:49 +00:00
|
|
|
c3/return
|
|
|
|
|
|
|
|
test-parse-array-of-ints-just-whitespace:
|
|
|
|
# - just whitespace = empty array
|
2019-10-16 02:35:19 +00:00
|
|
|
# . prologue
|
2019-08-26 18:55:26 +00:00
|
|
|
55/push-ebp
|
2020-01-14 09:16:25 +00:00
|
|
|
89/<- %ebp 4/r32/esp
|
2020-04-04 02:36:57 +00:00
|
|
|
# var h/esi: handle
|
|
|
|
68/push 0/imm32
|
|
|
|
68/push 0/imm32
|
|
|
|
89/<- %esi 4/r32/esp
|
2020-03-21 22:07:59 +00:00
|
|
|
#
|
2020-10-26 04:15:43 +00:00
|
|
|
(_parse-array-of-ints Heap Space %esi)
|
2020-04-04 02:36:57 +00:00
|
|
|
(lookup *esi *(esi+4)) # => eax
|
|
|
|
(check-ints-equal *eax 0 "F - test-parse-array-of-ints-just-whitespace")
|
2019-10-16 02:35:19 +00:00
|
|
|
# . epilogue
|
2020-01-14 09:16:25 +00:00
|
|
|
89/<- %esp 5/r32/ebp
|
2019-08-26 18:55:26 +00:00
|
|
|
5d/pop-to-ebp
|
2019-05-26 06:47:49 +00:00
|
|
|
c3/return
|
|
|
|
|
|
|
|
test-parse-array-of-ints-extra-whitespace:
|
2019-10-16 02:35:19 +00:00
|
|
|
# . prologue
|
2019-08-26 18:55:26 +00:00
|
|
|
55/push-ebp
|
2020-01-14 09:16:25 +00:00
|
|
|
89/<- %ebp 4/r32/esp
|
2020-04-04 02:36:57 +00:00
|
|
|
# var h/esi: handle
|
|
|
|
68/push 0/imm32
|
|
|
|
68/push 0/imm32
|
|
|
|
89/<- %esi 4/r32/esp
|
2020-01-27 08:36:44 +00:00
|
|
|
# var ecx: (array int) = [1, 2, 3]
|
2020-01-14 09:16:25 +00:00
|
|
|
68/push 3/imm32
|
|
|
|
68/push 2/imm32
|
|
|
|
68/push 1/imm32
|
|
|
|
68/push 0xc/imm32/size
|
|
|
|
89/<- %ecx 4/r32/esp
|
2020-03-21 22:07:59 +00:00
|
|
|
#
|
2020-10-26 04:15:43 +00:00
|
|
|
(_parse-array-of-ints Heap " 1 2 3 " %esi)
|
2020-04-04 02:36:57 +00:00
|
|
|
(lookup *esi *(esi+4)) # => eax
|
2020-03-21 22:07:59 +00:00
|
|
|
(array-equal? %ecx %eax) # => eax
|
|
|
|
(check-ints-equal %eax 1 "F - test-parse-array-of-ints-extra-whitespace")
|
2019-10-16 02:35:19 +00:00
|
|
|
# . epilogue
|
2020-01-14 09:16:25 +00:00
|
|
|
89/<- %esp 5/r32/ebp
|
2019-08-26 18:55:26 +00:00
|
|
|
5d/pop-to-ebp
|
2019-05-26 06:47:49 +00:00
|
|
|
c3/return
|
|
|
|
|
2020-10-26 04:15:43 +00:00
|
|
|
parse-array-of-ints: # s: (addr array byte), out: (addr handle array int)
|
|
|
|
# . prologue
|
|
|
|
55/push-ebp
|
|
|
|
89/<- %ebp 4/r32/esp
|
|
|
|
#
|
|
|
|
(_parse-array-of-ints Heap *(ebp+8) *(ebp+0xc))
|
|
|
|
$parse-array-of-ints:end:
|
|
|
|
# . epilogue
|
|
|
|
89/<- %esp 5/r32/ebp
|
|
|
|
5d/pop-to-ebp
|
|
|
|
c3/return
|
|
|
|
|
2019-05-26 17:37:28 +00:00
|
|
|
# helper for later tests
|
|
|
|
# compare an array with a string representation of an array literal
|
2020-01-27 08:36:44 +00:00
|
|
|
check-array-equal: # a: (addr array int), expected: (addr string), msg: (addr string)
|
2019-10-16 02:35:19 +00:00
|
|
|
# . prologue
|
2019-08-26 18:55:26 +00:00
|
|
|
55/push-ebp
|
2020-01-14 09:16:25 +00:00
|
|
|
89/<- %ebp 4/r32/esp
|
2019-05-26 17:37:28 +00:00
|
|
|
# . save registers
|
2019-08-26 18:55:26 +00:00
|
|
|
50/push-eax
|
2020-04-04 02:36:57 +00:00
|
|
|
56/push-esi
|
|
|
|
# var h/esi: handle
|
|
|
|
68/push 0/imm32
|
|
|
|
68/push 0/imm32
|
|
|
|
89/<- %esi 4/r32/esp
|
|
|
|
# var b/eax: (addr array int) = parse-array-of-ints(Heap, expected)
|
2020-10-26 04:15:43 +00:00
|
|
|
(parse-array-of-ints *(ebp+0xc) %esi)
|
2020-04-04 02:36:57 +00:00
|
|
|
(lookup *esi *(esi+4)) # => eax
|
2020-03-21 22:07:59 +00:00
|
|
|
#
|
2020-04-04 02:36:57 +00:00
|
|
|
(array-equal? *(ebp+8) %eax)
|
2020-03-21 22:07:59 +00:00
|
|
|
(check-ints-equal %eax 1 *(ebp+0x10))
|
2019-05-26 17:37:28 +00:00
|
|
|
$check-array-equal:end:
|
|
|
|
# . restore registers
|
2020-04-04 02:36:57 +00:00
|
|
|
5e/pop-to-esi
|
2019-08-26 18:55:26 +00:00
|
|
|
58/pop-to-eax
|
2019-10-16 02:35:19 +00:00
|
|
|
# . epilogue
|
2020-01-14 09:16:25 +00:00
|
|
|
89/<- %esp 5/r32/ebp
|
2019-08-26 18:55:26 +00:00
|
|
|
5d/pop-to-ebp
|
2019-05-26 17:37:28 +00:00
|
|
|
c3/return
|
|
|
|
|
|
|
|
test-check-array-equal:
|
2019-10-16 02:35:19 +00:00
|
|
|
# . prologue
|
2019-08-26 18:55:26 +00:00
|
|
|
55/push-ebp
|
2020-01-14 09:16:25 +00:00
|
|
|
89/<- %ebp 4/r32/esp
|
2020-01-27 08:36:44 +00:00
|
|
|
# var ecx: (array int) = [1, 2, 3]
|
2020-01-14 09:16:25 +00:00
|
|
|
68/push 3/imm32
|
|
|
|
68/push 2/imm32
|
|
|
|
68/push 1/imm32
|
|
|
|
68/push 0xc/imm32/size
|
|
|
|
89/<- %ecx 4/r32/esp
|
2020-03-21 22:07:59 +00:00
|
|
|
#
|
|
|
|
(check-array-equal %ecx "1 2 3" "F - test-check-array-equal")
|
2019-10-16 02:35:19 +00:00
|
|
|
# . epilogue
|
2020-01-14 09:16:25 +00:00
|
|
|
89/<- %esp 5/r32/ebp
|
2019-08-26 18:55:26 +00:00
|
|
|
5d/pop-to-ebp
|
2019-05-26 17:37:28 +00:00
|
|
|
c3/return
|
7842 - new directory organization
Baremetal is now the default build target and therefore has its sources
at the top-level. Baremetal programs build using the phase-2 Mu toolchain
that requires a Linux kernel. This phase-2 codebase which used to be at
the top-level is now under the linux/ directory. Finally, the phase-2 toolchain,
while self-hosting, has a way to bootstrap from a C implementation, which
is now stored in linux/bootstrap. The bootstrap C implementation uses some
literate programming tools that are now in linux/bootstrap/tools.
So the whole thing has gotten inverted. Each directory should build one
artifact and include the main sources (along with standard library). Tools
used for building it are relegated to sub-directories, even though those
tools are often useful in their own right, and have had lots of interesting
programs written using them.
A couple of things have gotten dropped in this process:
- I had old ways to run on just a Linux kernel, or with a Soso kernel.
No more.
- I had some old tooling for running a single test at the cursor. I haven't
used that lately. Maybe I'll bring it back one day.
The reorg isn't done yet. Still to do:
- redo documentation everywhere. All the README files, all other markdown,
particularly vocabulary.md.
- clean up how-to-run comments at the start of programs everywhere
- rethink what to do with the html/ directory. Do we even want to keep
supporting it?
In spite of these shortcomings, all the scripts at the top-level, linux/
and linux/bootstrap are working. The names of the scripts also feel reasonable.
This is a good milestone to take stock at.
2021-03-04 06:09:50 +00:00
|
|
|
|
|
|
|
== data
|
|
|
|
|
|
|
|
# length-prefixed string containing just a single space
|
|
|
|
Space: # (array byte)
|
|
|
|
# size: int
|
|
|
|
1/imm32
|
|
|
|
# data
|
|
|
|
20/space
|