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
|
.include "macros.s"
.section .init
.global _start
_start:
jmp _uskel_start
.section .bss
_memory_state:
cell 0 # next free position
cell 0 # region start
cell 0 # region end
.section .text
_uskel_alloc_basic_mem:
mov $0x100000, %r15 # desired size
mov $0x9, %rax # mmap
mov $0, %rdi # addr = NULL
mov %r15, %rsi # len = %rcx
mov $0x3, %rdx # prot = PROT_READ 0x1 | PROT_WRITE 0x2
mov $0x22, %r10 # flags = MAP_PRIVATE 0x2 | MAP_ANONYMOUS 0x20
mov $-1, %r8 # fd = -1
mov $0, %r9 # off = 0
syscall
mov $_memory_state, %rdi
mov %rax, (%rdi)
mov %rax, 0x8(%rdi)
add %r15, %rax
mov %rax, 0x10(%rdi)
retq
_uskel_start:
call _uskel_alloc_basic_mem
mov _memory_state, %rdi
# push a thunk for main
mov %rdi, %r15 # backup main for later
movq $main, 0x00(%rdi)
movq $0, 0x08(%rdi)
add $0x10, %rdi
# save the memory ptr
mov %rdi, _memory_state
mov $0, %rsi # no result for main
mov $0, %rdi # set continuation to exit
enter %r15 # run the program
# Simple values and boxed machine integers
# | ptr | value |
CON_evacuate1:
retq
CON_scavenge1:
add $0x10, %rsi
retq
INT_info_table:
cell CON_evacuate1
cell CON_scavenge1
cell 0
INT_code:
continue
# List
# | ptr | 0 |
# | ptr | 1 | a | b |
LIST_evacuate:
# [] | a : b
retq #TODO
LIST_scavenge:
mov 0x8(%rbp), %rax
shl $1, %rax
add $2, %rax
shl $3, %rax
add %rax, %rsi
retq
LIST_info_table:
cell LIST_evacuate
cell LIST_scavenge
cell 0
LIST_code:
continue
# FUN/PAP combo objects
# | ptr | thunkptr | args | arg[0] | arg[1] | ... | arg[args] |
FUN_evacuate:
retq #TODO
FUN_scavenge:
mov 0x10(%rbp), %rax
add $3, %rax
shl $3, %rax
add %rax, %rsi
retq
# Simple info for n-ary functions
# TODO continue to add as required
fun1_info_table:
cell FUN_evacuate
cell FUN_scavenge
cell 1
fun1_code:
continue
fun2_info_table:
cell FUN_evacuate
cell FUN_scavenge
cell 2
fun2_code:
continue
fun3_info_table:
cell FUN_evacuate
cell FUN_scavenge
cell 3
fun3_code:
continue
# indirection (Q: how to recognize IND and THUNK on return?)
# | ptr | indptr |
IND_evacuate:
retq #TODO
IND_scavenge:
add $0x10,%rsi
retq
IND_info:
cell IND_evacuate
cell IND_scavenge
cell 0
IND_code:
enter 0x8(%rbp)
# THU objects (gc implementation only, actual THUs are defined by functions)
# | ptr | args | arg[0] | arg[1] | ... | arg[args] |
# args wouldn't need to be here but let's keep them for gc simplicity
THU_evacuate:
retq #TODO
THU_scavenge:
mov 0x8(%rbp), %rax
add $2,%rax
shl $3,%rax
add %rax,%rsi
retq
#
# Actual code!
#
.makethunk main
# push a thunk for main_exit
mov _memory_state, %r15
mov %r15, %r14 # backup for later
movq $main_exit, 0x00(%r15)
movq $1, 0x08(%r15)
mov %rdi, 0x10(%r15)
add $0x18, %r15
mov %r15, _memory_state
# continue 123
movq $INT_code, (%rbp)
movq $123, 0x8(%rbp)
mov %rbp, %rsi
enter %r14
.makethunk main_exit
mov 0x8(%rsi), %rdi
mov $0x3c, %rax
syscall # exit %rdi
|
