Text file src/runtime/sys_linux_ppc64x.s
1 // Copyright 2014 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
4
5 // +build linux
6 // +build ppc64 ppc64le
7
8 //
9 // System calls and other sys.stuff for ppc64, Linux
10 //
11
12 #include "go_asm.h"
13 #include "go_tls.h"
14 #include "textflag.h"
15 #include "asm_ppc64x.h"
16
17 #define SYS_exit 1
18 #define SYS_read 3
19 #define SYS_write 4
20 #define SYS_open 5
21 #define SYS_close 6
22 #define SYS_getpid 20
23 #define SYS_kill 37
24 #define SYS_brk 45
25 #define SYS_fcntl 55
26 #define SYS_mmap 90
27 #define SYS_munmap 91
28 #define SYS_setitimer 104
29 #define SYS_clone 120
30 #define SYS_sched_yield 158
31 #define SYS_nanosleep 162
32 #define SYS_rt_sigreturn 172
33 #define SYS_rt_sigaction 173
34 #define SYS_rt_sigprocmask 174
35 #define SYS_sigaltstack 185
36 #define SYS_madvise 205
37 #define SYS_mincore 206
38 #define SYS_gettid 207
39 #define SYS_futex 221
40 #define SYS_sched_getaffinity 223
41 #define SYS_exit_group 234
42 #define SYS_epoll_create 236
43 #define SYS_epoll_ctl 237
44 #define SYS_epoll_wait 238
45 #define SYS_clock_gettime 246
46 #define SYS_tgkill 250
47 #define SYS_epoll_create1 315
48
49 TEXT runtime·exit(SB),NOSPLIT|NOFRAME,$0-4
50 MOVW code+0(FP), R3
51 SYSCALL $SYS_exit_group
52 RET
53
54 // func exitThread(wait *uint32)
55 TEXT runtime·exitThread(SB),NOSPLIT|NOFRAME,$0-8
56 MOVD wait+0(FP), R1
57 // We're done using the stack.
58 MOVW $0, R2
59 SYNC
60 MOVW R2, (R1)
61 MOVW $0, R3 // exit code
62 SYSCALL $SYS_exit
63 JMP 0(PC)
64
65 TEXT runtime·open(SB),NOSPLIT|NOFRAME,$0-20
66 MOVD name+0(FP), R3
67 MOVW mode+8(FP), R4
68 MOVW perm+12(FP), R5
69 SYSCALL $SYS_open
70 BVC 2(PC)
71 MOVW $-1, R3
72 MOVW R3, ret+16(FP)
73 RET
74
75 TEXT runtime·closefd(SB),NOSPLIT|NOFRAME,$0-12
76 MOVW fd+0(FP), R3
77 SYSCALL $SYS_close
78 BVC 2(PC)
79 MOVW $-1, R3
80 MOVW R3, ret+8(FP)
81 RET
82
83 TEXT runtime·write(SB),NOSPLIT|NOFRAME,$0-28
84 MOVD fd+0(FP), R3
85 MOVD p+8(FP), R4
86 MOVW n+16(FP), R5
87 SYSCALL $SYS_write
88 BVC 2(PC)
89 MOVW $-1, R3
90 MOVW R3, ret+24(FP)
91 RET
92
93 TEXT runtime·read(SB),NOSPLIT|NOFRAME,$0-28
94 MOVW fd+0(FP), R3
95 MOVD p+8(FP), R4
96 MOVW n+16(FP), R5
97 SYSCALL $SYS_read
98 BVC 2(PC)
99 MOVW $-1, R3
100 MOVW R3, ret+24(FP)
101 RET
102
103 TEXT runtime·usleep(SB),NOSPLIT,$16-4
104 MOVW usec+0(FP), R3
105 MOVD R3, R5
106 MOVW $1000000, R4
107 DIVD R4, R3
108 MOVD R3, 8(R1)
109 MOVW $1000, R4
110 MULLD R3, R4
111 SUB R4, R5
112 MOVD R5, 16(R1)
113
114 // nanosleep(&ts, 0)
115 ADD $8, R1, R3
116 MOVW $0, R4
117 SYSCALL $SYS_nanosleep
118 RET
119
120 TEXT runtime·gettid(SB),NOSPLIT,$0-4
121 SYSCALL $SYS_gettid
122 MOVW R3, ret+0(FP)
123 RET
124
125 TEXT runtime·raise(SB),NOSPLIT|NOFRAME,$0
126 SYSCALL $SYS_getpid
127 MOVW R3, R14
128 SYSCALL $SYS_gettid
129 MOVW R3, R4 // arg 2 tid
130 MOVW R14, R3 // arg 1 pid
131 MOVW sig+0(FP), R5 // arg 3
132 SYSCALL $SYS_tgkill
133 RET
134
135 TEXT runtime·raiseproc(SB),NOSPLIT|NOFRAME,$0
136 SYSCALL $SYS_getpid
137 MOVW R3, R3 // arg 1 pid
138 MOVW sig+0(FP), R4 // arg 2
139 SYSCALL $SYS_kill
140 RET
141
142 TEXT runtime·setitimer(SB),NOSPLIT|NOFRAME,$0-24
143 MOVW mode+0(FP), R3
144 MOVD new+8(FP), R4
145 MOVD old+16(FP), R5
146 SYSCALL $SYS_setitimer
147 RET
148
149 TEXT runtime·mincore(SB),NOSPLIT|NOFRAME,$0-28
150 MOVD addr+0(FP), R3
151 MOVD n+8(FP), R4
152 MOVD dst+16(FP), R5
153 SYSCALL $SYS_mincore
154 NEG R3 // caller expects negative errno
155 MOVW R3, ret+24(FP)
156 RET
157
158 // func walltime() (sec int64, nsec int32)
159 TEXT runtime·walltime(SB),NOSPLIT,$16
160 MOVD R1, R15 // R15 is unchanged by C code
161 MOVD g_m(g), R21 // R21 = m
162
163 MOVD $0, R3 // CLOCK_REALTIME
164
165 MOVD runtime·vdsoClockgettimeSym(SB), R12 // Check for VDSO availability
166 CMP R12, R0
167 BEQ fallback
168
169 // Set vdsoPC and vdsoSP for SIGPROF traceback.
170 MOVD LR, R14
171 MOVD R14, m_vdsoPC(R21)
172 MOVD R15, m_vdsoSP(R21)
173
174 MOVD m_curg(R21), R6
175 CMP g, R6
176 BNE noswitch
177
178 MOVD m_g0(R21), R7
179 MOVD (g_sched+gobuf_sp)(R7), R1 // Set SP to g0 stack
180
181 noswitch:
182 SUB $16, R1 // Space for results
183 RLDICR $0, R1, $59, R1 // Align for C code
184 MOVD R12, CTR
185 MOVD R1, R4
186 BL (CTR) // Call from VDSO
187 MOVD $0, R0 // Restore R0
188 MOVD R0, m_vdsoSP(R21) // Clear vdsoSP
189 MOVD 0(R1), R3 // sec
190 MOVD 8(R1), R5 // nsec
191 MOVD R15, R1 // Restore SP
192
193 finish:
194 MOVD R3, sec+0(FP)
195 MOVW R5, nsec+8(FP)
196 RET
197
198 // Syscall fallback
199 fallback:
200 ADD $32, R1, R4
201 SYSCALL $SYS_clock_gettime
202 MOVD 32(R1), R3
203 MOVD 40(R1), R5
204 JMP finish
205
206 TEXT runtime·nanotime(SB),NOSPLIT,$16
207 MOVD $1, R3 // CLOCK_MONOTONIC
208
209 MOVD R1, R15 // R15 is unchanged by C code
210 MOVD g_m(g), R21 // R21 = m
211
212 MOVD runtime·vdsoClockgettimeSym(SB), R12 // Check for VDSO availability
213 CMP R12, R0
214 BEQ fallback
215
216 // Set vdsoPC and vdsoSP for SIGPROF traceback.
217 MOVD LR, R14 // R14 is unchanged by C code
218 MOVD R14, m_vdsoPC(R21)
219 MOVD R15, m_vdsoSP(R21)
220
221 MOVD m_curg(R21), R6
222 CMP g, R6
223 BNE noswitch
224
225 MOVD m_g0(R21), R7
226 MOVD (g_sched+gobuf_sp)(R7), R1 // Set SP to g0 stack
227
228 noswitch:
229 SUB $16, R1 // Space for results
230 RLDICR $0, R1, $59, R1 // Align for C code
231 MOVD R12, CTR
232 MOVD R1, R4
233 BL (CTR) // Call from VDSO
234 MOVD $0, R0 // Restore R0
235 MOVD $0, m_vdsoSP(R21) // Clear vdsoSP
236 MOVD 0(R1), R3 // sec
237 MOVD 8(R1), R5 // nsec
238 MOVD R15, R1 // Restore SP
239
240 finish:
241 // sec is in R3, nsec in R5
242 // return nsec in R3
243 MOVD $1000000000, R4
244 MULLD R4, R3
245 ADD R5, R3
246 MOVD R3, ret+0(FP)
247 RET
248
249 // Syscall fallback
250 fallback:
251 ADD $32, R1, R4
252 SYSCALL $SYS_clock_gettime
253 MOVD 32(R1), R3
254 MOVD 48(R1), R5
255 JMP finish
256
257 TEXT runtime·rtsigprocmask(SB),NOSPLIT|NOFRAME,$0-28
258 MOVW how+0(FP), R3
259 MOVD new+8(FP), R4
260 MOVD old+16(FP), R5
261 MOVW size+24(FP), R6
262 SYSCALL $SYS_rt_sigprocmask
263 BVC 2(PC)
264 MOVD R0, 0xf0(R0) // crash
265 RET
266
267 TEXT runtime·rt_sigaction(SB),NOSPLIT|NOFRAME,$0-36
268 MOVD sig+0(FP), R3
269 MOVD new+8(FP), R4
270 MOVD old+16(FP), R5
271 MOVD size+24(FP), R6
272 SYSCALL $SYS_rt_sigaction
273 BVC 2(PC)
274 NEG R3 // caller expects negative errno
275 MOVW R3, ret+32(FP)
276 RET
277
278 TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
279 MOVW sig+8(FP), R3
280 MOVD info+16(FP), R4
281 MOVD ctx+24(FP), R5
282 MOVD fn+0(FP), R12
283 MOVD R12, CTR
284 BL (CTR)
285 MOVD 24(R1), R2
286 RET
287
288 TEXT runtime·sigreturn(SB),NOSPLIT,$0-0
289 RET
290
291 #ifdef GOARCH_ppc64le
292 // ppc64le doesn't need function descriptors
293 TEXT runtime·sigtramp(SB),NOSPLIT,$64
294 #else
295 // function descriptor for the real sigtramp
296 TEXT runtime·sigtramp(SB),NOSPLIT|NOFRAME,$0
297 DWORD $sigtramp<>(SB)
298 DWORD $0
299 DWORD $0
300 TEXT sigtramp<>(SB),NOSPLIT,$64
301 #endif
302 // initialize essential registers (just in case)
303 BL runtime·reginit(SB)
304
305 // this might be called in external code context,
306 // where g is not set.
307 MOVBZ runtime·iscgo(SB), R6
308 CMP R6, $0
309 BEQ 2(PC)
310 BL runtime·load_g(SB)
311
312 MOVW R3, FIXED_FRAME+0(R1)
313 MOVD R4, FIXED_FRAME+8(R1)
314 MOVD R5, FIXED_FRAME+16(R1)
315 MOVD $runtime·sigtrampgo(SB), R12
316 MOVD R12, CTR
317 BL (CTR)
318 MOVD 24(R1), R2
319 RET
320
321 #ifdef GOARCH_ppc64le
322 // ppc64le doesn't need function descriptors
323 TEXT runtime·cgoSigtramp(SB),NOSPLIT|NOFRAME,$0
324 // The stack unwinder, presumably written in C, may not be able to
325 // handle Go frame correctly. So, this function is NOFRAME, and we
326 // save/restore LR manually.
327 MOVD LR, R10
328
329 // We're coming from C code, initialize essential registers.
330 CALL runtime·reginit(SB)
331
332 // If no traceback function, do usual sigtramp.
333 MOVD runtime·cgoTraceback(SB), R6
334 CMP $0, R6
335 BEQ sigtramp
336
337 // If no traceback support function, which means that
338 // runtime/cgo was not linked in, do usual sigtramp.
339 MOVD _cgo_callers(SB), R6
340 CMP $0, R6
341 BEQ sigtramp
342
343 // Set up g register.
344 CALL runtime·load_g(SB)
345
346 // Figure out if we are currently in a cgo call.
347 // If not, just do usual sigtramp.
348 CMP $0, g
349 BEQ sigtrampnog // g == nil
350 MOVD g_m(g), R6
351 CMP $0, R6
352 BEQ sigtramp // g.m == nil
353 MOVW m_ncgo(R6), R7
354 CMPW $0, R7
355 BEQ sigtramp // g.m.ncgo = 0
356 MOVD m_curg(R6), R7
357 CMP $0, R7
358 BEQ sigtramp // g.m.curg == nil
359 MOVD g_syscallsp(R7), R7
360 CMP $0, R7
361 BEQ sigtramp // g.m.curg.syscallsp == 0
362 MOVD m_cgoCallers(R6), R7 // R7 is the fifth arg in C calling convention.
363 CMP $0, R7
364 BEQ sigtramp // g.m.cgoCallers == nil
365 MOVW m_cgoCallersUse(R6), R8
366 CMPW $0, R8
367 BNE sigtramp // g.m.cgoCallersUse != 0
368
369 // Jump to a function in runtime/cgo.
370 // That function, written in C, will call the user's traceback
371 // function with proper unwind info, and will then call back here.
372 // The first three arguments, and the fifth, are already in registers.
373 // Set the two remaining arguments now.
374 MOVD runtime·cgoTraceback(SB), R6
375 MOVD $runtime·sigtramp(SB), R8
376 MOVD _cgo_callers(SB), R12
377 MOVD R12, CTR
378 MOVD R10, LR // restore LR
379 JMP (CTR)
380
381 sigtramp:
382 MOVD R10, LR // restore LR
383 JMP runtime·sigtramp(SB)
384
385 sigtrampnog:
386 // Signal arrived on a non-Go thread. If this is SIGPROF, get a
387 // stack trace.
388 CMPW R3, $27 // 27 == SIGPROF
389 BNE sigtramp
390
391 // Lock sigprofCallersUse (cas from 0 to 1).
392 MOVW $1, R7
393 MOVD $runtime·sigprofCallersUse(SB), R8
394 SYNC
395 LWAR (R8), R6
396 CMPW $0, R6
397 BNE sigtramp
398 STWCCC R7, (R8)
399 BNE -4(PC)
400 ISYNC
401
402 // Jump to the traceback function in runtime/cgo.
403 // It will call back to sigprofNonGo, which will ignore the
404 // arguments passed in registers.
405 // First three arguments to traceback function are in registers already.
406 MOVD runtime·cgoTraceback(SB), R6
407 MOVD $runtime·sigprofCallers(SB), R7
408 MOVD $runtime·sigprofNonGoWrapper<>(SB), R8
409 MOVD _cgo_callers(SB), R12
410 MOVD R12, CTR
411 MOVD R10, LR // restore LR
412 JMP (CTR)
413 #else
414 // function descriptor for the real sigtramp
415 TEXT runtime·cgoSigtramp(SB),NOSPLIT|NOFRAME,$0
416 DWORD $cgoSigtramp<>(SB)
417 DWORD $0
418 DWORD $0
419 TEXT cgoSigtramp<>(SB),NOSPLIT,$0
420 JMP sigtramp<>(SB)
421 #endif
422
423 TEXT runtime·sigprofNonGoWrapper<>(SB),NOSPLIT,$0
424 // We're coming from C code, set up essential register, then call sigprofNonGo.
425 CALL runtime·reginit(SB)
426 CALL runtime·sigprofNonGo(SB)
427 RET
428
429 TEXT runtime·mmap(SB),NOSPLIT|NOFRAME,$0
430 MOVD addr+0(FP), R3
431 MOVD n+8(FP), R4
432 MOVW prot+16(FP), R5
433 MOVW flags+20(FP), R6
434 MOVW fd+24(FP), R7
435 MOVW off+28(FP), R8
436
437 SYSCALL $SYS_mmap
438 BVC ok
439 MOVD $0, p+32(FP)
440 MOVD R3, err+40(FP)
441 RET
442 ok:
443 MOVD R3, p+32(FP)
444 MOVD $0, err+40(FP)
445 RET
446
447 TEXT runtime·munmap(SB),NOSPLIT|NOFRAME,$0
448 MOVD addr+0(FP), R3
449 MOVD n+8(FP), R4
450 SYSCALL $SYS_munmap
451 BVC 2(PC)
452 MOVD R0, 0xf0(R0)
453 RET
454
455 TEXT runtime·madvise(SB),NOSPLIT|NOFRAME,$0
456 MOVD addr+0(FP), R3
457 MOVD n+8(FP), R4
458 MOVW flags+16(FP), R5
459 SYSCALL $SYS_madvise
460 MOVW R3, ret+24(FP)
461 RET
462
463 // int64 futex(int32 *uaddr, int32 op, int32 val,
464 // struct timespec *timeout, int32 *uaddr2, int32 val2);
465 TEXT runtime·futex(SB),NOSPLIT|NOFRAME,$0
466 MOVD addr+0(FP), R3
467 MOVW op+8(FP), R4
468 MOVW val+12(FP), R5
469 MOVD ts+16(FP), R6
470 MOVD addr2+24(FP), R7
471 MOVW val3+32(FP), R8
472 SYSCALL $SYS_futex
473 BVC 2(PC)
474 NEG R3 // caller expects negative errno
475 MOVW R3, ret+40(FP)
476 RET
477
478 // int64 clone(int32 flags, void *stk, M *mp, G *gp, void (*fn)(void));
479 TEXT runtime·clone(SB),NOSPLIT|NOFRAME,$0
480 MOVW flags+0(FP), R3
481 MOVD stk+8(FP), R4
482
483 // Copy mp, gp, fn off parent stack for use by child.
484 // Careful: Linux system call clobbers ???.
485 MOVD mp+16(FP), R7
486 MOVD gp+24(FP), R8
487 MOVD fn+32(FP), R12
488
489 MOVD R7, -8(R4)
490 MOVD R8, -16(R4)
491 MOVD R12, -24(R4)
492 MOVD $1234, R7
493 MOVD R7, -32(R4)
494
495 SYSCALL $SYS_clone
496 BVC 2(PC)
497 NEG R3 // caller expects negative errno
498
499 // In parent, return.
500 CMP R3, $0
501 BEQ 3(PC)
502 MOVW R3, ret+40(FP)
503 RET
504
505 // In child, on new stack.
506 // initialize essential registers
507 BL runtime·reginit(SB)
508 MOVD -32(R1), R7
509 CMP R7, $1234
510 BEQ 2(PC)
511 MOVD R0, 0(R0)
512
513 // Initialize m->procid to Linux tid
514 SYSCALL $SYS_gettid
515
516 MOVD -24(R1), R12 // fn
517 MOVD -16(R1), R8 // g
518 MOVD -8(R1), R7 // m
519
520 CMP R7, $0
521 BEQ nog
522 CMP R8, $0
523 BEQ nog
524
525 MOVD R3, m_procid(R7)
526
527 // TODO: setup TLS.
528
529 // In child, set up new stack
530 MOVD R7, g_m(R8)
531 MOVD R8, g
532 //CALL runtime·stackcheck(SB)
533
534 nog:
535 // Call fn
536 MOVD R12, CTR
537 BL (CTR)
538
539 // It shouldn't return. If it does, exit that thread.
540 MOVW $111, R3
541 SYSCALL $SYS_exit
542 BR -2(PC) // keep exiting
543
544 TEXT runtime·sigaltstack(SB),NOSPLIT|NOFRAME,$0
545 MOVD new+0(FP), R3
546 MOVD old+8(FP), R4
547 SYSCALL $SYS_sigaltstack
548 BVC 2(PC)
549 MOVD R0, 0xf0(R0) // crash
550 RET
551
552 TEXT runtime·osyield(SB),NOSPLIT|NOFRAME,$0
553 SYSCALL $SYS_sched_yield
554 RET
555
556 TEXT runtime·sched_getaffinity(SB),NOSPLIT|NOFRAME,$0
557 MOVD pid+0(FP), R3
558 MOVD len+8(FP), R4
559 MOVD buf+16(FP), R5
560 SYSCALL $SYS_sched_getaffinity
561 BVC 2(PC)
562 NEG R3 // caller expects negative errno
563 MOVW R3, ret+24(FP)
564 RET
565
566 // int32 runtime·epollcreate(int32 size);
567 TEXT runtime·epollcreate(SB),NOSPLIT|NOFRAME,$0
568 MOVW size+0(FP), R3
569 SYSCALL $SYS_epoll_create
570 BVC 2(PC)
571 NEG R3 // caller expects negative errno
572 MOVW R3, ret+8(FP)
573 RET
574
575 // int32 runtime·epollcreate1(int32 flags);
576 TEXT runtime·epollcreate1(SB),NOSPLIT|NOFRAME,$0
577 MOVW flags+0(FP), R3
578 SYSCALL $SYS_epoll_create1
579 BVC 2(PC)
580 NEG R3 // caller expects negative errno
581 MOVW R3, ret+8(FP)
582 RET
583
584 // func epollctl(epfd, op, fd int32, ev *epollEvent) int
585 TEXT runtime·epollctl(SB),NOSPLIT|NOFRAME,$0
586 MOVW epfd+0(FP), R3
587 MOVW op+4(FP), R4
588 MOVW fd+8(FP), R5
589 MOVD ev+16(FP), R6
590 SYSCALL $SYS_epoll_ctl
591 NEG R3 // caller expects negative errno
592 MOVW R3, ret+24(FP)
593 RET
594
595 // int32 runtime·epollwait(int32 epfd, EpollEvent *ev, int32 nev, int32 timeout);
596 TEXT runtime·epollwait(SB),NOSPLIT|NOFRAME,$0
597 MOVW epfd+0(FP), R3
598 MOVD ev+8(FP), R4
599 MOVW nev+16(FP), R5
600 MOVW timeout+20(FP), R6
601 SYSCALL $SYS_epoll_wait
602 BVC 2(PC)
603 NEG R3 // caller expects negative errno
604 MOVW R3, ret+24(FP)
605 RET
606
607 // void runtime·closeonexec(int32 fd);
608 TEXT runtime·closeonexec(SB),NOSPLIT|NOFRAME,$0
609 MOVW fd+0(FP), R3 // fd
610 MOVD $2, R4 // F_SETFD
611 MOVD $1, R5 // FD_CLOEXEC
612 SYSCALL $SYS_fcntl
613 RET
614
615 // func sbrk0() uintptr
616 TEXT runtime·sbrk0(SB),NOSPLIT|NOFRAME,$0
617 // Implemented as brk(NULL).
618 MOVD $0, R3
619 SYSCALL $SYS_brk
620 MOVD R3, ret+0(FP)
621 RET
622
623 TEXT runtime·access(SB),$0-20
624 MOVD R0, 0(R0) // unimplemented, only needed for android; declared in stubs_linux.go
625 MOVW R0, ret+16(FP) // for vet
626 RET
627
628 TEXT runtime·connect(SB),$0-28
629 MOVD R0, 0(R0) // unimplemented, only needed for android; declared in stubs_linux.go
630 MOVW R0, ret+24(FP) // for vet
631 RET
632
633 TEXT runtime·socket(SB),$0-20
634 MOVD R0, 0(R0) // unimplemented, only needed for android; declared in stubs_linux.go
635 MOVW R0, ret+16(FP) // for vet
636 RET
View as plain text