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
335
|
/***********************************************************************/
/* */
/* Objective Caml */
/* */
/* Xavier Leroy, projet Cristal, INRIA Rocquencourt */
/* */
/* Copyright 2003 Institut National de Recherche en Informatique et */
/* en Automatique. All rights reserved. This file is distributed */
/* under the terms of the GNU Library General Public License, with */
/* the special exception on linking described in file ../LICENSE. */
/* */
/***********************************************************************/
/* $Id$ */
/* Asm part of the runtime system, AMD64 processor */
/* Must be preprocessed by cpp */
#define FUNCTION_ALIGN 4
#define FUNCTION(name) \
.globl name; \
.type name,@function; \
.align FUNCTION_ALIGN; \
name:
.text
/* Allocation */
FUNCTION(caml_call_gc)
/* Record lowest stack address and return address */
movq 0(%rsp), %rax
movq %rax, caml_last_return_address(%rip)
leaq 8(%rsp), %rax
movq %rax, caml_bottom_of_stack(%rip)
/* Save young_ptr, caml_exception_pointer */
movq %r15, young_ptr(%rip)
movq %r14, caml_exception_pointer(%rip)
/* Build array of registers, save it into caml_gc_regs */
.L105:
pushq %r13
pushq %r12
pushq %rbp
pushq %r11
pushq %r10
pushq %r9
pushq %r8
pushq %rcx
pushq %rdx
pushq %rsi
pushq %rdi
pushq %rbx
pushq %rax
movq %rsp, caml_gc_regs
/* Save floating-point registers */
subq $(16*8), %rsp
movlpd %xmm0, 0*8(%rsp)
movlpd %xmm1, 1*8(%rsp)
movlpd %xmm2, 2*8(%rsp)
movlpd %xmm3, 3*8(%rsp)
movlpd %xmm4, 4*8(%rsp)
movlpd %xmm5, 5*8(%rsp)
movlpd %xmm6, 6*8(%rsp)
movlpd %xmm7, 7*8(%rsp)
movlpd %xmm8, 8*8(%rsp)
movlpd %xmm9, 9*8(%rsp)
movlpd %xmm10, 10*8(%rsp)
movlpd %xmm11, 11*8(%rsp)
movlpd %xmm12, 12*8(%rsp)
movlpd %xmm13, 13*8(%rsp)
movlpd %xmm14, 14*8(%rsp)
movlpd %xmm15, 15*8(%rsp)
/* Call the garbage collector */
call garbage_collection
/* Restore all regs used by the code generator */
movlpd 0*8(%rsp), %xmm0
movlpd 1*8(%rsp), %xmm1
movlpd 2*8(%rsp), %xmm2
movlpd 3*8(%rsp), %xmm3
movlpd 4*8(%rsp), %xmm4
movlpd 5*8(%rsp), %xmm5
movlpd 6*8(%rsp), %xmm6
movlpd 7*8(%rsp), %xmm7
movlpd 8*8(%rsp), %xmm8
movlpd 9*8(%rsp), %xmm9
movlpd 10*8(%rsp), %xmm10
movlpd 11*8(%rsp), %xmm11
movlpd 12*8(%rsp), %xmm12
movlpd 13*8(%rsp), %xmm13
movlpd 14*8(%rsp), %xmm14
movlpd 15*8(%rsp), %xmm15
addq $(16*8), %rsp
popq %rax
popq %rbx
popq %rdi
popq %rsi
popq %rdx
popq %rcx
popq %r8
popq %r9
popq %r10
popq %r11
popq %rbp
popq %r12
popq %r13
/* Restore young_ptr, caml_exception_pointer */
movq young_ptr(%rip), %r15
movq caml_exception_pointer(%rip), %r14
/* Return to caller */
ret
FUNCTION(caml_alloc1)
subq $16, %r15
cmpq young_limit(%rip), %r15
jb .L100
ret
.L100:
movq 0(%rsp), %rax
movq %rax, caml_last_return_address(%rip)
leaq 8(%rsp), %rax
movq %rax, caml_bottom_of_stack(%rip)
subq $8, %rsp
call .L105
addq $8, %rsp
jmp caml_alloc1
FUNCTION(caml_alloc2)
subq $24, %r15
cmpq young_limit(%rip), %r15
jb .L101
ret
.L101:
movq 0(%rsp), %rax
movq %rax, caml_last_return_address(%rip)
leaq 8(%rsp), %rax
movq %rax, caml_bottom_of_stack(%rip)
subq $8, %rsp
call .L105
addq $8, %rsp
jmp caml_alloc2
FUNCTION(caml_alloc3)
subq $32, %r15
cmpq young_limit(%rip), %r15
jb .L102
ret
.L102:
movq 0(%rsp), %rax
movq %rax, caml_last_return_address(%rip)
leaq 8(%rsp), %rax
movq %rax, caml_bottom_of_stack(%rip)
subq $8, %rsp
call .L105
addq $8, %rsp
jmp caml_alloc3
FUNCTION(caml_alloc)
subq %rax, %r15
cmpq young_limit(%rip), %r15
jb .L103
ret
.L103:
pushq %rax /* save desired size */
movq 8(%rsp), %rax
movq %rax, caml_last_return_address(%rip)
leaq 16(%rsp), %rax
movq %rax, caml_bottom_of_stack(%rip)
call .L105
popq %rax /* recover desired size */
jmp caml_alloc
/* Call a C function from Caml */
FUNCTION(caml_c_call)
/* Record lowest stack address and return address */
popq %r12
movq %r12, caml_last_return_address(%rip)
movq %rsp, caml_bottom_of_stack(%rip)
/* Make the exception handler and alloc ptr available to the C code */
movq %r15, young_ptr(%rip)
movq %r14, caml_exception_pointer(%rip)
/* Call the function (address in %rax) */
call *%rax
/* Reload alloc ptr */
movq young_ptr(%rip), %r15
/* Return to caller */
pushq %r12
ret
/* Start the Caml program */
FUNCTION(caml_start_program)
/* Save callee-save registers */
pushq %rbx
pushq %rbp
pushq %r12
pushq %r13
pushq %r14
pushq %r15
subq $8, %rsp /* stack 16-aligned */
/* Initial entry point is caml_program */
leaq caml_program(%rip), %r12
/* Common code for caml_start_program and callback* */
.L106:
/* Build a callback link */
subq $8, %rsp /* stack 16-aligned */
pushq caml_gc_regs(%rip)
pushq caml_last_return_address(%rip)
pushq caml_bottom_of_stack(%rip)
/* Setup alloc ptr and exception ptr */
movq young_ptr(%rip), %r15
movq caml_exception_pointer(%rip), %r14
/* Build an exception handler */
lea .L108(%rip), %r13
pushq %r13
pushq %r14
movq %rsp, %r14
/* Call the Caml code */
call *%r12
.L107:
/* Pop the exception handler */
popq %r14
popq %r12 /* dummy register */
.L109:
/* Update alloc ptr and exception ptr */
movq %r15, young_ptr(%rip)
movq %r14, caml_exception_pointer(%rip)
/* Pop the callback link, restoring the global variables */
popq caml_bottom_of_stack(%rip)
popq caml_last_return_address(%rip)
popq caml_gc_regs(%rip)
addq $8, %rsp
/* Restore callee-save registers. */
addq $8, %rsp
popq %r15
popq %r14
popq %r13
popq %r12
popq %rbp
popq %rbx
/* Return to caller. */
ret
.L108:
/* Exception handler*/
/* Mark the bucket as an exception result and return it */
orq $2, %rax
jmp .L109
/* Raise an exception from C */
FUNCTION(raise_caml_exception)
movq %rdi, %rax
movq caml_exception_pointer(%rip), %rsp
popq caml_exception_pointer(%rip)
ret
/* Callback from C to Caml */
FUNCTION(callback_exn)
/* Save callee-save registers */
pushq %rbx
pushq %rbp
pushq %r12
pushq %r13
pushq %r14
pushq %r15
subq $8, %rsp /* stack 16-aligned */
/* Initial loading of arguments */
movq %rdi, %rbx /* closure */
movq %rsi, %rax /* argument */
movq 0(%rbx), %r12 /* code pointer */
jmp .L106
FUNCTION(callback2_exn)
/* Save callee-save registers */
pushq %rbx
pushq %rbp
pushq %r12
pushq %r13
pushq %r14
pushq %r15
subq $8, %rsp /* stack 16-aligned */
/* Initial loading of arguments */
/* closure stays in %rdi */
movq %rsi, %rax /* first argument */
movq %rdx, %rbx /* second argument */
leaq caml_apply2(%rip), %r12 /* code pointer */
jmp .L106
FUNCTION(callback3_exn)
/* Save callee-save registers */
pushq %rbx
pushq %rbp
pushq %r12
pushq %r13
pushq %r14
pushq %r15
subq $8, %rsp /* stack 16-aligned */
/* Initial loading of arguments */
movq %rsi, %rax /* first argument */
movq %rdx, %rbx /* second argument */
movq %rdi, %rsi /* closure */
movq %rcx, %rdi /* third argument */
leaq caml_apply3(%rip), %r12 /* code pointer */
jmp .L106
FUNCTION(caml_array_bound_error)
/* Make the exception handler and alloc ptr available to the C code */
movq %r15, young_ptr(%rip)
movq %r14, caml_exception_pointer(%rip)
jmp array_bound_error
.data
.globl system__frametable
.type system__frametable,@object
.align 8
system__frametable:
.quad 1 /* one descriptor */
.quad .L107 /* return address into callback */
.value -1 /* negative frame size => use callback link */
.value 0 /* no roots here */
.align 8
.section .rodata.cst8,"aM",@progbits,8
.globl caml_negf_mask
.type caml_negf_mask,@object
.align 16
caml_negf_mask:
.quad 0x8000000000000000, 0
.globl caml_absf_mask
.type caml_absf_mask,@object
.align 16
caml_absf_mask:
.quad 0x7FFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF
|
