stubs_moxie.ll raw
1 ; Linker stubs for functions not available in the Moxie runtime.
2 ; These allow linking to succeed. Functions that are actually called
3 ; at runtime will trap; dead-code paths are harmless.
4
5 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
6 target triple = "x86_64-unknown-linux-musleabihf"
7
8 ; --- time ---
9
10 define void @time.Sleep(i64 %ns, ptr %ctx) {
11 ; nanosleep syscall: SYS_nanosleep = 35
12 %ts = alloca [16 x i8], align 8
13 %sec_ptr = bitcast ptr %ts to ptr
14 %nsec_ptr = getelementptr i8, ptr %ts, i64 8
15 %sec = udiv i64 %ns, 1000000000
16 %nsec = urem i64 %ns, 1000000000
17 store i64 %sec, ptr %sec_ptr, align 8
18 store i64 %nsec, ptr %nsec_ptr, align 8
19 call i64 asm sideeffect "syscall", "={rax},{rax},{rdi},{rsi},~{rcx},~{r11},~{memory}"(i64 35, ptr %ts, ptr null)
20 ret void
21 }
22
23 define ptr @time.newTimer(i64 %when, i64 %period, {ptr, ptr} %f, {ptr, ptr} %arg, ptr %c, ptr %ctx) {
24 ret ptr null
25 }
26
27 define i1 @time.stopTimer(ptr %t, ptr %ctx) {
28 ret i1 false
29 }
30
31 define i1 @time.resetTimer(ptr %t, i64 %when, i64 %period, ptr %ctx) {
32 ret i1 false
33 }
34
35 define i1 @time.runtimeIsBubbled(ptr %ctx) {
36 ret i1 false
37 }
38
39 ; --- internal/poll ---
40
41 define void @"internal/poll.runtime_pollServerInit"(ptr %ctx) {
42 ret void
43 }
44
45 define {i64, i32} @"internal/poll.runtime_pollOpen"(i64 %fd, ptr %ctx) {
46 %r = insertvalue {i64, i32} undef, i64 %fd, 0
47 %r2 = insertvalue {i64, i32} %r, i32 0, 1
48 ret {i64, i32} %r2
49 }
50
51 define void @"internal/poll.runtime_pollClose"(i64 %ctx_fd, ptr %ctx) {
52 ret void
53 }
54
55 define i32 @"internal/poll.runtime_pollWait"(i64 %ctx_fd, i32 %mode, ptr %ctx) {
56 ret i32 0
57 }
58
59 define void @"internal/poll.runtime_pollWaitCanceled"(i64 %ctx_fd, i32 %mode, ptr %ctx) {
60 ret void
61 }
62
63 define i32 @"internal/poll.runtime_pollReset"(i64 %ctx_fd, i32 %mode, ptr %ctx) {
64 ret i32 0
65 }
66
67 define void @"internal/poll.runtime_pollSetDeadline"(i64 %ctx_fd, i64 %d, i32 %mode, ptr %ctx) {
68 ret void
69 }
70
71 define void @"internal/poll.runtime_pollUnblock"(i64 %ctx_fd, ptr %ctx) {
72 ret void
73 }
74
75 define void @"internal/poll.runtime_Semacquire"(ptr %addr, ptr %ctx) {
76 ret void
77 }
78
79 define void @"internal/poll.runtime_Semrelease"(ptr %addr, ptr %ctx) {
80 ret void
81 }
82
83 ; --- context ---
84
85 define ptr @context._closedchan(ptr %ctx) {
86 ret ptr null
87 }
88
89 define ptr @context.cancelCtx.Done(ptr %self, ptr %ctx) {
90 ret ptr null
91 }
92
93 define ptr @context.emptyCtx.Done(ptr %self, ptr %ctx) {
94 ret ptr null
95 }
96
97 define ptr @context.withoutCancelCtx.Done(ptr %self, ptr %ctx) {
98 ret ptr null
99 }
100
101 define ptr @context.parentCancelCtx(ptr %parent, ptr %ctx) {
102 ret ptr null
103 }
104
105 ; --- net ---
106
107 define ptr @net.pipeDeadline.wait(ptr %self, ptr %ctx) {
108 ret ptr null
109 }
110
111 ; --- crypto/elliptic nistCurve generic methods ---
112
113 define ptr @"crypto/elliptic.nistCurve.Params"(ptr %self, ptr %ctx) {
114 ret ptr null
115 }
116
117 define {ptr, ptr} @"crypto/elliptic.nistCurve.Add"(ptr %self, ptr %x1, ptr %y1, ptr %x2, ptr %y2, ptr %ctx) {
118 %r = insertvalue {ptr, ptr} undef, ptr null, 0
119 %r2 = insertvalue {ptr, ptr} %r, ptr null, 1
120 ret {ptr, ptr} %r2
121 }
122
123 define i1 @"crypto/elliptic.nistCurve.IsOnCurve"(ptr %self, ptr %x, ptr %y, ptr %ctx) {
124 ret i1 false
125 }
126
127 define {ptr, ptr} @"crypto/elliptic.nistCurve.ScalarBaseMult"(ptr %self, ptr %k_ptr, i64 %k_len, i64 %k_cap, ptr %ctx) {
128 %r = insertvalue {ptr, ptr} undef, ptr null, 0
129 %r2 = insertvalue {ptr, ptr} %r, ptr null, 1
130 ret {ptr, ptr} %r2
131 }
132
133 define {ptr, ptr} @"crypto/elliptic.nistCurve.ScalarMult"(ptr %self, ptr %bx, ptr %by, ptr %k_ptr, i64 %k_len, i64 %k_cap, ptr %ctx) {
134 %r = insertvalue {ptr, ptr} undef, ptr null, 0
135 %r2 = insertvalue {ptr, ptr} %r, ptr null, 1
136 ret {ptr, ptr} %r2
137 }
138
139 ; --- crypto/ecdh nistCurve generic methods ---
140
141 define {ptr, {ptr, ptr}} @"crypto/ecdh.nistCurve.GenerateKey"(ptr %self, ptr %rand, ptr %rand2, ptr %ctx) {
142 %r = insertvalue {ptr, {ptr, ptr}} undef, ptr null, 0
143 %r2 = insertvalue {ptr, {ptr, ptr}} %r, ptr null, 1, 0
144 %r3 = insertvalue {ptr, {ptr, ptr}} %r2, ptr null, 1, 1
145 ret {ptr, {ptr, ptr}} %r3
146 }
147
148 define {ptr, {ptr, ptr}} @"crypto/ecdh.nistCurve.NewPrivateKey"(ptr %self, ptr %key_ptr, i64 %key_len, i64 %key_cap, ptr %ctx) {
149 %r = insertvalue {ptr, {ptr, ptr}} undef, ptr null, 0
150 %r2 = insertvalue {ptr, {ptr, ptr}} %r, ptr null, 1, 0
151 %r3 = insertvalue {ptr, {ptr, ptr}} %r2, ptr null, 1, 1
152 ret {ptr, {ptr, ptr}} %r3
153 }
154
155 define {ptr, {ptr, ptr}} @"crypto/ecdh.nistCurve.NewPublicKey"(ptr %self, ptr %key_ptr, i64 %key_len, i64 %key_cap, ptr %ctx) {
156 %r = insertvalue {ptr, {ptr, ptr}} undef, ptr null, 0
157 %r2 = insertvalue {ptr, {ptr, ptr}} %r, ptr null, 1, 0
158 %r3 = insertvalue {ptr, {ptr, ptr}} %r2, ptr null, 1, 1
159 ret {ptr, {ptr, ptr}} %r3
160 }
161
162 define {ptr, i64, i64} @"crypto/ecdh.nistCurve.String"(ptr %self, ptr %ctx) {
163 %r = insertvalue {ptr, i64, i64} undef, ptr null, 0
164 %r2 = insertvalue {ptr, i64, i64} %r, i64 0, 1
165 %r3 = insertvalue {ptr, i64, i64} %r2, i64 0, 2
166 ret {ptr, i64, i64} %r3
167 }
168
169 ; --- os.runtime_args ---
170
171 @runtime.main_argc = external global i32, align 4
172 @runtime.main_argv = external global ptr, align 8
173 declare noalias nonnull ptr @runtime.alloc(i64, ptr, ptr)
174
175 define {ptr, i64, i64} @"os.runtime_args"() {
176 entry:
177 %argc32 = load i32, ptr @runtime.main_argc, align 4
178 %argc = sext i32 %argc32 to i64
179 %cmp = icmp sle i64 %argc, 0
180 br i1 %cmp, label %empty, label %alloc
181
182 empty:
183 ret {ptr, i64, i64} zeroinitializer
184
185 alloc:
186 ; each string is {ptr, i64, i64} = 24 bytes
187 %sz = mul i64 %argc, 24
188 %arr = call ptr @runtime.alloc(i64 %sz, ptr inttoptr (i64 3 to ptr), ptr undef)
189 %argv = load ptr, ptr @runtime.main_argv, align 8
190 br label %loop
191
192 loop:
193 %i = phi i64 [0, %alloc], [%inext, %done_str]
194 %done = icmp uge i64 %i, %argc
195 br i1 %done, label %ret, label %body
196
197 body:
198 ; argv[i] is a C string pointer
199 %argvp = getelementptr ptr, ptr %argv, i64 %i
200 %cstr = load ptr, ptr %argvp, align 8
201 br label %strlen_loop
202
203 strlen_loop:
204 %slen = phi i64 [0, %body], [%snext, %strlen_cont]
205 %cp = getelementptr i8, ptr %cstr, i64 %slen
206 %ch = load i8, ptr %cp, align 1
207 %isz = icmp eq i8 %ch, 0
208 br i1 %isz, label %done_str, label %strlen_cont
209
210 strlen_cont:
211 %snext = add i64 %slen, 1
212 br label %strlen_loop
213
214 done_str:
215 ; store string {ptr, len, cap} at arr[i]
216 %slot = getelementptr [24 x i8], ptr %arr, i64 %i
217 %pp = getelementptr {ptr, i64, i64}, ptr %slot, i64 0, i32 0
218 store ptr %cstr, ptr %pp, align 8
219 %lp = getelementptr {ptr, i64, i64}, ptr %slot, i64 0, i32 1
220 store i64 %slen, ptr %lp, align 8
221 %cp2 = getelementptr {ptr, i64, i64}, ptr %slot, i64 0, i32 2
222 store i64 %slen, ptr %cp2, align 8
223 %inext = add i64 %i, 1
224 br label %loop
225
226 ret:
227 %r1 = insertvalue {ptr, i64, i64} undef, ptr %arr, 0
228 %r2 = insertvalue {ptr, i64, i64} %r1, i64 %argc, 1
229 %r3 = insertvalue {ptr, i64, i64} %r2, i64 %argc, 2
230 ret {ptr, i64, i64} %r3
231 }
232
233 ; --- slices (generic functions not monomorphized by compiler) ---
234
235 define void @slices.Clone(ptr %ctx) {
236 ret void
237 }
238
239 define void @slices.SortFunc(ptr %ctx) {
240 ret void
241 }
242
243 define void @slices.SortStableFunc(ptr %ctx) {
244 ret void
245 }
246
247 ; --- unsafe (compiler intrinsics that should be resolved at compile time) ---
248
249 define i32 @unsafe.Sizeof({ptr, ptr} %iface, ptr %ctx) {
250 ret i32 0
251 }
252
253 define i32 @unsafe.Offsetof({ptr, ptr} %iface, ptr %ctx) {
254 ret i32 0
255 }
256
257 ; --- syscall ---
258
259 define i32 @syscall.Getpagesize() {
260 ret i32 4096
261 }
262
263 ; --- net ---
264
265 define i64 @net.runtime_rand(ptr %ctx) {
266 %buf = alloca i64, align 8
267 call i64 asm sideeffect "syscall", "={rax},{rax},{rdi},{rsi},{rdx},~{rcx},~{r11},~{memory}"(i64 318, ptr %buf, i64 8, i64 0)
268 %val = load i64, ptr %buf, align 8
269 ret i64 %val
270 }
271
272 ; --- runtime ---
273
274 define i32 @runtime.LastSpawnedParentFd(ptr %ctx) {
275 ret i32 -1
276 }
277
278 ; --- crypto/internal/fips140/ecdh ---
279
280 define void @"crypto/internal/fips140/ecdh.ECDH"(ptr %ctx) {
281 ret void
282 }
283
284 define void @"crypto/internal/fips140/ecdh.GenerateKey"(ptr %ctx) {
285 ret void
286 }
287
288 define void @"crypto/internal/fips140/ecdh.NewPublicKey"(ptr %ctx) {
289 ret void
290 }
291
292 ; --- builtin String() methods for basic types ---
293
294 declare {ptr, i64, i64} @strconv.Itoa(i32, ptr)
295 declare {ptr, i64, i64} @strconv.FormatInt(i64, i32, ptr)
296 declare {ptr, i64, i64} @strconv.FormatUint(i64, i32, ptr)
297 declare {ptr, i64, i64} @strconv.FormatBool(i1, ptr)
298 declare {ptr, i64, i64} @strconv.FormatFloat(double, i8, i32, i32, ptr)
299
300 define {ptr, i64, i64} @"__builtin.bytes.String"({ptr, i64, i64} %self, ptr %ctx) {
301 ret {ptr, i64, i64} %self
302 }
303
304 define {ptr, i64, i64} @"__builtin.bool.String"(i1 %self, ptr %ctx) {
305 %r = call {ptr, i64, i64} @strconv.FormatBool(i1 %self, ptr null)
306 ret {ptr, i64, i64} %r
307 }
308
309 define {ptr, i64, i64} @"__builtin.int8.String"(i8 %self, ptr %ctx) {
310 %ext = sext i8 %self to i32
311 %r = call {ptr, i64, i64} @strconv.Itoa(i32 %ext, ptr null)
312 ret {ptr, i64, i64} %r
313 }
314
315 define {ptr, i64, i64} @"__builtin.int16.String"(i16 %self, ptr %ctx) {
316 %ext = sext i16 %self to i32
317 %r = call {ptr, i64, i64} @strconv.Itoa(i32 %ext, ptr null)
318 ret {ptr, i64, i64} %r
319 }
320
321 define {ptr, i64, i64} @"__builtin.int32.String"(i32 %self, ptr %ctx) {
322 %r = call {ptr, i64, i64} @strconv.Itoa(i32 %self, ptr null)
323 ret {ptr, i64, i64} %r
324 }
325
326 define {ptr, i64, i64} @"__builtin.int64.String"(i64 %self, ptr %ctx) {
327 %r = call {ptr, i64, i64} @strconv.FormatInt(i64 %self, i32 10, ptr null)
328 ret {ptr, i64, i64} %r
329 }
330
331 define {ptr, i64, i64} @"__builtin.uint8.String"(i8 %self, ptr %ctx) {
332 %ext = zext i8 %self to i64
333 %r = call {ptr, i64, i64} @strconv.FormatUint(i64 %ext, i32 10, ptr null)
334 ret {ptr, i64, i64} %r
335 }
336
337 define {ptr, i64, i64} @"__builtin.uint16.String"(i16 %self, ptr %ctx) {
338 %ext = zext i16 %self to i64
339 %r = call {ptr, i64, i64} @strconv.FormatUint(i64 %ext, i32 10, ptr null)
340 ret {ptr, i64, i64} %r
341 }
342
343 define {ptr, i64, i64} @"__builtin.uint32.String"(i32 %self, ptr %ctx) {
344 %ext = zext i32 %self to i64
345 %r = call {ptr, i64, i64} @strconv.FormatUint(i64 %ext, i32 10, ptr null)
346 ret {ptr, i64, i64} %r
347 }
348
349 define {ptr, i64, i64} @"__builtin.uint64.String"(i64 %self, ptr %ctx) {
350 %r = call {ptr, i64, i64} @strconv.FormatUint(i64 %self, i32 10, ptr null)
351 ret {ptr, i64, i64} %r
352 }
353
354 define {ptr, i64, i64} @"__builtin.float32.String"(float %self, ptr %ctx) {
355 %ext = fpext float %self to double
356 %r = call {ptr, i64, i64} @strconv.FormatFloat(double %ext, i8 103, i32 -1, i32 32, ptr null)
357 ret {ptr, i64, i64} %r
358 }
359
360 define {ptr, i64, i64} @"__builtin.float64.String"(double %self, ptr %ctx) {
361 %r = call {ptr, i64, i64} @strconv.FormatFloat(double %self, i8 103, i32 -1, i32 64, ptr null)
362 ret {ptr, i64, i64} %r
363 }
364