1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
|
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Mu - 069allocate.subx</title>
<meta name="Generator" content="Vim/8.1">
<meta name="plugin-version" content="vim8.1_v1">
<meta name="syntax" content="none">
<meta name="settings" content="number_lines,use_css,no_foldcolumn,expand_tabs,line_ids,prevent_copy=">
<meta name="colorscheme" content="minimal-light">
<style type="text/css">
<!--
pre { font-family: monospace; color: #000000; background-color: #c6c6c6; }
body { font-size:12pt; font-family: monospace; color: #000000; background-color: #c6c6c6; }
a { color:inherit; }
* { font-size:12pt; font-size: 1em; }
.subxComment { color: #005faf; }
.subxS2Comment { color: #8a8a8a; }
.subxFunction { color: #af5f00; text-decoration: underline; }
.LineNr { }
.subxS1Comment { color: #0000af; }
.SpecialChar { color: #d70000; }
.Normal { color: #000000; background-color: #c6c6c6; padding-bottom: 1px; }
.subxMinorFunction { color: #875f5f; }
.Constant { color: #008787; }
.subxTest { color: #5f8700; }
-->
</style>
<script type='text/javascript'>
<!--
/* function to open any folds containing a jumped-to line before jumping to it */
function JumpToLine()
{
var lineNum;
lineNum = window.location.hash;
lineNum = lineNum.substr(1); /* strip off '#' */
if (lineNum.indexOf('L') == -1) {
lineNum = 'L'+lineNum;
}
var lineElem = document.getElementById(lineNum);
/* Always jump to new location even if the line was hidden inside a fold, or
* we corrected the raw number to a line ID.
*/
if (lineElem) {
lineElem.scrollIntoView(true);
}
return true;
}
if ('onhashchange' in window) {
window.onhashchange = JumpToLine;
}
-->
</script>
</head>
<body onload='JumpToLine();'>
<a href='https://github.com/akkartik/mu/blob/master/069allocate.subx'>https://github.com/akkartik/mu/blob/master/069allocate.subx</a>
<pre id='vimCodeElement'>
<span id="L1" class="LineNr"> 1 </span><span class="subxComment"># Helper to dynamically allocate memory on the heap.</span>
<span id="L2" class="LineNr"> 2 </span><span class="subxComment">#</span>
<span id="L3" class="LineNr"> 3 </span><span class="subxComment"># We'd like to be able to write tests for functions that allocate memory,</span>
<span id="L4" class="LineNr"> 4 </span><span class="subxComment"># making assertions on the precise addresses used. To achieve this we'll pass</span>
<span id="L5" class="LineNr"> 5 </span><span class="subxComment"># in an *allocation descriptor* to allocate from.</span>
<span id="L6" class="LineNr"> 6 </span><span class="subxComment">#</span>
<span id="L7" class="LineNr"> 7 </span><span class="subxComment"># Allocation descriptors are also useful outside of tests. Assembly and machine</span>
<span id="L8" class="LineNr"> 8 </span><span class="subxComment"># code are of necessity unsafe languages, and one of the most insidious kinds</span>
<span id="L9" class="LineNr"> 9 </span><span class="subxComment"># of bugs unsafe languages expose us to are dangling pointers to memory that</span>
<span id="L10" class="LineNr"> 10 </span><span class="subxComment"># has been freed and potentially even reused for something totally different.</span>
<span id="L11" class="LineNr"> 11 </span><span class="subxComment"># To reduce the odds of such "use after free" errors, SubX programs tend to not</span>
<span id="L12" class="LineNr"> 12 </span><span class="subxComment"># reclaim and reuse dynamically allocated memory. (Running out of memory is far</span>
<span id="L13" class="LineNr"> 13 </span><span class="subxComment"># easier to debug.) Long-running programs that want to reuse memory are mostly</span>
<span id="L14" class="LineNr"> 14 </span><span class="subxComment"># on their own to be careful. However, they do get one bit of help: they can</span>
<span id="L15" class="LineNr"> 15 </span><span class="subxComment"># carve out chunks of memory and then allocate from them manually using this</span>
<span id="L16" class="LineNr"> 16 </span><span class="subxComment"># very same 'allocate' helper. They just need a new allocation descriptor for</span>
<span id="L17" class="LineNr"> 17 </span><span class="subxComment"># their book-keeping.</span>
<span id="L18" class="LineNr"> 18 </span>
<span id="L19" class="LineNr"> 19 </span>== data
<span id="L20" class="LineNr"> 20 </span>
<span id="L21" class="LineNr"> 21 </span><span class="subxComment"># A default allocation descriptor for programs to use.</span>
<span id="L22" class="LineNr"> 22 </span><span class="SpecialChar">Heap</span>: <span class="subxComment"># allocation-descriptor</span>
<span id="L23" class="LineNr"> 23 </span> <span class="subxComment"># curr</span>
<span id="L24" class="LineNr"> 24 </span> 0/imm32
<span id="L25" class="LineNr"> 25 </span> <span class="subxComment"># limit</span>
<span id="L26" class="LineNr"> 26 </span> 0/imm32
<span id="L27" class="LineNr"> 27 </span>
<span id="L28" class="LineNr"> 28 </span><span class="subxComment"># a reasonable default</span>
<span id="L29" class="LineNr"> 29 </span><span class="SpecialChar">Heap-size</span>: <span class="subxComment"># int</span>
<span id="L30" class="LineNr"> 30 </span> 0x400000/imm32/4MB
<span id="L31" class="LineNr"> 31 </span>
<span id="L32" class="LineNr"> 32 </span>== code
<span id="L33" class="LineNr"> 33 </span><span class="subxComment"># instruction effective address register displacement immediate</span>
<span id="L34" class="LineNr"> 34 </span><span class="subxS1Comment"># . op subop mod rm32 base index scale r32</span>
<span id="L35" class="LineNr"> 35 </span><span class="subxS1Comment"># . 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</span>
<span id="L36" class="LineNr"> 36 </span>
<span id="L37" class="LineNr"> 37 </span><span class="subxComment"># Let's start initializing the default allocation descriptor.</span>
<span id="L38" class="LineNr"> 38 </span>
<span id="L39" class="LineNr"> 39 </span><span class="SpecialChar">Entry</span>:
<span id="L40" class="LineNr"> 40 </span> <span class="subxComment"># initialize heap</span>
<span id="L41" class="LineNr"> 41 </span> <span class="subxS1Comment"># . Heap = new-segment(Heap-size)</span>
<span id="L42" class="LineNr"> 42 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L43" class="LineNr"> 43 </span> 68/push <span class="SpecialChar"><a href='069allocate.subx.html#L22'>Heap</a></span>/imm32
<span id="L44" class="LineNr"> 44 </span> ff 6/subop/push 0/mod/indirect 5/rm32/.disp32 <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="SpecialChar"><a href='069allocate.subx.html#L29'>Heap-size</a></span>/disp32 <span class="subxComment"># push *Heap-size</span>
<span id="L45" class="LineNr"> 45 </span> <span class="subxS2Comment"># . . call</span>
<span id="L46" class="LineNr"> 46 </span> e8/call <a href='053new-segment.subx.html#L41'>new-segment</a>/disp32
<span id="L47" class="LineNr"> 47 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L48" class="LineNr"> 48 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to esp</span>
<span id="L49" class="LineNr"> 49 </span>
<span id="L50" class="LineNr"> 50 </span> e8/call run-tests/disp32 <span class="subxComment"># 'run-tests' is a function created automatically by SubX. It calls all functions that start with 'test-'.</span>
<span id="L51" class="LineNr"> 51 </span><span class="Constant">$array-equal-main:end</span>:
<span id="L52" class="LineNr"> 52 </span> <span class="subxComment"># syscall(exit, Num-test-failures)</span>
<span id="L53" class="LineNr"> 53 </span> 8b/copy 0/mod/indirect 5/rm32/.disp32 <span class="Normal"> . </span> <span class="Normal"> . </span> 3/r32/ebx <span class="SpecialChar"><a href='051test.subx.html#L90'>Num-test-failures</a></span>/disp32 <span class="subxComment"># copy *Num-test-failures to ebx</span>
<span id="L54" class="LineNr"> 54 </span> b8/copy-to-eax 1/imm32/exit
<span id="L55" class="LineNr"> 55 </span> cd/syscall 0x80/imm8
<span id="L56" class="LineNr"> 56 </span>
<span id="L57" class="LineNr"> 57 </span><span class="subxComment"># Claim the next 'n' bytes of memory starting at ad->curr and update ad->curr.</span>
<span id="L58" class="LineNr"> 58 </span><span class="subxComment"># Abort if there isn't enough memory in 'ad'.</span>
<span id="L59" class="LineNr"> 59 </span><span class="subxFunction">allocate</span>: <span class="subxComment"># ad: (addr allocation-descriptor), n: int -> address-or-null/eax: (addr _)</span>
<span id="L60" class="LineNr"> 60 </span> <span class="subxS1Comment"># . prologue</span>
<span id="L61" class="LineNr"> 61 </span> 55/push-ebp
<span id="L62" class="LineNr"> 62 </span> 89/copy 3/mod/direct 5/rm32/ebp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/r32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># copy esp to ebp</span>
<span id="L63" class="LineNr"> 63 </span> <span class="subxS1Comment"># . save registers</span>
<span id="L64" class="LineNr"> 64 </span> 51/push-ecx
<span id="L65" class="LineNr"> 65 </span> 52/push-edx
<span id="L66" class="LineNr"> 66 </span> <span class="subxComment"># ecx = ad</span>
<span id="L67" class="LineNr"> 67 </span> 8b/copy 1/mod/*+disp8 5/rm32/ebp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 1/r32/ecx 8/disp8 <span class="Normal"> . </span> <span class="subxComment"># copy *(ebp+8) to ecx</span>
<span id="L68" class="LineNr"> 68 </span> <span class="subxComment"># save ad->curr</span>
<span id="L69" class="LineNr"> 69 </span> 8b/copy 0/mod/indirect 1/rm32/ecx <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 0/r32/eax <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># copy *ecx to eax</span>
<span id="L70" class="LineNr"> 70 </span> <span class="subxComment"># check if there's enough space</span>
<span id="L71" class="LineNr"> 71 </span> <span class="subxS1Comment"># . edx = ad->curr + n</span>
<span id="L72" class="LineNr"> 72 </span> 89/copy 3/mod/direct 2/rm32/edx <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 0/r32/eax <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># copy eax to edx</span>
<span id="L73" class="LineNr"> 73 </span> 03/add 1/mod/*+disp8 5/rm32/ebp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 2/r32/edx 0xc/disp8 <span class="Normal"> . </span> <span class="subxComment"># add *(ebp+12) to edx</span>
<span id="L74" class="LineNr"> 74 </span> 3b/compare 1/mod/*+disp8 1/rm32/ecx <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 2/r32/edx 4/disp8 <span class="Normal"> . </span> <span class="subxComment"># compare edx with *(ecx+4)</span>
<span id="L75" class="LineNr"> 75 </span> 73/jump-if->=-signed $allocate:abort/disp8
<span id="L76" class="LineNr"> 76 </span><span class="Constant">$allocate:commit</span>:
<span id="L77" class="LineNr"> 77 </span> <span class="subxComment"># update ad->curr</span>
<span id="L78" class="LineNr"> 78 </span> 89/copy 0/mod/indirect 1/rm32/ecx <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 2/r32/edx <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># copy edx to *ecx</span>
<span id="L79" class="LineNr"> 79 </span><span class="Constant">$allocate:end</span>:
<span id="L80" class="LineNr"> 80 </span> <span class="subxS1Comment"># . restore registers</span>
<span id="L81" class="LineNr"> 81 </span> 5a/pop-to-edx
<span id="L82" class="LineNr"> 82 </span> 59/pop-to-ecx
<span id="L83" class="LineNr"> 83 </span> <span class="subxS1Comment"># . epilogue</span>
<span id="L84" class="LineNr"> 84 </span> 89/copy 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 5/r32/ebp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># copy ebp to esp</span>
<span id="L85" class="LineNr"> 85 </span> 5d/pop-to-ebp
<span id="L86" class="LineNr"> 86 </span> c3/return
<span id="L87" class="LineNr"> 87 </span>
<span id="L88" class="LineNr"> 88 </span><span class="Constant">$allocate:abort</span>:
<span id="L89" class="LineNr"> 89 </span> <span class="subxS1Comment"># . _write(2/stderr, error)</span>
<span id="L90" class="LineNr"> 90 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L91" class="LineNr"> 91 </span> 68/push <span class="Constant">"allocate: failed to allocate\n"</span>/imm32
<span id="L92" class="LineNr"> 92 </span> 68/push 2/imm32/stderr
<span id="L93" class="LineNr"> 93 </span> <span class="subxS2Comment"># . . call</span>
<span id="L94" class="LineNr"> 94 </span> e8/call <a href='050_write.subx.html#L14'>_write</a>/disp32
<span id="L95" class="LineNr"> 95 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L96" class="LineNr"> 96 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to esp</span>
<span id="L97" class="LineNr"> 97 </span> <span class="subxS1Comment"># . syscall(exit, 1)</span>
<span id="L98" class="LineNr"> 98 </span> bb/copy-to-ebx 1/imm32
<span id="L99" class="LineNr"> 99 </span> b8/copy-to-eax 1/imm32/exit
<span id="L100" class="LineNr">100 </span> cd/syscall 0x80/imm8
<span id="L101" class="LineNr">101 </span> <span class="subxComment"># never gets here</span>
<span id="L102" class="LineNr">102 </span>
<span id="L103" class="LineNr">103 </span><span class="subxTest">test-allocate-success</span>:
<span id="L104" class="LineNr">104 </span> <span class="subxS1Comment"># . prologue</span>
<span id="L105" class="LineNr">105 </span> 55/push-ebp
<span id="L106" class="LineNr">106 </span> 89/copy 3/mod/direct 5/rm32/ebp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/r32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># copy esp to ebp</span>
<span id="L107" class="LineNr">107 </span> <span class="subxComment"># var ad/ecx: allocation-descriptor = {11, 15}</span>
<span id="L108" class="LineNr">108 </span> 68/push 0xf/imm32/limit
<span id="L109" class="LineNr">109 </span> 68/push 0xb/imm32/curr
<span id="L110" class="LineNr">110 </span> 89/copy 3/mod/direct 1/rm32/ecx <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/r32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># copy esp to ecx</span>
<span id="L111" class="LineNr">111 </span> <span class="subxComment"># var eax: (handle byte) = allocate(ad, 3)</span>
<span id="L112" class="LineNr">112 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L113" class="LineNr">113 </span> 68/push 3/imm32
<span id="L114" class="LineNr">114 </span> 51/push-ecx
<span id="L115" class="LineNr">115 </span> <span class="subxS2Comment"># . . call</span>
<span id="L116" class="LineNr">116 </span> e8/call <a href='069allocate.subx.html#L59'>allocate</a>/disp32
<span id="L117" class="LineNr">117 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L118" class="LineNr">118 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to esp</span>
<span id="L119" class="LineNr">119 </span> <span class="subxComment"># check-ints-equal(eax, 11, msg)</span>
<span id="L120" class="LineNr">120 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L121" class="LineNr">121 </span> 68/push <span class="Constant">"F - <a href='069allocate.subx.html#L103'>test-allocate-success</a>: returns current pointer of allocation descriptor"</span>/imm32
<span id="L122" class="LineNr">122 </span> 68/push 0xb/imm32
<span id="L123" class="LineNr">123 </span> 50/push-eax
<span id="L124" class="LineNr">124 </span> <span class="subxS2Comment"># . . call</span>
<span id="L125" class="LineNr">125 </span> e8/call <a href='051test.subx.html#L24'>check-ints-equal</a>/disp32
<span id="L126" class="LineNr">126 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L127" class="LineNr">127 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 0xc/imm32 <span class="subxComment"># add to esp</span>
<span id="L128" class="LineNr">128 </span> <span class="subxComment"># check-ints-equal(ad->curr, 14, msg)</span>
<span id="L129" class="LineNr">129 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L130" class="LineNr">130 </span> 68/push <span class="Constant">"F - <a href='069allocate.subx.html#L103'>test-allocate-success</a>: updates allocation descriptor"</span>/imm32
<span id="L131" class="LineNr">131 </span> 68/push 0xe/imm32
<span id="L132" class="LineNr">132 </span> ff 6/subop/push 0/mod/indirect 1/rm32/ecx <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># push *ecx</span>
<span id="L133" class="LineNr">133 </span> <span class="subxS2Comment"># . . call</span>
<span id="L134" class="LineNr">134 </span> e8/call <a href='051test.subx.html#L24'>check-ints-equal</a>/disp32
<span id="L135" class="LineNr">135 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L136" class="LineNr">136 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 0xc/imm32 <span class="subxComment"># add to esp</span>
<span id="L137" class="LineNr">137 </span> <span class="subxS1Comment"># . epilogue</span>
<span id="L138" class="LineNr">138 </span> 89/copy 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 5/r32/ebp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># copy ebp to esp</span>
<span id="L139" class="LineNr">139 </span> 5d/pop-to-ebp
<span id="L140" class="LineNr">140 </span> c3/return
<span id="L141" class="LineNr">141 </span>
<span id="L142" class="LineNr">142 </span><span class="subxMinorFunction">_pending-test-allocate-failure</span>:
<span id="L143" class="LineNr">143 </span> <span class="subxS1Comment"># . prologue</span>
<span id="L144" class="LineNr">144 </span> 55/push-ebp
<span id="L145" class="LineNr">145 </span> 89/copy 3/mod/direct 5/rm32/ebp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/r32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># copy esp to ebp</span>
<span id="L146" class="LineNr">146 </span> <span class="subxComment"># var ad/ecx: allocation-descriptor = {11, 15}</span>
<span id="L147" class="LineNr">147 </span> 68/push 0xf/imm32/limit
<span id="L148" class="LineNr">148 </span> 68/push 0xb/imm32/curr
<span id="L149" class="LineNr">149 </span> 89/copy 3/mod/direct 1/rm32/ecx <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/r32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># copy esp to ecx</span>
<span id="L150" class="LineNr">150 </span> <span class="subxComment"># var eax: (handle byte) = allocate(ad, 6)</span>
<span id="L151" class="LineNr">151 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L152" class="LineNr">152 </span> 68/push 6/imm32
<span id="L153" class="LineNr">153 </span> 51/push-ecx
<span id="L154" class="LineNr">154 </span> <span class="subxS2Comment"># . . call</span>
<span id="L155" class="LineNr">155 </span> e8/call <a href='069allocate.subx.html#L59'>allocate</a>/disp32
<span id="L156" class="LineNr">156 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L157" class="LineNr">157 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to esp</span>
<span id="L158" class="LineNr">158 </span> <span class="subxComment"># check-ints-equal(eax, 0, msg)</span>
<span id="L159" class="LineNr">159 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L160" class="LineNr">160 </span> 68/push <span class="Constant">"F - test-allocate-failure: returns null"</span>/imm32
<span id="L161" class="LineNr">161 </span> 68/push 0/imm32
<span id="L162" class="LineNr">162 </span> 50/push-eax
<span id="L163" class="LineNr">163 </span> <span class="subxS2Comment"># . . call</span>
<span id="L164" class="LineNr">164 </span> e8/call <a href='051test.subx.html#L24'>check-ints-equal</a>/disp32
<span id="L165" class="LineNr">165 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L166" class="LineNr">166 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 0xc/imm32 <span class="subxComment"># add to esp</span>
<span id="L167" class="LineNr">167 </span> <span class="subxComment"># no change to ad->curr</span>
<span id="L168" class="LineNr">168 </span> <span class="subxS1Comment"># . check-ints-equal(ad->curr, 11)</span>
<span id="L169" class="LineNr">169 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L170" class="LineNr">170 </span> 68/push <span class="Constant">"F - test-allocate-failure: updates allocation descriptor"</span>/imm32
<span id="L171" class="LineNr">171 </span> 68/push 0xb/imm32
<span id="L172" class="LineNr">172 </span> ff 6/subop/push 0/mod/indirect 1/rm32/ecx <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># push *ecx</span>
<span id="L173" class="LineNr">173 </span> <span class="subxS2Comment"># . . call</span>
<span id="L174" class="LineNr">174 </span> e8/call <a href='051test.subx.html#L24'>check-ints-equal</a>/disp32
<span id="L175" class="LineNr">175 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L176" class="LineNr">176 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 0xc/imm32 <span class="subxComment"># add to esp</span>
<span id="L177" class="LineNr">177 </span> <span class="subxS1Comment"># . epilogue</span>
<span id="L178" class="LineNr">178 </span> 89/copy 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 5/r32/ebp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># copy ebp to esp</span>
<span id="L179" class="LineNr">179 </span> 5d/pop-to-ebp
<span id="L180" class="LineNr">180 </span> c3/return
<span id="L181" class="LineNr">181 </span>
<span id="L182" class="LineNr">182 </span><span class="subxComment"># helper: create a nested allocation descriptor (useful for tests)</span>
<span id="L183" class="LineNr">183 </span><span class="subxFunction">allocate-region</span>: <span class="subxComment"># ad: (addr allocation-descriptor), n: int -> new-ad: (handle allocation-descriptor)</span>
<span id="L184" class="LineNr">184 </span> <span class="subxS1Comment"># . prologue</span>
<span id="L185" class="LineNr">185 </span> 55/push-ebp
<span id="L186" class="LineNr">186 </span> 89/copy 3/mod/direct 5/rm32/ebp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/r32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># copy esp to ebp</span>
<span id="L187" class="LineNr">187 </span> <span class="subxS1Comment"># . save registers</span>
<span id="L188" class="LineNr">188 </span> 51/push-ecx
<span id="L189" class="LineNr">189 </span> <span class="subxComment"># eax = allocate(ad, n)</span>
<span id="L190" class="LineNr">190 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L191" class="LineNr">191 </span> ff 6/subop/push 1/mod/*+disp8 5/rm32/ebp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 0xc/disp8 <span class="Normal"> . </span> <span class="subxComment"># push *(ebp+12)</span>
<span id="L192" class="LineNr">192 </span> ff 6/subop/push 1/mod/*+disp8 5/rm32/ebp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/disp8 <span class="Normal"> . </span> <span class="subxComment"># push *(ebp+8)</span>
<span id="L193" class="LineNr">193 </span> <span class="subxS2Comment"># . . call</span>
<span id="L194" class="LineNr">194 </span> e8/call <a href='069allocate.subx.html#L59'>allocate</a>/disp32
<span id="L195" class="LineNr">195 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L196" class="LineNr">196 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to esp</span>
<span id="L197" class="LineNr">197 </span> <span class="subxComment"># if (eax == 0) abort</span>
<span id="L198" class="LineNr">198 </span> 3d/compare-eax-and 0/imm32
<span id="L199" class="LineNr">199 </span> 74/jump-if-= $allocate-region:abort/disp8
<span id="L200" class="LineNr">200 </span> <span class="subxComment"># earmark 8 bytes at the start for a new allocation descriptor</span>
<span id="L201" class="LineNr">201 </span> <span class="subxS1Comment"># . *eax = eax + 8</span>
<span id="L202" class="LineNr">202 </span> 89/copy 3/mod/direct 1/rm32/ecx <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 0/r32/eax <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># copy eax to ecx</span>
<span id="L203" class="LineNr">203 </span> 81 0/subop/add 3/mod/direct 1/rm32/ecx <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to ecx</span>
<span id="L204" class="LineNr">204 </span> 89/copy 0/mod/indirect 0/rm32/eax <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 1/r32/ecx <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># copy ecx to *eax</span>
<span id="L205" class="LineNr">205 </span> <span class="subxS1Comment"># . *(eax+4) = eax + n</span>
<span id="L206" class="LineNr">206 </span> 89/copy 3/mod/direct 1/rm32/ecx <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 0/r32/eax <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># copy eax to ecx</span>
<span id="L207" class="LineNr">207 </span> 03/add 1/mod/*+disp8 5/rm32/ebp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 1/r32/ecx 0xc/disp8 <span class="Normal"> . </span> <span class="subxComment"># add *(ebp+12) to ecx</span>
<span id="L208" class="LineNr">208 </span> 89/copy 1/mod/*+disp8 0/rm32/eax <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 1/r32/ecx 4/disp8 <span class="Normal"> . </span> <span class="subxComment"># copy ecx to *(eax+4)</span>
<span id="L209" class="LineNr">209 </span> <span class="subxS1Comment"># . restore registers</span>
<span id="L210" class="LineNr">210 </span> 59/pop-to-ecx
<span id="L211" class="LineNr">211 </span> <span class="subxS1Comment"># . epilogue</span>
<span id="L212" class="LineNr">212 </span> 89/copy 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 5/r32/ebp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># copy ebp to esp</span>
<span id="L213" class="LineNr">213 </span> 5d/pop-to-ebp
<span id="L214" class="LineNr">214 </span> c3/return
<span id="L215" class="LineNr">215 </span>
<span id="L216" class="LineNr">216 </span><span class="subxComment"># We could create a more general '$abort' jump target, but then we'd need to do</span>
<span id="L217" class="LineNr">217 </span><span class="subxComment"># a conditional jump followed by loading the error message and an unconditional</span>
<span id="L218" class="LineNr">218 </span><span class="subxComment"># jump. Or we'd need to unconditionally load the error message before a</span>
<span id="L219" class="LineNr">219 </span><span class="subxComment"># conditional jump, even if it's unused the vast majority of the time. This way</span>
<span id="L220" class="LineNr">220 </span><span class="subxComment"># we bloat a potentially cold segment in RAM so we can abort with a single</span>
<span id="L221" class="LineNr">221 </span><span class="subxComment"># instruction.</span>
<span id="L222" class="LineNr">222 </span><span class="Constant">$allocate-region:abort</span>:
<span id="L223" class="LineNr">223 </span> <span class="subxS1Comment"># . _write(2/stderr, error)</span>
<span id="L224" class="LineNr">224 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L225" class="LineNr">225 </span> 68/push <span class="Constant">"allocate-region: failed to allocate\n"</span>/imm32
<span id="L226" class="LineNr">226 </span> 68/push 2/imm32/stderr
<span id="L227" class="LineNr">227 </span> <span class="subxS2Comment"># . . call</span>
<span id="L228" class="LineNr">228 </span> e8/call <a href='050_write.subx.html#L14'>_write</a>/disp32
<span id="L229" class="LineNr">229 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L230" class="LineNr">230 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to esp</span>
<span id="L231" class="LineNr">231 </span> <span class="subxS1Comment"># . syscall(exit, 1)</span>
<span id="L232" class="LineNr">232 </span> bb/copy-to-ebx 1/imm32
<span id="L233" class="LineNr">233 </span> b8/copy-to-eax 1/imm32/exit
<span id="L234" class="LineNr">234 </span> cd/syscall 0x80/imm8
<span id="L235" class="LineNr">235 </span> <span class="subxComment"># never gets here</span>
<span id="L236" class="LineNr">236 </span>
<span id="L237" class="LineNr">237 </span><span class="subxComment"># Claim the next 'n+4' bytes of memory and initialize the first 4 to n.</span>
<span id="L238" class="LineNr">238 </span><span class="subxComment"># Abort if there isn't enough memory in 'ad'.</span>
<span id="L239" class="LineNr">239 </span><span class="subxFunction">allocate-array</span>: <span class="subxComment"># ad: (addr allocation-descriptor), n: int -> result/eax: (addr _)</span>
<span id="L240" class="LineNr">240 </span> <span class="subxS1Comment"># . prologue</span>
<span id="L241" class="LineNr">241 </span> 55/push-ebp
<span id="L242" class="LineNr">242 </span> 89/copy 3/mod/direct 5/rm32/ebp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/r32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># copy esp to ebp</span>
<span id="L243" class="LineNr">243 </span> <span class="subxS1Comment"># . save registers</span>
<span id="L244" class="LineNr">244 </span> 51/push-ecx
<span id="L245" class="LineNr">245 </span> 52/push-edx
<span id="L246" class="LineNr">246 </span> <span class="subxComment"># ecx = n</span>
<span id="L247" class="LineNr">247 </span> 8b/copy 1/mod/*+disp8 5/rm32/ebp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 1/r32/ecx 0xc/disp8 <span class="Normal"> . </span> <span class="subxComment"># copy *(ebp+12) to ecx</span>
<span id="L248" class="LineNr">248 </span> <span class="subxComment"># var size/edx: int = n+4</span>
<span id="L249" class="LineNr">249 </span> 8d/copy-address 1/mod/*+disp8 1/rm32/ecx <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 2/r32/edx 4/disp8 <span class="Normal"> . </span> <span class="subxComment"># copy ecx+4 to edx</span>
<span id="L250" class="LineNr">250 </span> <span class="subxComment"># result = allocate(ad, size)</span>
<span id="L251" class="LineNr">251 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L252" class="LineNr">252 </span> 52/push-edx
<span id="L253" class="LineNr">253 </span> ff 6/subop/push 1/mod/*+disp8 5/rm32/ebp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/disp8 <span class="Normal"> . </span> <span class="subxComment"># push *(ebp+8)</span>
<span id="L254" class="LineNr">254 </span> <span class="subxS2Comment"># . . call</span>
<span id="L255" class="LineNr">255 </span> e8/call <a href='069allocate.subx.html#L59'>allocate</a>/disp32
<span id="L256" class="LineNr">256 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L257" class="LineNr">257 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to esp</span>
<span id="L258" class="LineNr">258 </span> <span class="subxComment"># *result = n</span>
<span id="L259" class="LineNr">259 </span> 89/copy 0/mod/indirect 0/rm32/eax <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 1/r32/ecx <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># copy ecx to *eax</span>
<span id="L260" class="LineNr">260 </span><span class="Constant">$allocate-array:end</span>:
<span id="L261" class="LineNr">261 </span> <span class="subxS1Comment"># . restore registers</span>
<span id="L262" class="LineNr">262 </span> 5a/pop-to-edx
<span id="L263" class="LineNr">263 </span> 59/pop-to-ecx
<span id="L264" class="LineNr">264 </span> <span class="subxS1Comment"># . epilogue</span>
<span id="L265" class="LineNr">265 </span> 89/copy 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 5/r32/ebp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># copy ebp to esp</span>
<span id="L266" class="LineNr">266 </span> 5d/pop-to-ebp
<span id="L267" class="LineNr">267 </span> c3/return
<span id="L268" class="LineNr">268 </span>
<span id="L269" class="LineNr">269 </span><span class="subxS2Comment"># . . vim:nowrap:textwidth=0</span>
</pre>
</body>
</html>
<!-- vim: set foldmethod=manual : -->
|