github.com/dannin/go@v0.0.0-20161031215817-d35dfd405eaa/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 how+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 sigtrampnog // 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, and the fifth, are already in registers. 280 // Set the two remaining 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 sigtrampnog: 290 // Signal arrived on a non-Go thread. If this is SIGPROF, get a 291 // stack trace. 292 CMPL DI, $27 // 27 == SIGPROF 293 JNZ sigtramp 294 295 // Lock sigprofCallersUse. 296 MOVL $0, AX 297 MOVL $1, CX 298 MOVQ $runtime·sigprofCallersUse(SB), BX 299 LOCK 300 CMPXCHGL CX, 0(BX) 301 JNZ sigtramp // Skip stack trace if already locked. 302 303 // Jump to the traceback function in runtime/cgo. 304 // It will call back to sigprofNonGo, which will ignore the 305 // arguments passed in registers. 306 // First three arguments to traceback function are in registers already. 307 MOVQ runtime·cgoTraceback(SB), CX 308 MOVQ $runtime·sigprofCallers(SB), R8 309 MOVQ $runtime·sigprofNonGo(SB), R9 310 MOVQ _cgo_callers(SB), AX 311 JMP AX 312 313 // For cgo unwinding to work, this function must look precisely like 314 // the one in glibc. The glibc source code is: 315 // https://sourceware.org/git/?p=glibc.git;a=blob;f=sysdeps/unix/sysv/linux/x86_64/sigaction.c 316 // The code that cares about the precise instructions used is: 317 // https://gcc.gnu.org/viewcvs/gcc/trunk/libgcc/config/i386/linux-unwind.h?revision=219188&view=markup 318 TEXT runtime·sigreturn(SB),NOSPLIT,$0 319 MOVQ $15, AX // rt_sigreturn 320 SYSCALL 321 INT $3 // not reached 322 323 TEXT runtime·sysMmap(SB),NOSPLIT,$0 324 MOVQ addr+0(FP), DI 325 MOVQ n+8(FP), SI 326 MOVL prot+16(FP), DX 327 MOVL flags+20(FP), R10 328 MOVL fd+24(FP), R8 329 MOVL off+28(FP), R9 330 331 MOVL $9, AX // mmap 332 SYSCALL 333 CMPQ AX, $0xfffffffffffff001 334 JLS 3(PC) 335 NOTQ AX 336 INCQ AX 337 MOVQ AX, ret+32(FP) 338 RET 339 340 // Call the function stored in _cgo_mmap using the GCC calling convention. 341 // This must be called on the system stack. 342 TEXT runtime·callCgoMmap(SB),NOSPLIT,$16 343 MOVQ addr+0(FP), DI 344 MOVQ n+8(FP), SI 345 MOVL prot+16(FP), DX 346 MOVL flags+20(FP), CX 347 MOVL fd+24(FP), R8 348 MOVL off+28(FP), R9 349 MOVQ _cgo_mmap(SB), AX 350 MOVQ SP, BX 351 ANDQ $~15, SP // alignment as per amd64 psABI 352 MOVQ BX, 0(SP) 353 CALL AX 354 MOVQ 0(SP), SP 355 MOVQ AX, ret+32(FP) 356 RET 357 358 TEXT runtime·munmap(SB),NOSPLIT,$0 359 MOVQ addr+0(FP), DI 360 MOVQ n+8(FP), SI 361 MOVQ $11, AX // munmap 362 SYSCALL 363 CMPQ AX, $0xfffffffffffff001 364 JLS 2(PC) 365 MOVL $0xf1, 0xf1 // crash 366 RET 367 368 TEXT runtime·madvise(SB),NOSPLIT,$0 369 MOVQ addr+0(FP), DI 370 MOVQ n+8(FP), SI 371 MOVL flags+16(FP), DX 372 MOVQ $28, AX // madvise 373 SYSCALL 374 // ignore failure - maybe pages are locked 375 RET 376 377 // int64 futex(int32 *uaddr, int32 op, int32 val, 378 // struct timespec *timeout, int32 *uaddr2, int32 val2); 379 TEXT runtime·futex(SB),NOSPLIT,$0 380 MOVQ addr+0(FP), DI 381 MOVL op+8(FP), SI 382 MOVL val+12(FP), DX 383 MOVQ ts+16(FP), R10 384 MOVQ addr2+24(FP), R8 385 MOVL val3+32(FP), R9 386 MOVL $202, AX 387 SYSCALL 388 MOVL AX, ret+40(FP) 389 RET 390 391 // int32 clone(int32 flags, void *stk, M *mp, G *gp, void (*fn)(void)); 392 TEXT runtime·clone(SB),NOSPLIT,$0 393 MOVL flags+0(FP), DI 394 MOVQ stk+8(FP), SI 395 MOVQ $0, DX 396 MOVQ $0, R10 397 398 // Copy mp, gp, fn off parent stack for use by child. 399 // Careful: Linux system call clobbers CX and R11. 400 MOVQ mp+16(FP), R8 401 MOVQ gp+24(FP), R9 402 MOVQ fn+32(FP), R12 403 404 MOVL $56, AX 405 SYSCALL 406 407 // In parent, return. 408 CMPQ AX, $0 409 JEQ 3(PC) 410 MOVL AX, ret+40(FP) 411 RET 412 413 // In child, on new stack. 414 MOVQ SI, SP 415 416 // If g or m are nil, skip Go-related setup. 417 CMPQ R8, $0 // m 418 JEQ nog 419 CMPQ R9, $0 // g 420 JEQ nog 421 422 // Initialize m->procid to Linux tid 423 MOVL $186, AX // gettid 424 SYSCALL 425 MOVQ AX, m_procid(R8) 426 427 // Set FS to point at m->tls. 428 LEAQ m_tls(R8), DI 429 CALL runtime·settls(SB) 430 431 // In child, set up new stack 432 get_tls(CX) 433 MOVQ R8, g_m(R9) 434 MOVQ R9, g(CX) 435 CALL runtime·stackcheck(SB) 436 437 nog: 438 // Call fn 439 CALL R12 440 441 // It shouldn't return. If it does, exit that thread. 442 MOVL $111, DI 443 MOVL $60, AX 444 SYSCALL 445 JMP -3(PC) // keep exiting 446 447 TEXT runtime·sigaltstack(SB),NOSPLIT,$-8 448 MOVQ new+0(FP), DI 449 MOVQ old+8(FP), SI 450 MOVQ $131, AX 451 SYSCALL 452 CMPQ AX, $0xfffffffffffff001 453 JLS 2(PC) 454 MOVL $0xf1, 0xf1 // crash 455 RET 456 457 // set tls base to DI 458 TEXT runtime·settls(SB),NOSPLIT,$32 459 #ifdef GOOS_android 460 // Same as in sys_darwin_386.s:/ugliness, different constant. 461 // DI currently holds m->tls, which must be fs:0x1d0. 462 // See cgo/gcc_android_amd64.c for the derivation of the constant. 463 SUBQ $0x1d0, DI // In android, the tls base 464 #else 465 ADDQ $8, DI // ELF wants to use -8(FS) 466 #endif 467 MOVQ DI, SI 468 MOVQ $0x1002, DI // ARCH_SET_FS 469 MOVQ $158, AX // arch_prctl 470 SYSCALL 471 CMPQ AX, $0xfffffffffffff001 472 JLS 2(PC) 473 MOVL $0xf1, 0xf1 // crash 474 RET 475 476 TEXT runtime·osyield(SB),NOSPLIT,$0 477 MOVL $24, AX 478 SYSCALL 479 RET 480 481 TEXT runtime·sched_getaffinity(SB),NOSPLIT,$0 482 MOVQ pid+0(FP), DI 483 MOVQ len+8(FP), SI 484 MOVQ buf+16(FP), DX 485 MOVL $204, AX // syscall entry 486 SYSCALL 487 MOVL AX, ret+24(FP) 488 RET 489 490 // int32 runtime·epollcreate(int32 size); 491 TEXT runtime·epollcreate(SB),NOSPLIT,$0 492 MOVL size+0(FP), DI 493 MOVL $213, AX // syscall entry 494 SYSCALL 495 MOVL AX, ret+8(FP) 496 RET 497 498 // int32 runtime·epollcreate1(int32 flags); 499 TEXT runtime·epollcreate1(SB),NOSPLIT,$0 500 MOVL flags+0(FP), DI 501 MOVL $291, AX // syscall entry 502 SYSCALL 503 MOVL AX, ret+8(FP) 504 RET 505 506 // func epollctl(epfd, op, fd int32, ev *epollEvent) int 507 TEXT runtime·epollctl(SB),NOSPLIT,$0 508 MOVL epfd+0(FP), DI 509 MOVL op+4(FP), SI 510 MOVL fd+8(FP), DX 511 MOVQ ev+16(FP), R10 512 MOVL $233, AX // syscall entry 513 SYSCALL 514 MOVL AX, ret+24(FP) 515 RET 516 517 // int32 runtime·epollwait(int32 epfd, EpollEvent *ev, int32 nev, int32 timeout); 518 TEXT runtime·epollwait(SB),NOSPLIT,$0 519 MOVL epfd+0(FP), DI 520 MOVQ ev+8(FP), SI 521 MOVL nev+16(FP), DX 522 MOVL timeout+20(FP), R10 523 MOVL $232, AX // syscall entry 524 SYSCALL 525 MOVL AX, ret+24(FP) 526 RET 527 528 // void runtime·closeonexec(int32 fd); 529 TEXT runtime·closeonexec(SB),NOSPLIT,$0 530 MOVL fd+0(FP), DI // fd 531 MOVQ $2, SI // F_SETFD 532 MOVQ $1, DX // FD_CLOEXEC 533 MOVL $72, AX // fcntl 534 SYSCALL 535 RET 536 537 538 // int access(const char *name, int mode) 539 TEXT runtime·access(SB),NOSPLIT,$0 540 MOVQ name+0(FP), DI 541 MOVL mode+8(FP), SI 542 MOVL $21, AX // syscall entry 543 SYSCALL 544 MOVL AX, ret+16(FP) 545 RET 546 547 // int connect(int fd, const struct sockaddr *addr, socklen_t addrlen) 548 TEXT runtime·connect(SB),NOSPLIT,$0-28 549 MOVL fd+0(FP), DI 550 MOVQ addr+8(FP), SI 551 MOVL len+16(FP), DX 552 MOVL $42, AX // syscall entry 553 SYSCALL 554 MOVL AX, ret+24(FP) 555 RET 556 557 // int socket(int domain, int type, int protocol) 558 TEXT runtime·socket(SB),NOSPLIT,$0-20 559 MOVL domain+0(FP), DI 560 MOVL typ+4(FP), SI 561 MOVL prot+8(FP), DX 562 MOVL $41, AX // syscall entry 563 SYSCALL 564 MOVL AX, ret+16(FP) 565 RET