github.com/miolini/go@v0.0.0-20160405192216-fca68c8cb408/src/runtime/sys_linux_amd64.s (about) 1 // Copyright 2009 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 // 6 // System calls and other sys.stuff for AMD64, Linux 7 // 8 9 #include "go_asm.h" 10 #include "go_tls.h" 11 #include "textflag.h" 12 13 TEXT runtime·exit(SB),NOSPLIT,$0-4 14 MOVL code+0(FP), DI 15 MOVL $231, AX // exitgroup - force all os threads to exit 16 SYSCALL 17 RET 18 19 TEXT runtime·exit1(SB),NOSPLIT,$0-4 20 MOVL code+0(FP), DI 21 MOVL $60, AX // exit - exit the current os thread 22 SYSCALL 23 RET 24 25 TEXT runtime·open(SB),NOSPLIT,$0-20 26 MOVQ name+0(FP), DI 27 MOVL mode+8(FP), SI 28 MOVL perm+12(FP), DX 29 MOVL $2, AX // syscall entry 30 SYSCALL 31 CMPQ AX, $0xfffffffffffff001 32 JLS 2(PC) 33 MOVL $-1, AX 34 MOVL AX, ret+16(FP) 35 RET 36 37 TEXT runtime·closefd(SB),NOSPLIT,$0-12 38 MOVL fd+0(FP), DI 39 MOVL $3, AX // syscall entry 40 SYSCALL 41 CMPQ AX, $0xfffffffffffff001 42 JLS 2(PC) 43 MOVL $-1, AX 44 MOVL AX, ret+8(FP) 45 RET 46 47 TEXT runtime·write(SB),NOSPLIT,$0-28 48 MOVQ fd+0(FP), DI 49 MOVQ p+8(FP), SI 50 MOVL n+16(FP), DX 51 MOVL $1, AX // syscall entry 52 SYSCALL 53 CMPQ AX, $0xfffffffffffff001 54 JLS 2(PC) 55 MOVL $-1, AX 56 MOVL AX, ret+24(FP) 57 RET 58 59 TEXT runtime·read(SB),NOSPLIT,$0-28 60 MOVL fd+0(FP), DI 61 MOVQ p+8(FP), SI 62 MOVL n+16(FP), DX 63 MOVL $0, AX // syscall entry 64 SYSCALL 65 CMPQ AX, $0xfffffffffffff001 66 JLS 2(PC) 67 MOVL $-1, AX 68 MOVL AX, ret+24(FP) 69 RET 70 71 TEXT runtime·getrlimit(SB),NOSPLIT,$0-20 72 MOVL kind+0(FP), DI 73 MOVQ limit+8(FP), SI 74 MOVL $97, AX // syscall entry 75 SYSCALL 76 MOVL AX, ret+16(FP) 77 RET 78 79 TEXT runtime·usleep(SB),NOSPLIT,$16 80 MOVL $0, DX 81 MOVL usec+0(FP), AX 82 MOVL $1000000, CX 83 DIVL CX 84 MOVQ AX, 0(SP) 85 MOVQ DX, 8(SP) 86 87 // select(0, 0, 0, 0, &tv) 88 MOVL $0, DI 89 MOVL $0, SI 90 MOVL $0, DX 91 MOVL $0, R10 92 MOVQ SP, R8 93 MOVL $23, AX 94 SYSCALL 95 RET 96 97 TEXT runtime·gettid(SB),NOSPLIT,$0-4 98 MOVL $186, AX // syscall - gettid 99 SYSCALL 100 MOVL AX, ret+0(FP) 101 RET 102 103 TEXT runtime·raise(SB),NOSPLIT,$0 104 MOVL $186, AX // syscall - gettid 105 SYSCALL 106 MOVL AX, DI // arg 1 tid 107 MOVL sig+0(FP), SI // arg 2 108 MOVL $200, AX // syscall - tkill 109 SYSCALL 110 RET 111 112 TEXT runtime·raiseproc(SB),NOSPLIT,$0 113 MOVL $39, AX // syscall - getpid 114 SYSCALL 115 MOVL AX, DI // arg 1 pid 116 MOVL sig+0(FP), SI // arg 2 117 MOVL $62, AX // syscall - kill 118 SYSCALL 119 RET 120 121 TEXT runtime·setitimer(SB),NOSPLIT,$0-24 122 MOVL mode+0(FP), DI 123 MOVQ new+8(FP), SI 124 MOVQ old+16(FP), DX 125 MOVL $38, AX // syscall entry 126 SYSCALL 127 RET 128 129 TEXT runtime·mincore(SB),NOSPLIT,$0-28 130 MOVQ addr+0(FP), DI 131 MOVQ n+8(FP), SI 132 MOVQ dst+16(FP), DX 133 MOVL $27, AX // syscall entry 134 SYSCALL 135 MOVL AX, ret+24(FP) 136 RET 137 138 // func now() (sec int64, nsec int32) 139 TEXT time·now(SB),NOSPLIT,$16 140 // Be careful. We're calling a function with gcc calling convention here. 141 // We're guaranteed 128 bytes on entry, and we've taken 16, and the 142 // call uses another 8. 143 // That leaves 104 for the gettime code to use. Hope that's enough! 144 MOVQ runtime·__vdso_clock_gettime_sym(SB), AX 145 CMPQ AX, $0 146 JEQ fallback 147 MOVL $0, DI // CLOCK_REALTIME 148 LEAQ 0(SP), SI 149 CALL AX 150 MOVQ 0(SP), AX // sec 151 MOVQ 8(SP), DX // nsec 152 MOVQ AX, sec+0(FP) 153 MOVL DX, nsec+8(FP) 154 RET 155 fallback: 156 LEAQ 0(SP), DI 157 MOVQ $0, SI 158 MOVQ runtime·__vdso_gettimeofday_sym(SB), AX 159 CALL AX 160 MOVQ 0(SP), AX // sec 161 MOVL 8(SP), DX // usec 162 IMULQ $1000, DX 163 MOVQ AX, sec+0(FP) 164 MOVL DX, nsec+8(FP) 165 RET 166 167 TEXT runtime·nanotime(SB),NOSPLIT,$16 168 // Duplicate time.now here to avoid using up precious stack space. 169 // See comment above in time.now. 170 MOVQ runtime·__vdso_clock_gettime_sym(SB), AX 171 CMPQ AX, $0 172 JEQ fallback 173 MOVL $1, DI // CLOCK_MONOTONIC 174 LEAQ 0(SP), SI 175 CALL AX 176 MOVQ 0(SP), AX // sec 177 MOVQ 8(SP), DX // nsec 178 // sec is in AX, nsec in DX 179 // return nsec in AX 180 IMULQ $1000000000, AX 181 ADDQ DX, AX 182 MOVQ AX, ret+0(FP) 183 RET 184 fallback: 185 LEAQ 0(SP), DI 186 MOVQ $0, SI 187 MOVQ runtime·__vdso_gettimeofday_sym(SB), AX 188 CALL AX 189 MOVQ 0(SP), AX // sec 190 MOVL 8(SP), DX // usec 191 IMULQ $1000, DX 192 // sec is in AX, nsec in DX 193 // return nsec in AX 194 IMULQ $1000000000, AX 195 ADDQ DX, AX 196 MOVQ AX, ret+0(FP) 197 RET 198 199 TEXT runtime·rtsigprocmask(SB),NOSPLIT,$0-28 200 MOVL sig+0(FP), DI 201 MOVQ new+8(FP), SI 202 MOVQ old+16(FP), DX 203 MOVL size+24(FP), R10 204 MOVL $14, AX // syscall entry 205 SYSCALL 206 CMPQ AX, $0xfffffffffffff001 207 JLS 2(PC) 208 MOVL $0xf1, 0xf1 // crash 209 RET 210 211 TEXT runtime·rt_sigaction(SB),NOSPLIT,$0-36 212 MOVQ sig+0(FP), DI 213 MOVQ new+8(FP), SI 214 MOVQ old+16(FP), DX 215 MOVQ size+24(FP), R10 216 MOVL $13, AX // syscall entry 217 SYSCALL 218 MOVL AX, ret+32(FP) 219 RET 220 221 TEXT runtime·sigfwd(SB),NOSPLIT,$0-32 222 MOVL sig+8(FP), DI 223 MOVQ info+16(FP), SI 224 MOVQ ctx+24(FP), DX 225 MOVQ fn+0(FP), AX 226 CALL AX 227 RET 228 229 TEXT runtime·sigtramp(SB),NOSPLIT,$24 230 MOVQ DI, 0(SP) // signum 231 MOVQ SI, 8(SP) // info 232 MOVQ DX, 16(SP) // ctx 233 MOVQ $runtime·sigtrampgo(SB), AX 234 CALL AX 235 RET 236 237 // Used instead of sigtramp in programs that use cgo. 238 // Arguments from kernel are in DI, SI, DX. 239 TEXT runtime·cgoSigtramp(SB),NOSPLIT,$0 240 // If no traceback function, do usual sigtramp. 241 MOVQ runtime·cgoTraceback(SB), AX 242 TESTQ AX, AX 243 JZ sigtramp 244 245 // If no traceback support function, which means that 246 // runtime/cgo was not linked in, do usual sigtramp. 247 MOVQ _cgo_callers(SB), AX 248 TESTQ AX, AX 249 JZ sigtramp 250 251 // Figure out if we are currently in a cgo call. 252 // If not, just do usual sigtramp. 253 get_tls(CX) 254 MOVQ g(CX),AX 255 TESTQ AX, AX 256 JZ sigtramp // g == nil 257 MOVQ g_m(AX), AX 258 TESTQ AX, AX 259 JZ sigtramp // g.m == nil 260 MOVL m_ncgo(AX), CX 261 TESTL CX, CX 262 JZ sigtramp // g.m.ncgo == 0 263 MOVQ m_curg(AX), CX 264 TESTQ CX, CX 265 JZ sigtramp // g.m.curg == nil 266 MOVQ g_syscallsp(CX), CX 267 TESTQ CX, CX 268 JZ sigtramp // g.m.curg.syscallsp == 0 269 MOVQ m_cgoCallers(AX), R8 270 TESTQ R8, R8 271 JZ sigtramp // g.m.cgoCallers == nil 272 MOVL m_cgoCallersUse(AX), CX 273 TESTL CX, CX 274 JNZ sigtramp // g.m.cgoCallersUse != 0 275 276 // Jump to a function in runtime/cgo. 277 // That function, written in C, will call the user's traceback 278 // function with proper unwind info, and will then call back here. 279 // The first three arguments are already in registers. 280 // Set the last three arguments now. 281 MOVQ runtime·cgoTraceback(SB), CX 282 MOVQ $runtime·sigtramp(SB), R9 283 MOVQ _cgo_callers(SB), AX 284 JMP AX 285 286 sigtramp: 287 JMP runtime·sigtramp(SB) 288 289 // For cgo unwinding to work, this function must look precisely like 290 // the one in glibc. The glibc source code is: 291 // https://sourceware.org/git/?p=glibc.git;a=blob;f=sysdeps/unix/sysv/linux/x86_64/sigaction.c 292 // The code that cares about the precise instructions used is: 293 // https://gcc.gnu.org/viewcvs/gcc/trunk/libgcc/config/i386/linux-unwind.h?revision=219188&view=markup 294 TEXT runtime·sigreturn(SB),NOSPLIT,$0 295 MOVQ $15, AX // rt_sigreturn 296 SYSCALL 297 INT $3 // not reached 298 299 TEXT runtime·sysMmap(SB),NOSPLIT,$0 300 MOVQ addr+0(FP), DI 301 MOVQ n+8(FP), SI 302 MOVL prot+16(FP), DX 303 MOVL flags+20(FP), R10 304 MOVL fd+24(FP), R8 305 MOVL off+28(FP), R9 306 307 MOVL $9, AX // mmap 308 SYSCALL 309 CMPQ AX, $0xfffffffffffff001 310 JLS 3(PC) 311 NOTQ AX 312 INCQ AX 313 MOVQ AX, ret+32(FP) 314 RET 315 316 // Call the function stored in _cgo_mmap using the GCC calling convention. 317 // This must be called on the system stack. 318 TEXT runtime·callCgoMmap(SB),NOSPLIT,$16 319 MOVQ addr+0(FP), DI 320 MOVQ n+8(FP), SI 321 MOVL prot+16(FP), DX 322 MOVL flags+20(FP), CX 323 MOVL fd+24(FP), R8 324 MOVL off+28(FP), R9 325 MOVQ _cgo_mmap(SB), AX 326 MOVQ SP, BX 327 ANDQ $~15, SP // alignment as per amd64 psABI 328 MOVQ BX, 0(SP) 329 CALL AX 330 MOVQ 0(SP), SP 331 MOVQ AX, ret+32(FP) 332 RET 333 334 TEXT runtime·munmap(SB),NOSPLIT,$0 335 MOVQ addr+0(FP), DI 336 MOVQ n+8(FP), SI 337 MOVQ $11, AX // munmap 338 SYSCALL 339 CMPQ AX, $0xfffffffffffff001 340 JLS 2(PC) 341 MOVL $0xf1, 0xf1 // crash 342 RET 343 344 TEXT runtime·madvise(SB),NOSPLIT,$0 345 MOVQ addr+0(FP), DI 346 MOVQ n+8(FP), SI 347 MOVL flags+16(FP), DX 348 MOVQ $28, AX // madvise 349 SYSCALL 350 // ignore failure - maybe pages are locked 351 RET 352 353 // int64 futex(int32 *uaddr, int32 op, int32 val, 354 // struct timespec *timeout, int32 *uaddr2, int32 val2); 355 TEXT runtime·futex(SB),NOSPLIT,$0 356 MOVQ addr+0(FP), DI 357 MOVL op+8(FP), SI 358 MOVL val+12(FP), DX 359 MOVQ ts+16(FP), R10 360 MOVQ addr2+24(FP), R8 361 MOVL val3+32(FP), R9 362 MOVL $202, AX 363 SYSCALL 364 MOVL AX, ret+40(FP) 365 RET 366 367 // int32 clone(int32 flags, void *stack, M *mp, G *gp, void (*fn)(void)); 368 TEXT runtime·clone(SB),NOSPLIT,$0 369 MOVL flags+0(FP), DI 370 MOVQ stack+8(FP), SI 371 MOVQ $0, DX 372 MOVQ $0, R10 373 374 // Copy mp, gp, fn off parent stack for use by child. 375 // Careful: Linux system call clobbers CX and R11. 376 MOVQ mp+16(FP), R8 377 MOVQ gp+24(FP), R9 378 MOVQ fn+32(FP), R12 379 380 MOVL $56, AX 381 SYSCALL 382 383 // In parent, return. 384 CMPQ AX, $0 385 JEQ 3(PC) 386 MOVL AX, ret+40(FP) 387 RET 388 389 // In child, on new stack. 390 MOVQ SI, SP 391 392 // If g or m are nil, skip Go-related setup. 393 CMPQ R8, $0 // m 394 JEQ nog 395 CMPQ R9, $0 // g 396 JEQ nog 397 398 // Initialize m->procid to Linux tid 399 MOVL $186, AX // gettid 400 SYSCALL 401 MOVQ AX, m_procid(R8) 402 403 // Set FS to point at m->tls. 404 LEAQ m_tls(R8), DI 405 CALL runtime·settls(SB) 406 407 // In child, set up new stack 408 get_tls(CX) 409 MOVQ R8, g_m(R9) 410 MOVQ R9, g(CX) 411 CALL runtime·stackcheck(SB) 412 413 nog: 414 // Call fn 415 CALL R12 416 417 // It shouldn't return. If it does, exit that thread. 418 MOVL $111, DI 419 MOVL $60, AX 420 SYSCALL 421 JMP -3(PC) // keep exiting 422 423 TEXT runtime·sigaltstack(SB),NOSPLIT,$-8 424 MOVQ new+8(SP), DI 425 MOVQ old+16(SP), SI 426 MOVQ $131, AX 427 SYSCALL 428 CMPQ AX, $0xfffffffffffff001 429 JLS 2(PC) 430 MOVL $0xf1, 0xf1 // crash 431 RET 432 433 // set tls base to DI 434 TEXT runtime·settls(SB),NOSPLIT,$32 435 #ifdef GOOS_android 436 // Same as in sys_darwin_386.s:/ugliness, different constant. 437 // DI currently holds m->tls, which must be fs:0x1d0. 438 // See cgo/gcc_android_amd64.c for the derivation of the constant. 439 SUBQ $0x1d0, DI // In android, the tls base 440 #else 441 ADDQ $8, DI // ELF wants to use -8(FS) 442 #endif 443 MOVQ DI, SI 444 MOVQ $0x1002, DI // ARCH_SET_FS 445 MOVQ $158, AX // arch_prctl 446 SYSCALL 447 CMPQ AX, $0xfffffffffffff001 448 JLS 2(PC) 449 MOVL $0xf1, 0xf1 // crash 450 RET 451 452 TEXT runtime·osyield(SB),NOSPLIT,$0 453 MOVL $24, AX 454 SYSCALL 455 RET 456 457 TEXT runtime·sched_getaffinity(SB),NOSPLIT,$0 458 MOVQ pid+0(FP), DI 459 MOVQ len+8(FP), SI 460 MOVQ buf+16(FP), DX 461 MOVL $204, AX // syscall entry 462 SYSCALL 463 MOVL AX, ret+24(FP) 464 RET 465 466 // int32 runtime·epollcreate(int32 size); 467 TEXT runtime·epollcreate(SB),NOSPLIT,$0 468 MOVL size+0(FP), DI 469 MOVL $213, AX // syscall entry 470 SYSCALL 471 MOVL AX, ret+8(FP) 472 RET 473 474 // int32 runtime·epollcreate1(int32 flags); 475 TEXT runtime·epollcreate1(SB),NOSPLIT,$0 476 MOVL flags+0(FP), DI 477 MOVL $291, AX // syscall entry 478 SYSCALL 479 MOVL AX, ret+8(FP) 480 RET 481 482 // func epollctl(epfd, op, fd int32, ev *epollEvent) int 483 TEXT runtime·epollctl(SB),NOSPLIT,$0 484 MOVL epfd+0(FP), DI 485 MOVL op+4(FP), SI 486 MOVL fd+8(FP), DX 487 MOVQ ev+16(FP), R10 488 MOVL $233, AX // syscall entry 489 SYSCALL 490 MOVL AX, ret+24(FP) 491 RET 492 493 // int32 runtime·epollwait(int32 epfd, EpollEvent *ev, int32 nev, int32 timeout); 494 TEXT runtime·epollwait(SB),NOSPLIT,$0 495 MOVL epfd+0(FP), DI 496 MOVQ ev+8(FP), SI 497 MOVL nev+16(FP), DX 498 MOVL timeout+20(FP), R10 499 MOVL $232, AX // syscall entry 500 SYSCALL 501 MOVL AX, ret+24(FP) 502 RET 503 504 // void runtime·closeonexec(int32 fd); 505 TEXT runtime·closeonexec(SB),NOSPLIT,$0 506 MOVL fd+0(FP), DI // fd 507 MOVQ $2, SI // F_SETFD 508 MOVQ $1, DX // FD_CLOEXEC 509 MOVL $72, AX // fcntl 510 SYSCALL 511 RET 512 513 514 // int access(const char *name, int mode) 515 TEXT runtime·access(SB),NOSPLIT,$0 516 MOVQ name+0(FP), DI 517 MOVL mode+8(FP), SI 518 MOVL $21, AX // syscall entry 519 SYSCALL 520 MOVL AX, ret+16(FP) 521 RET 522 523 // int connect(int fd, const struct sockaddr *addr, socklen_t addrlen) 524 TEXT runtime·connect(SB),NOSPLIT,$0-28 525 MOVL fd+0(FP), DI 526 MOVQ addr+8(FP), SI 527 MOVL addrlen+16(FP), DX 528 MOVL $42, AX // syscall entry 529 SYSCALL 530 MOVL AX, ret+24(FP) 531 RET 532 533 // int socket(int domain, int type, int protocol) 534 TEXT runtime·socket(SB),NOSPLIT,$0-20 535 MOVL domain+0(FP), DI 536 MOVL type+4(FP), SI 537 MOVL protocol+8(FP), DX 538 MOVL $41, AX // syscall entry 539 SYSCALL 540 MOVL AX, ret+16(FP) 541 RET