1 # Helper to allocate a stream on the heap.
  2 
  3 == code
  4 #   instruction                     effective address                                                   register    displacement    immediate
  5 # . op          subop               mod             rm32          base        index         scale       r32
  6 # . 1-3 bytes   3 bits              2 bits          3 bits        3 bits      3 bits        2 bits      2 bits      0/1/2/4 bytes   0/1/2/4 bytes
  7 
  8 new-stream:  # ad: (addr allocation-descriptor), length: int, elemsize: int, out: (addr handle stream _)
  9     # . prologue
 10     55/push-ebp
 11     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
 12     # . save registers
 13     50/push-eax
 14     52/push-edx
 15     # var size/edx: int = elemsize*length (clobbering eax)
 16     # . eax = elemsize
 17     8b/copy                         1/mod/*+disp8   5/rm32/ebp    .           .             .           0/r32/eax   0x10/disp8      .                 # copy *(ebp+16) to eax
 18     # . eax *= length
 19     31/xor                          3/mod/direct    2/rm32/edx    .           .             .           2/r32/edx   .               .                 # clear edx
 20     f7          4/subop/multiply    1/mod/*+disp8   5/rm32/ebp    .           .                                     0xc/disp8       .                 # multiply *(ebp+12) into edx:eax
 21     # . if overflow abort
 22     81          7/subop/compare     3/mod/direct    2/rm32/edx    .           .             .           .           .               0/imm32           # compare edx
 23     75/jump-if-!=  $new-stream:abort/disp8
 24     # . edx = elemsize*length
 25     89/copy                         3/mod/direct    2/rm32/edx    .           .             .           0/r32/eax   .               .                 # copy eax to edx
 26     # var n/eax: int = size + 12 (for read, write and size)
 27     05/add-to-eax  0xc/imm32
 28     # allocate(ad, n, out)
 29     # . . push args
 30     ff          6/subop/push        1/mod/*+disp8   5/rm32/ebp    .           .             .           .           0x14/disp8      .                 # push *(ebp+20)
 31     50/push-eax
 32     ff          6/subop/push        1/mod/*+disp8   5/rm32/ebp    .           .             .           .           8/disp8         .                 # push *(ebp+8)
 33     # . . call
 34     e8/call  allocate/disp32
 35     # . . discard args
 36     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               0xc/imm32         # add to esp
 37     # eax = out->payload
 38     8b/copy                         1/mod/*+disp8   5/rm32/ebp    .           .             .           0/r32/eax   0x14/disp8      .                 # copy *(ebp+20) to eax
 39     8b/copy                         1/mod/*+disp8   0/rm32/eax    .           .             .           0/r32/eax   4/disp8         .                 # copy *(eax+4) to eax
 40     # skip payload->allocid
 41     05/add-to-eax  4/imm32
 42     # eax->size = size
 43     89/copy                         1/mod/*+disp8   0/rm32/eax    .           .             .           2/r32/edx   8/disp8         .                 # copy edx to *(eax+8)
 44     # clear-stream(eax)
 45     # . . push args
 46     50/push-eax
 47     # . . call
 48     e8/call  clear-stream/disp32
 49     # . . discard args
 50     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               4/imm32           # add to esp
 51 $new-stream:end:
 52     # . restore registers
 53     5a/pop-to-edx
 54     58/pop-to-eax
 55     # . epilogue
 56     89/copy                         3/mod/direct    4/rm32/esp    .           .             .           5/r32/ebp   .               .                 # copy ebp to esp
 57     5d/pop-to-ebp
 58     c3/return
 59 
 60 $new-stream:abort:
 61     (abort "new-stream: size too large")
 62     # never gets here
 63 
 64 test-new-stream:
 65     # . prologue
 66     55/push-ebp
 67     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
 68     # var ad/ecx: allocation-descriptor containing 16 bytes
 69     # . var end/ecx: (addr byte)
 70     89/<- %ecx 4/r32/esp
 71     # . var start/edx: (addr byte) = end - 32
 72     81 5/subop/subtract %esp 0x20/imm32
 73     89/<- %edx 4/r32/esp
 74     # . ad = {start, end}
 75     51/push-ecx
 76     52/push-edx
 77     89/copy                         3/mod/direct    1/rm32/ecx    .           .             .           4/r32/esp   .               .                 # copy esp to ecx
 78     # var start/edx = ad->curr
 79     8b/copy                         0/mod/indirect  1/rm32/ecx    .           .             .           2/r32/edx   .               .                 # copy *ecx to edx
 80     # var h/ebx: (handle stream byte)
 81     68/push  0/imm32
 82     68/push  0/imm32
 83     89/copy                         3/mod/direct    3/rm32/ebx    .           .             .           4/r32/esp   .               .                 # copy esp to ebx
 84     # new-stream(ad, 3, 2, h)
 85     # . . push args
 86     53/push-ebx
 87     68/push  2/imm32
 88     68/push  3/imm32
 89     51/push-ecx
 90     # . . call
 91     e8/call  new-stream/disp32
 92     # . . discard args
 93     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               0x10/imm32        # add to esp
 94     # eax = out->payload
 95     8b/copy                         1/mod/*+disp8   3/rm32/ebx    .           .             .           0/r32/eax   4/disp8         .                 # copy *(ebx+4) to eax
 96     # check-ints-equal(eax, edx, msg)
 97     # . . push args
 98     68/push  "F - test-new-stream: returns current pointer of allocation descriptor"/imm32
 99     52/push-edx
100     50/push-eax
101     # . . call
102     e8/call  check-ints-equal/disp32
103     # . . discard args
104     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               0xc/imm32         # add to esp
105     # skip payload->allocid
106     05/add-to-eax  4/imm32
107     # check-ints-equal(eax->size, 6, msg)
108     # . . push args
109     68/push  "F - test-new-stream: sets size correctly"/imm32
110     68/push  6/imm32
111     ff          6/subop/push        1/mod/*+disp8   0/rm32/eax    .           .             .           .           .               8/disp8           # push *(eax+8)
112     # . . call
113     e8/call  check-ints-equal/disp32
114     # . . discard args
115     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               0xc/imm32         # add to esp
116     # the rest is delegated to clear-stream() so we won't bother checking it
117     # . reclaim locals
118     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               0x30/imm32        # add to esp
119     # . epilogue
120     89/copy                         3/mod/direct    4/rm32/esp    .           .             .           5/r32/ebp   .               .                 # copy ebp to esp
121     5d/pop-to-ebp
122     c3/return
123 
124 # . . vim:nowrap:textwidth=0