309stream.subx

   1 # Some unsafe methods not intended to be used directly in SubX, only through
   2 # Mu after proper type-checking.
   3
   4 == code
   5
   6 stream-empty?:  # s: (addr stream _) -> result/eax: boolean
   7     # . prologue
   8     55/push-ebp
   9     89/<- %ebp 4/r32/esp
  10     # . save registers
  11     51/push-ecx
  12     56/push-esi
  13     # result = false
  14     b8/copy-to-eax 0/imm32/false
  15     # esi = s
  16     8b/-> *(ebp+8) 6/r32/esi
  17     # return s->read >= s->write
  18     8b/-> *esi 1/r32/ecx
  19     39/compare-with *(esi+4) 1/r32/ecx
  20     0f 9d/set-if->= %al
  21 $stream-empty?:end:
  22     # . restore registers
  23     5e/pop-to-esi
  24     59/pop-to-ecx
  25     # . epilogue
  26     89/<- %esp 5/r32/ebp
  27     5d/pop-to-ebp
  28     c3/return
  29
  30 stream-full?:  # s: (addr stream _) -> result/eax: boolean
  31     # . prologue
  32     55/push-ebp
  33     89/<- %ebp 4/r32/esp
  34     # . save registers
  35     51/push-ecx
  36     56/push-esi
  37     # result = false
  38     b8/copy-to-eax 0/imm32/false
  39     # esi = s
  40     8b/-> *(ebp+8) 6/r32/esi
  41     # return s->write >= s->size
  42     8b/-> *(esi+8) 1/r32/ecx
  43     39/compare-with *esi 1/r32/ecx
  44     0f 9d/set-if->= %al
  45 $stream-full?:end:
  46     # . restore registers
  47     5e/pop-to-esi
  48     59/pop-to-ecx
  49     # . epilogue
  50     89/<- %esp 5/r32/ebp
  51     5d/pop-to-ebp
  52     c3/return
  53
  54 write-to-stream:  # s: (addr stream _), in: (addr byte), n: int
  55     # . prologue
  56     55/push-ebp
  57     89/<- %ebp 4/r32/esp
  58     # . save registers
  59     50/push-eax
  60     51/push-ecx
  61     52/push-edx
  62     53/push-ebx
  63     57/push-edi
  64     # edi = s
  65     8b/-> *(ebp+8) 7/r32/edi
  66     # var swrite/edx: int = s->write
  67     8b/-> *edi 2/r32/edx
  68     # if (swrite + n > s->size) abort
  69     8b/-> *(ebp+0x10) 1/r32/ecx
  70     01/add-to %ecx 2/r32/edx
  71     3b/compare 1/r32/ecx *(edi+8)
  72     0f 8f/jump-if-> $write-to-stream:abort/disp32
  73     # var out/edx: (addr byte) = s->data + s->write
  74     8d/copy-address *(edi+edx+0xc) 2/r32/edx
  75     # var outend/ebx: (addr byte) = out + n
  76     8b/-> *(ebp+0x10) 3/r32/ebx
  77     8d/copy-address *(edx+ebx) 3/r32/ebx
  78     # eax = in
  79     8b/-> *(ebp+0xc) 0/r32/eax
  80     # var inend/ecx: (addr byte) = in + n
  81     8b/-> *(ebp+0x10) 1/r32/ecx
  82     8d/copy-address *(eax+ecx) 1/r32/ecx
  83     #
  84     (_append-4  %edx %ebx  %eax %ecx)  # => eax
  85     # s->write += n
  86     8b/-> *(ebp+0x10) 1/r32/ecx
  87     01/add-to *edi 1/r32/ecx
  88 $write-to-stream:end:
  89     # . restore registers
  90     5f/pop-to-edi
  91     5b/pop-to-ebx
  92     5a/pop-to-edx
  93     59/pop-to-ecx
  94     58/pop-to-eax
  95     # . epilogue
  96     89/<- %esp 5/r32/ebp
  97     5d/pop-to-ebp
  98     c3/return
  99
 100 $write-to-stream:abort:
 101     (abort "write-to-stream: stream full")
 102     # never gets here
 103
 104 read-from-stream:  # s: (addr stream _), out: (addr byte), n: int
 105     # . prologue
 106     55/push-ebp
 107     89/<- %ebp 4/r32/esp
 108     # . save registers
 109     50/push-eax
 110     51/push-ecx
 111     52/push-edx
 112     53/push-ebx
 113     56/push-esi
 114     # esi = s
 115     8b/-> *(ebp+8) 6/r32/esi
 116     # var sread/edx: int = s->read
 117     8b/-> *(esi+4) 2/r32/edx
 118     # if (sread + n > s->write) abort
 119     8b/-> *(ebp+0x10) 1/r32/ecx
 120     01/add-to %ecx 2/r32/edx
 121     3b/compare 1/r32/ecx *esi
 122     0f 8f/jump-if-> $read-from-stream:abort/disp32
 123     # var in/edx: (addr byte) = s->data + s->read
 124     8d/copy-address *(esi+edx+0xc) 2/r32/edx
 125     # var inend/ebx: (addr byte) = in + n
 126     8b/-> *(ebp+0x10) 3/r32/ebx
 127     8d/copy-address *(edx+ebx) 3/r32/ebx
 128     # eax = out
 129     8b/-> *(ebp+0xc) 0/r32/eax
 130     # var outend/ecx: (addr byte) = out + n
 131     8b/-> *(ebp+0x10) 1/r32/ecx
 132     8d/copy-address *(eax+ecx) 1/r32/ecx
 133     #
 134     (_append-4  %eax %ecx  %edx %ebx)  # => eax
 135     # s->read += n
 136     8b/-> *(ebp+0x10) 1/r32/ecx
 137     01/add-to *(esi+4) 1/r32/ecx
 138 $read-from-stream:end:
 139     # . restore registers
 140     5e/pop-to-esi
 141     5b/pop-to-ebx
 142     5a/pop-to-edx
 143     59/pop-to-ecx
 144     58/pop-to-eax
 145     # . epilogue
 146     89/<- %esp 5/r32/ebp
 147     5d/pop-to-ebp
 148     c3/return
 149
 150 $read-from-stream:abort:
 151     (abort "read-from-stream: stream empty")
 152     # never gets here
 153
 154 stream-first:  # s: (addr stream byte) -> result/eax: byte
 155     # . prologue
 156     55/push-ebp
 157     89/<- %ebp 4/r32/esp
 158     # . save registers
 159     51/push-ecx
 160     56/push-esi
 161     # result = false
 162     b8/copy-to-eax 0/imm32
 163     # esi = s
 164     8b/-> *(ebp+8) 6/r32/esi
 165     # var idx/ecx: int = s->read
 166     8b/-> *(esi+4) 1/r32/ecx
 167     # if idx >= s->write return 0
 168     3b/compare-with 1/r32/ecx *esi
 169     7d/jump-if->= $stream-first:end/disp8
 170     # result = s->data[idx]
 171     8a/byte-> *(esi+ecx+0xc) 0/r32/AL
 172 $stream-first:end:
 173     # . restore registers
 174     5e/pop-to-esi
 175     59/pop-to-ecx
 176     # . epilogue
 177     89/<- %esp 5/r32/ebp
 178     5d/pop-to-ebp
 179     c3/return
 180
 181 stream-final:  # s: (addr stream byte) -> result/eax: byte
 182     # . prologue
 183     55/push-ebp
 184     89/<- %ebp 4/r32/esp
 185     # . save registers
 186     51/push-ecx
 187     56/push-esi
 188     # result = false
 189     b8/copy-to-eax 0/imm32
 190     # esi = s
 191     8b/-> *(ebp+8) 6/r32/esi
 192     # var max/ecx: int = s->write
 193     8b/-> *esi 1/r32/ecx
 194     # if s->read >= max return 0
 195     39/compare-with *(esi+4) 1/r32/ecx
 196     7d/jump-if->= $stream-final:end/disp8
 197     # var idx/ecx: int = max - 1
 198     49/decrement-ecx
 199     # result = s->data[idx]
 200     8a/byte-> *(esi+ecx+0xc) 0/r32/AL
 201 $stream-final:end:
 202     # . restore registers
 203     5e/pop-to-esi
 204     59/pop-to-ecx
 205     # . epilogue
 206     89/<- %esp 5/r32/ebp
 207     5d/pop-to-ebp
 208     c3/return
 209
 210 # compare all the data in two streams (ignoring the read pointer)
 211 streams-data-equal?:  # a: (addr stream byte), b: (addr array byte) -> result/eax: boolean
 212     # pseudocode:
 213     #   awrite = a->write
 214     #   if (awrite != b->write) return false
 215     #   i = 0
 216     #   curra = a->data
 217     #   currb = b->data
 218     #   while i < awrite
 219     #     i1 = *curra
 220     #     i2 = *currb
 221     #     if (c1 != c2) return false
 222     #     i+=4, curra+=4, currb+=4
 223     #   return true
 224     #
 225     # registers:
 226     #   i: ecx
 227     #   awrite: edx
 228     #   curra: esi
 229     #   currb: edi
 230     #   i1: eax
 231     #   i2: ebx
 232     #
 233     # . prologue
 234     55/push-ebp
 235     89/<- %ebp 4/r32/esp
 236     # . save registers
 237     51/push-ecx
 238     52/push-edx
 239     53/push-ebx
 240     56/push-esi
 241     57/push-edi
 242     # esi = a
 243     8b/-> *(ebp+8) 6/r32/esi
 244     # edi = b
 245     8b/-> *(ebp+0xc) 7/r32/edi
 246     # var awrite/edx: int = a->write
 247     8b/-> *esi 2/r32/edx
 248 $streams-data-equal?:sizes:
 249     # if (awrite != b->write) return false
 250     39/compare *edi 2/r32/edx
 251     75/jump-if-!= $streams-data-equal?:false/disp8
 252     # var curra/esi: (addr byte) = a->data
 253     81 0/subop/add %esi 0xc/imm32
 254     # var currb/edi: (addr byte) = b->data
 255     81 0/subop/add %edi 0xc/imm32
 256     # var i/ecx: int = 0
 257     31/xor-with %ecx 1/r32/ecx
 258     # var vala/eax: int
 259     31/xor-with %eax 0/r32/eax
 260     # var valb/ebx: int
 261     31/xor-with %ebx 3/r32/ebx
 262 $streams-data-equal?:loop:
 263     {
 264       # if (i >= awrite) return true
 265       39/compare %ecx 2/r32/edx
 266       7d/jump-if->= $streams-data-equal?:true/disp8
 267       # var vala/eax: int = *curra
 268       8a/byte-> *esi 0/r32/eax
 269       # var valb/ebx: int = *currb
 270       8a/byte-> *edi 3/r32/ebx
 271       # if (vala != valb) return false
 272       39/compare %eax 3/r32/ebx
 273       75/jump-if-!= $streams-data-equal?:false/disp8
 274       # i++
 275       41/increment-ecx
 276       # curra++
 277       46/increment-esi
 278       # currb++
 279       47/increment-edi
 280       eb/jump loop/disp8
 281     }
 282 $streams-data-equal?:true:
 283     b8/copy-to-eax 1/imm32
 284     eb/jump $streams-data-equal?:end/disp8
 285 $streams-data-equal?:false:
 286     b8/copy-to-eax 0/imm32
 287 $streams-data-equal?:end:
 288     # . restore registers
 289     5f/pop-to-edi
 290     5e/pop-to-esi
 291     5b/pop-to-ebx
 292     5a/pop-to-edx
 293     59/pop-to-ecx
 294     # . epilogue
 295     89/<- %esp 5/r32/ebp
 296     5d/pop-to-ebp
 297     c3/return
 298
 299 # helper for tests
 300 check-streams-data-equal:  # s: (addr stream _), expected: (addr array _), msg: (addr array byte)
 301     # . prologue
 302     55/push-ebp
 303     89/<- %ebp 4/r32/esp
 304     # . save registers
 305     50/push-eax
 306     #
 307     (streams-data-equal? *(ebp+8) *(ebp+0xc))  # => eax
 308     (check-ints-equal %eax 1 *(ebp+0x10))
 309 $check-streams-data-equal:end:
 310     # . restore registers
 311     58/pop-to-eax
 312     # . epilogue
 313     89/<- %esp 5/r32/ebp
 314     5d/pop-to-ebp
 315     c3/return