github.com/MangoDowner/go-gm@v0.0.0-20180818020936-8baa2bd4408c/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 MOVL $1000, AX // usec to nsec 86 MULL DX 87 MOVQ AX, 8(SP) 88 89 // pselect6(0, 0, 0, 0, &ts, 0) 90 MOVL $0, DI 91 MOVL $0, SI 92 MOVL $0, DX 93 MOVL $0, R10 94 MOVQ SP, R8 95 MOVL $0, R9 96 MOVL $270, AX 97 SYSCALL 98 RET 99 100 TEXT runtime·gettid(SB),NOSPLIT,$0-4 101 MOVL $186, AX // syscall - gettid 102 SYSCALL 103 MOVL AX, ret+0(FP) 104 RET 105 106 TEXT runtime·raise(SB),NOSPLIT,$0 107 MOVL $186, AX // syscall - gettid 108 SYSCALL 109 MOVL AX, DI // arg 1 tid 110 MOVL sig+0(FP), SI // arg 2 111 MOVL $200, AX // syscall - tkill 112 SYSCALL 113 RET 114 115 TEXT runtime·raiseproc(SB),NOSPLIT,$0 116 MOVL $39, AX // syscall - getpid 117 SYSCALL 118 MOVL AX, DI // arg 1 pid 119 MOVL sig+0(FP), SI // arg 2 120 MOVL $62, AX // syscall - kill 121 SYSCALL 122 RET 123 124 TEXT runtime·setitimer(SB),NOSPLIT,$0-24 125 MOVL mode+0(FP), DI 126 MOVQ new+8(FP), SI 127 MOVQ old+16(FP), DX 128 MOVL $38, AX // syscall entry 129 SYSCALL 130 RET 131 132 TEXT runtime·mincore(SB),NOSPLIT,$0-28 133 MOVQ addr+0(FP), DI 134 MOVQ n+8(FP), SI 135 MOVQ dst+16(FP), DX 136 MOVL $27, AX // syscall entry 137 SYSCALL 138 MOVL AX, ret+24(FP) 139 RET 140 141 // func walltime() (sec int64, nsec int32) 142 TEXT runtime·walltime(SB),NOSPLIT,$0-12 143 // We don't know how much stack space the VDSO code will need, 144 // so switch to g0. 145 // In particular, a kernel configured with CONFIG_OPTIMIZE_INLINING=n 146 // and hardening can use a full page of stack space in gettime_sym 147 // due to stack probes inserted to avoid stack/heap collisions. 148 // See issue #20427. 149 150 MOVQ SP, BP // Save old SP; BP unchanged by C code. 151 152 get_tls(CX) 153 MOVQ g(CX), AX 154 MOVQ g_m(AX), CX 155 MOVQ m_curg(CX), DX 156 157 CMPQ AX, DX // Only switch if on curg. 158 JNE noswitch 159 160 MOVQ m_g0(CX), DX 161 MOVQ (g_sched+gobuf_sp)(DX), SP // Set SP to g0 stack 162 163 noswitch: 164 SUBQ $16, SP // Space for results 165 ANDQ $~15, SP // Align for C code 166 167 MOVQ runtime·__vdso_clock_gettime_sym(SB), AX 168 CMPQ AX, $0 169 JEQ fallback 170 MOVL $0, DI // CLOCK_REALTIME 171 LEAQ 0(SP), SI 172 CALL AX 173 MOVQ 0(SP), AX // sec 174 MOVQ 8(SP), DX // nsec 175 MOVQ BP, SP // Restore real SP 176 MOVQ AX, sec+0(FP) 177 MOVL DX, nsec+8(FP) 178 RET 179 fallback: 180 LEAQ 0(SP), DI 181 MOVQ $0, SI 182 MOVQ runtime·__vdso_gettimeofday_sym(SB), AX 183 CALL AX 184 MOVQ 0(SP), AX // sec 185 MOVL 8(SP), DX // usec 186 IMULQ $1000, DX 187 MOVQ BP, SP // Restore real SP 188 MOVQ AX, sec+0(FP) 189 MOVL DX, nsec+8(FP) 190 RET 191 192 TEXT runtime·nanotime(SB),NOSPLIT,$0-8 193 // Switch to g0 stack. See comment above in runtime·walltime. 194 195 MOVQ SP, BP // Save old SP; BX unchanged by C code. 196 197 get_tls(CX) 198 MOVQ g(CX), AX 199 MOVQ g_m(AX), CX 200 MOVQ m_curg(CX), DX 201 202 CMPQ AX, DX // Only switch if on curg. 203 JNE noswitch 204 205 MOVQ m_g0(CX), DX 206 MOVQ (g_sched+gobuf_sp)(DX), SP // Set SP to g0 stack 207 208 noswitch: 209 SUBQ $16, SP // Space for results 210 ANDQ $~15, SP // Align for C code 211 212 MOVQ runtime·__vdso_clock_gettime_sym(SB), AX 213 CMPQ AX, $0 214 JEQ fallback 215 MOVL $1, DI // CLOCK_MONOTONIC 216 LEAQ 0(SP), SI 217 CALL AX 218 MOVQ 0(SP), AX // sec 219 MOVQ 8(SP), DX // nsec 220 MOVQ BP, SP // Restore real SP 221 // sec is in AX, nsec in DX 222 // return nsec in AX 223 IMULQ $1000000000, AX 224 ADDQ DX, AX 225 MOVQ AX, ret+0(FP) 226 RET 227 fallback: 228 LEAQ 0(SP), DI 229 MOVQ $0, SI 230 MOVQ runtime·__vdso_gettimeofday_sym(SB), AX 231 CALL AX 232 MOVQ 0(SP), AX // sec 233 MOVL 8(SP), DX // usec 234 MOVQ BP, SP // Restore real SP 235 IMULQ $1000, DX 236 // sec is in AX, nsec in DX 237 // return nsec in AX 238 IMULQ $1000000000, AX 239 ADDQ DX, AX 240 MOVQ AX, ret+0(FP) 241 RET 242 243 TEXT runtime·rtsigprocmask(SB),NOSPLIT,$0-28 244 MOVL how+0(FP), DI 245 MOVQ new+8(FP), SI 246 MOVQ old+16(FP), DX 247 MOVL size+24(FP), R10 248 MOVL $14, AX // syscall entry 249 SYSCALL 250 CMPQ AX, $0xfffffffffffff001 251 JLS 2(PC) 252 MOVL $0xf1, 0xf1 // crash 253 RET 254 255 TEXT runtime·sysSigaction(SB),NOSPLIT,$0-36 256 MOVQ sig+0(FP), DI 257 MOVQ new+8(FP), SI 258 MOVQ old+16(FP), DX 259 MOVQ size+24(FP), R10 260 MOVL $13, AX // syscall entry 261 SYSCALL 262 MOVL AX, ret+32(FP) 263 RET 264 265 // Call the function stored in _cgo_sigaction using the GCC calling convention. 266 TEXT runtime·callCgoSigaction(SB),NOSPLIT,$16 267 MOVQ sig+0(FP), DI 268 MOVQ new+8(FP), SI 269 MOVQ old+16(FP), DX 270 MOVQ _cgo_sigaction(SB), AX 271 MOVQ SP, BX // callee-saved 272 ANDQ $~15, SP // alignment as per amd64 psABI 273 CALL AX 274 MOVQ BX, SP 275 MOVL AX, ret+24(FP) 276 RET 277 278 TEXT runtime·sigfwd(SB),NOSPLIT,$0-32 279 MOVQ fn+0(FP), AX 280 MOVL sig+8(FP), DI 281 MOVQ info+16(FP), SI 282 MOVQ ctx+24(FP), DX 283 PUSHQ BP 284 MOVQ SP, BP 285 ANDQ $~15, SP // alignment for x86_64 ABI 286 CALL AX 287 MOVQ BP, SP 288 POPQ BP 289 RET 290 291 TEXT runtime·sigtramp(SB),NOSPLIT,$72 292 // Save callee-saved C registers, since the caller may be a C signal handler. 293 MOVQ BX, bx-8(SP) 294 MOVQ BP, bp-16(SP) // save in case GOEXPERIMENT=noframepointer is set 295 MOVQ R12, r12-24(SP) 296 MOVQ R13, r13-32(SP) 297 MOVQ R14, r14-40(SP) 298 MOVQ R15, r15-48(SP) 299 // We don't save mxcsr or the x87 control word because sigtrampgo doesn't 300 // modify them. 301 302 MOVQ DX, ctx-56(SP) 303 MOVQ SI, info-64(SP) 304 MOVQ DI, signum-72(SP) 305 MOVQ $runtime·sigtrampgo(SB), AX 306 CALL AX 307 308 MOVQ r15-48(SP), R15 309 MOVQ r14-40(SP), R14 310 MOVQ r13-32(SP), R13 311 MOVQ r12-24(SP), R12 312 MOVQ bp-16(SP), BP 313 MOVQ bx-8(SP), BX 314 RET 315 316 // Used instead of sigtramp in programs that use cgo. 317 // Arguments from kernel are in DI, SI, DX. 318 TEXT runtime·cgoSigtramp(SB),NOSPLIT,$0 319 // If no traceback function, do usual sigtramp. 320 MOVQ runtime·cgoTraceback(SB), AX 321 TESTQ AX, AX 322 JZ sigtramp 323 324 // If no traceback support function, which means that 325 // runtime/cgo was not linked in, do usual sigtramp. 326 MOVQ _cgo_callers(SB), AX 327 TESTQ AX, AX 328 JZ sigtramp 329 330 // Figure out if we are currently in a cgo call. 331 // If not, just do usual sigtramp. 332 get_tls(CX) 333 MOVQ g(CX),AX 334 TESTQ AX, AX 335 JZ sigtrampnog // g == nil 336 MOVQ g_m(AX), AX 337 TESTQ AX, AX 338 JZ sigtramp // g.m == nil 339 MOVL m_ncgo(AX), CX 340 TESTL CX, CX 341 JZ sigtramp // g.m.ncgo == 0 342 MOVQ m_curg(AX), CX 343 TESTQ CX, CX 344 JZ sigtramp // g.m.curg == nil 345 MOVQ g_syscallsp(CX), CX 346 TESTQ CX, CX 347 JZ sigtramp // g.m.curg.syscallsp == 0 348 MOVQ m_cgoCallers(AX), R8 349 TESTQ R8, R8 350 JZ sigtramp // g.m.cgoCallers == nil 351 MOVL m_cgoCallersUse(AX), CX 352 TESTL CX, CX 353 JNZ sigtramp // g.m.cgoCallersUse != 0 354 355 // Jump to a function in runtime/cgo. 356 // That function, written in C, will call the user's traceback 357 // function with proper unwind info, and will then call back here. 358 // The first three arguments, and the fifth, are already in registers. 359 // Set the two remaining arguments now. 360 MOVQ runtime·cgoTraceback(SB), CX 361 MOVQ $runtime·sigtramp(SB), R9 362 MOVQ _cgo_callers(SB), AX 363 JMP AX 364 365 sigtramp: 366 JMP runtime·sigtramp(SB) 367 368 sigtrampnog: 369 // Signal arrived on a non-Go thread. If this is SIGPROF, get a 370 // stack trace. 371 CMPL DI, $27 // 27 == SIGPROF 372 JNZ sigtramp 373 374 // Lock sigprofCallersUse. 375 MOVL $0, AX 376 MOVL $1, CX 377 MOVQ $runtime·sigprofCallersUse(SB), R11 378 LOCK 379 CMPXCHGL CX, 0(R11) 380 JNZ sigtramp // Skip stack trace if already locked. 381 382 // Jump to the traceback function in runtime/cgo. 383 // It will call back to sigprofNonGo, which will ignore the 384 // arguments passed in registers. 385 // First three arguments to traceback function are in registers already. 386 MOVQ runtime·cgoTraceback(SB), CX 387 MOVQ $runtime·sigprofCallers(SB), R8 388 MOVQ $runtime·sigprofNonGo(SB), R9 389 MOVQ _cgo_callers(SB), AX 390 JMP AX 391 392 // For cgo unwinding to work, this function must look precisely like 393 // the one in glibc. The glibc source code is: 394 // https://sourceware.org/git/?p=glibc.git;a=blob;f=sysdeps/unix/sysv/linux/x86_64/sigaction.c 395 // The code that cares about the precise instructions used is: 396 // https://gcc.gnu.org/viewcvs/gcc/trunk/libgcc/config/i386/linux-unwind.h?revision=219188&view=markup 397 TEXT runtime·sigreturn(SB),NOSPLIT,$0 398 MOVQ $15, AX // rt_sigreturn 399 SYSCALL 400 INT $3 // not reached 401 402 TEXT runtime·sysMmap(SB),NOSPLIT,$0 403 MOVQ addr+0(FP), DI 404 MOVQ n+8(FP), SI 405 MOVL prot+16(FP), DX 406 MOVL flags+20(FP), R10 407 MOVL fd+24(FP), R8 408 MOVL off+28(FP), R9 409 410 MOVL $9, AX // mmap 411 SYSCALL 412 CMPQ AX, $0xfffffffffffff001 413 JLS 3(PC) 414 NOTQ AX 415 INCQ AX 416 MOVQ AX, ret+32(FP) 417 RET 418 419 // Call the function stored in _cgo_mmap using the GCC calling convention. 420 // This must be called on the system stack. 421 TEXT runtime·callCgoMmap(SB),NOSPLIT,$16 422 MOVQ addr+0(FP), DI 423 MOVQ n+8(FP), SI 424 MOVL prot+16(FP), DX 425 MOVL flags+20(FP), CX 426 MOVL fd+24(FP), R8 427 MOVL off+28(FP), R9 428 MOVQ _cgo_mmap(SB), AX 429 MOVQ SP, BX 430 ANDQ $~15, SP // alignment as per amd64 psABI 431 MOVQ BX, 0(SP) 432 CALL AX 433 MOVQ 0(SP), SP 434 MOVQ AX, ret+32(FP) 435 RET 436 437 TEXT runtime·sysMunmap(SB),NOSPLIT,$0 438 MOVQ addr+0(FP), DI 439 MOVQ n+8(FP), SI 440 MOVQ $11, AX // munmap 441 SYSCALL 442 CMPQ AX, $0xfffffffffffff001 443 JLS 2(PC) 444 MOVL $0xf1, 0xf1 // crash 445 RET 446 447 // Call the function stored in _cgo_munmap using the GCC calling convention. 448 // This must be called on the system stack. 449 TEXT runtime·callCgoMunmap(SB),NOSPLIT,$16-16 450 MOVQ addr+0(FP), DI 451 MOVQ n+8(FP), SI 452 MOVQ _cgo_munmap(SB), AX 453 MOVQ SP, BX 454 ANDQ $~15, SP // alignment as per amd64 psABI 455 MOVQ BX, 0(SP) 456 CALL AX 457 MOVQ 0(SP), SP 458 RET 459 460 TEXT runtime·madvise(SB),NOSPLIT,$0 461 MOVQ addr+0(FP), DI 462 MOVQ n+8(FP), SI 463 MOVL flags+16(FP), DX 464 MOVQ $28, AX // madvise 465 SYSCALL 466 // ignore failure - maybe pages are locked 467 RET 468 469 // int64 futex(int32 *uaddr, int32 op, int32 val, 470 // struct timespec *timeout, int32 *uaddr2, int32 val2); 471 TEXT runtime·futex(SB),NOSPLIT,$0 472 MOVQ addr+0(FP), DI 473 MOVL op+8(FP), SI 474 MOVL val+12(FP), DX 475 MOVQ ts+16(FP), R10 476 MOVQ addr2+24(FP), R8 477 MOVL val3+32(FP), R9 478 MOVL $202, AX 479 SYSCALL 480 MOVL AX, ret+40(FP) 481 RET 482 483 // int32 clone(int32 flags, void *stk, M *mp, G *gp, void (*fn)(void)); 484 TEXT runtime·clone(SB),NOSPLIT,$0 485 MOVL flags+0(FP), DI 486 MOVQ stk+8(FP), SI 487 MOVQ $0, DX 488 MOVQ $0, R10 489 490 // Copy mp, gp, fn off parent stack for use by child. 491 // Careful: Linux system call clobbers CX and R11. 492 MOVQ mp+16(FP), R8 493 MOVQ gp+24(FP), R9 494 MOVQ fn+32(FP), R12 495 496 MOVL $56, AX 497 SYSCALL 498 499 // In parent, return. 500 CMPQ AX, $0 501 JEQ 3(PC) 502 MOVL AX, ret+40(FP) 503 RET 504 505 // In child, on new stack. 506 MOVQ SI, SP 507 508 // If g or m are nil, skip Go-related setup. 509 CMPQ R8, $0 // m 510 JEQ nog 511 CMPQ R9, $0 // g 512 JEQ nog 513 514 // Initialize m->procid to Linux tid 515 MOVL $186, AX // gettid 516 SYSCALL 517 MOVQ AX, m_procid(R8) 518 519 // Set FS to point at m->tls. 520 LEAQ m_tls(R8), DI 521 CALL runtime·settls(SB) 522 523 // In child, set up new stack 524 get_tls(CX) 525 MOVQ R8, g_m(R9) 526 MOVQ R9, g(CX) 527 CALL runtime·stackcheck(SB) 528 529 nog: 530 // Call fn 531 CALL R12 532 533 // It shouldn't return. If it does, exit that thread. 534 MOVL $111, DI 535 MOVL $60, AX 536 SYSCALL 537 JMP -3(PC) // keep exiting 538 539 TEXT runtime·sigaltstack(SB),NOSPLIT,$-8 540 MOVQ new+0(FP), DI 541 MOVQ old+8(FP), SI 542 MOVQ $131, AX 543 SYSCALL 544 CMPQ AX, $0xfffffffffffff001 545 JLS 2(PC) 546 MOVL $0xf1, 0xf1 // crash 547 RET 548 549 // set tls base to DI 550 TEXT runtime·settls(SB),NOSPLIT,$32 551 #ifdef GOOS_android 552 // Same as in sys_darwin_386.s:/ugliness, different constant. 553 // DI currently holds m->tls, which must be fs:0x1d0. 554 // See cgo/gcc_android_amd64.c for the derivation of the constant. 555 SUBQ $0x1d0, DI // In android, the tls base 556 #else 557 ADDQ $8, DI // ELF wants to use -8(FS) 558 #endif 559 MOVQ DI, SI 560 MOVQ $0x1002, DI // ARCH_SET_FS 561 MOVQ $158, AX // arch_prctl 562 SYSCALL 563 CMPQ AX, $0xfffffffffffff001 564 JLS 2(PC) 565 MOVL $0xf1, 0xf1 // crash 566 RET 567 568 TEXT runtime·osyield(SB),NOSPLIT,$0 569 MOVL $24, AX 570 SYSCALL 571 RET 572 573 TEXT runtime·sched_getaffinity(SB),NOSPLIT,$0 574 MOVQ pid+0(FP), DI 575 MOVQ len+8(FP), SI 576 MOVQ buf+16(FP), DX 577 MOVL $204, AX // syscall entry 578 SYSCALL 579 MOVL AX, ret+24(FP) 580 RET 581 582 // int32 runtime·epollcreate(int32 size); 583 TEXT runtime·epollcreate(SB),NOSPLIT,$0 584 MOVL size+0(FP), DI 585 MOVL $213, AX // syscall entry 586 SYSCALL 587 MOVL AX, ret+8(FP) 588 RET 589 590 // int32 runtime·epollcreate1(int32 flags); 591 TEXT runtime·epollcreate1(SB),NOSPLIT,$0 592 MOVL flags+0(FP), DI 593 MOVL $291, AX // syscall entry 594 SYSCALL 595 MOVL AX, ret+8(FP) 596 RET 597 598 // func epollctl(epfd, op, fd int32, ev *epollEvent) int 599 TEXT runtime·epollctl(SB),NOSPLIT,$0 600 MOVL epfd+0(FP), DI 601 MOVL op+4(FP), SI 602 MOVL fd+8(FP), DX 603 MOVQ ev+16(FP), R10 604 MOVL $233, AX // syscall entry 605 SYSCALL 606 MOVL AX, ret+24(FP) 607 RET 608 609 // int32 runtime·epollwait(int32 epfd, EpollEvent *ev, int32 nev, int32 timeout); 610 TEXT runtime·epollwait(SB),NOSPLIT,$0 611 MOVL epfd+0(FP), DI 612 MOVQ ev+8(FP), SI 613 MOVL nev+16(FP), DX 614 MOVL timeout+20(FP), R10 615 MOVL $232, AX // syscall entry 616 SYSCALL 617 MOVL AX, ret+24(FP) 618 RET 619 620 // void runtime·closeonexec(int32 fd); 621 TEXT runtime·closeonexec(SB),NOSPLIT,$0 622 MOVL fd+0(FP), DI // fd 623 MOVQ $2, SI // F_SETFD 624 MOVQ $1, DX // FD_CLOEXEC 625 MOVL $72, AX // fcntl 626 SYSCALL 627 RET 628 629 630 // int access(const char *name, int mode) 631 TEXT runtime·access(SB),NOSPLIT,$0 632 MOVQ name+0(FP), DI 633 MOVL mode+8(FP), SI 634 MOVL $21, AX // syscall entry 635 SYSCALL 636 MOVL AX, ret+16(FP) 637 RET 638 639 // int connect(int fd, const struct sockaddr *addr, socklen_t addrlen) 640 TEXT runtime·connect(SB),NOSPLIT,$0-28 641 MOVL fd+0(FP), DI 642 MOVQ addr+8(FP), SI 643 MOVL len+16(FP), DX 644 MOVL $42, AX // syscall entry 645 SYSCALL 646 MOVL AX, ret+24(FP) 647 RET 648 649 // int socket(int domain, int type, int protocol) 650 TEXT runtime·socket(SB),NOSPLIT,$0-20 651 MOVL domain+0(FP), DI 652 MOVL typ+4(FP), SI 653 MOVL prot+8(FP), DX 654 MOVL $41, AX // syscall entry 655 SYSCALL 656 MOVL AX, ret+16(FP) 657 RET 658 659 // func sbrk0() uintptr 660 TEXT runtime·sbrk0(SB),NOSPLIT,$0-8 661 // Implemented as brk(NULL). 662 MOVQ $0, DI 663 MOVL $12, AX // syscall entry 664 SYSCALL 665 MOVQ AX, ret+0(FP) 666 RET