src/runtime/sys_linux_386.s

   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 386, Linux
   7 //
   8
   9 #include "go_asm.h"
  10 #include "go_tls.h"
  11 #include "textflag.h"
  12
  13 // Most linux systems use glibc's dynamic linker, which puts the
  14 // __kernel_vsyscall vdso helper at 0x10(GS) for easy access from position
  15 // independent code and setldt in runtime does the same in the statically
  16 // linked case. However, systems that use alternative libc such as Android's
  17 // bionic and musl, do not save the helper anywhere, and so the only way to
  18 // invoke a syscall from position independent code is boring old int $0x80
  19 // (which is also what syscall wrappers in bionic/musl use).
  20 //
  21 // The benchmarks also showed that using int $0x80 is as fast as calling
  22 // *%gs:0x10 except on AMD Opteron. See https://golang.org/cl/19833
  23 // for the benchmark program and raw data.
  24 //#define INVOKE_SYSCALL        CALL    0x10(GS) // non-portable
  25 #define INVOKE_SYSCALL  INT     $0x80
  26
  27 #define SYS_exit                1
  28 #define SYS_read                3
  29 #define SYS_write               4
  30 #define SYS_open                5
  31 #define SYS_close               6
  32 #define SYS_getpid              20
  33 #define SYS_access              33
  34 #define SYS_kill                37
  35 #define SYS_brk                 45
  36 #define SYS_munmap              91
  37 #define SYS_socketcall          102
  38 #define SYS_setittimer          104
  39 #define SYS_clone               120
  40 #define SYS_sched_yield         158
  41 #define SYS_nanosleep           162
  42 #define SYS_rt_sigreturn        173
  43 #define SYS_rt_sigaction        174
  44 #define SYS_rt_sigprocmask      175
  45 #define SYS_sigaltstack         186
  46 #define SYS_mmap2               192
  47 #define SYS_mincore             218
  48 #define SYS_madvise             219
  49 #define SYS_gettid              224
  50 #define SYS_futex               240
  51 #define SYS_sched_getaffinity   242
  52 #define SYS_set_thread_area     243
  53 #define SYS_exit_group          252
  54 #define SYS_timer_create        259
  55 #define SYS_timer_settime       260
  56 #define SYS_timer_delete        263
  57 #define SYS_clock_gettime       265
  58 #define SYS_tgkill              270
  59 #define SYS_pipe2               331
  60
  61 TEXT runtime·exit(SB),NOSPLIT,$0
  62         MOVL    $SYS_exit_group, AX
  63         MOVL    code+0(FP), BX
  64         INVOKE_SYSCALL
  65         INT $3  // not reached
  66         RET
  67
  68 TEXT exit1<>(SB),NOSPLIT,$0
  69         MOVL    $SYS_exit, AX
  70         MOVL    code+0(FP), BX
  71         INVOKE_SYSCALL
  72         INT $3  // not reached
  73         RET
  74
  75 // func exitThread(wait *atomic.Uint32)
  76 TEXT runtime·exitThread(SB),NOSPLIT,$0-4
  77         MOVL    wait+0(FP), AX
  78         // We're done using the stack.
  79         MOVL    $0, (AX)
  80         MOVL    $1, AX  // exit (just this thread)
  81         MOVL    $0, BX  // exit code
  82         INT     $0x80   // no stack; must not use CALL
  83         // We may not even have a stack any more.
  84         INT     $3
  85         JMP     0(PC)
  86
  87 TEXT runtime·open(SB),NOSPLIT,$0
  88         MOVL    $SYS_open, AX
  89         MOVL    name+0(FP), BX
  90         MOVL    mode+4(FP), CX
  91         MOVL    perm+8(FP), DX
  92         INVOKE_SYSCALL
  93         CMPL    AX, $0xfffff001
  94         JLS     2(PC)
  95         MOVL    $-1, AX
  96         MOVL    AX, ret+12(FP)
  97         RET
  98
  99 TEXT runtime·closefd(SB),NOSPLIT,$0
 100         MOVL    $SYS_close, AX
 101         MOVL    fd+0(FP), BX
 102         INVOKE_SYSCALL
 103         CMPL    AX, $0xfffff001
 104         JLS     2(PC)
 105         MOVL    $-1, AX
 106         MOVL    AX, ret+4(FP)
 107         RET
 108
 109 TEXT runtime·write1(SB),NOSPLIT,$0
 110         MOVL    $SYS_write, AX
 111         MOVL    fd+0(FP), BX
 112         MOVL    p+4(FP), CX
 113         MOVL    n+8(FP), DX
 114         INVOKE_SYSCALL
 115         MOVL    AX, ret+12(FP)
 116         RET
 117
 118 TEXT runtime·read(SB),NOSPLIT,$0
 119         MOVL    $SYS_read, AX
 120         MOVL    fd+0(FP), BX
 121         MOVL    p+4(FP), CX
 122         MOVL    n+8(FP), DX
 123         INVOKE_SYSCALL
 124         MOVL    AX, ret+12(FP)
 125         RET
 126
 127 // func pipe2(flags int32) (r, w int32, errno int32)
 128 TEXT runtime·pipe2(SB),NOSPLIT,$0-16
 129         MOVL    $SYS_pipe2, AX
 130         LEAL    r+4(FP), BX
 131         MOVL    flags+0(FP), CX
 132         INVOKE_SYSCALL
 133         MOVL    AX, errno+12(FP)
 134         RET
 135
 136 TEXT runtime·usleep(SB),NOSPLIT,$8
 137         MOVL    $0, DX
 138         MOVL    usec+0(FP), AX
 139         MOVL    $1000000, CX
 140         DIVL    CX
 141         MOVL    AX, 0(SP)
 142         MOVL    $1000, AX       // usec to nsec
 143         MULL    DX
 144         MOVL    AX, 4(SP)
 145
 146         // nanosleep(&ts, 0)
 147         MOVL    $SYS_nanosleep, AX
 148         LEAL    0(SP), BX
 149         MOVL    $0, CX
 150         INVOKE_SYSCALL
 151         RET
 152
 153 TEXT runtime·gettid(SB),NOSPLIT,$0-4
 154         MOVL    $SYS_gettid, AX
 155         INVOKE_SYSCALL
 156         MOVL    AX, ret+0(FP)
 157         RET
 158
 159 TEXT runtime·raise(SB),NOSPLIT,$12
 160         MOVL    $SYS_getpid, AX
 161         INVOKE_SYSCALL
 162         MOVL    AX, BX  // arg 1 pid
 163         MOVL    $SYS_gettid, AX
 164         INVOKE_SYSCALL
 165         MOVL    AX, CX  // arg 2 tid
 166         MOVL    sig+0(FP), DX   // arg 3 signal
 167         MOVL    $SYS_tgkill, AX
 168         INVOKE_SYSCALL
 169         RET
 170
 171 TEXT runtime·raiseproc(SB),NOSPLIT,$12
 172         MOVL    $SYS_getpid, AX
 173         INVOKE_SYSCALL
 174         MOVL    AX, BX  // arg 1 pid
 175         MOVL    sig+0(FP), CX   // arg 2 signal
 176         MOVL    $SYS_kill, AX
 177         INVOKE_SYSCALL
 178         RET
 179
 180 TEXT ·getpid(SB),NOSPLIT,$0-4
 181         MOVL    $SYS_getpid, AX
 182         INVOKE_SYSCALL
 183         MOVL    AX, ret+0(FP)
 184         RET
 185
 186 TEXT ·tgkill(SB),NOSPLIT,$0
 187         MOVL    $SYS_tgkill, AX
 188         MOVL    tgid+0(FP), BX
 189         MOVL    tid+4(FP), CX
 190         MOVL    sig+8(FP), DX
 191         INVOKE_SYSCALL
 192         RET
 193
 194 TEXT runtime·setitimer(SB),NOSPLIT,$0-12
 195         MOVL    $SYS_setittimer, AX
 196         MOVL    mode+0(FP), BX
 197         MOVL    new+4(FP), CX
 198         MOVL    old+8(FP), DX
 199         INVOKE_SYSCALL
 200         RET
 201
 202 TEXT runtime·timer_create(SB),NOSPLIT,$0-16
 203         MOVL    $SYS_timer_create, AX
 204         MOVL    clockid+0(FP), BX
 205         MOVL    sevp+4(FP), CX
 206         MOVL    timerid+8(FP), DX
 207         INVOKE_SYSCALL
 208         MOVL    AX, ret+12(FP)
 209         RET
 210
 211 TEXT runtime·timer_settime(SB),NOSPLIT,$0-20
 212         MOVL    $SYS_timer_settime, AX
 213         MOVL    timerid+0(FP), BX
 214         MOVL    flags+4(FP), CX
 215         MOVL    new+8(FP), DX
 216         MOVL    old+12(FP), SI
 217         INVOKE_SYSCALL
 218         MOVL    AX, ret+16(FP)
 219         RET
 220
 221 TEXT runtime·timer_delete(SB),NOSPLIT,$0-8
 222         MOVL    $SYS_timer_delete, AX
 223         MOVL    timerid+0(FP), BX
 224         INVOKE_SYSCALL
 225         MOVL    AX, ret+4(FP)
 226         RET
 227
 228 TEXT runtime·mincore(SB),NOSPLIT,$0-16
 229         MOVL    $SYS_mincore, AX
 230         MOVL    addr+0(FP), BX
 231         MOVL    n+4(FP), CX
 232         MOVL    dst+8(FP), DX
 233         INVOKE_SYSCALL
 234         MOVL    AX, ret+12(FP)
 235         RET
 236
 237 // func walltime() (sec int64, nsec int32)
 238 TEXT runtime·walltime(SB), NOSPLIT, $8-12
 239         // We don't know how much stack space the VDSO code will need,
 240         // so switch to g0.
 241
 242         MOVL    SP, BP  // Save old SP; BP unchanged by C code.
 243
 244         get_tls(CX)
 245         MOVL    g(CX), AX
 246         MOVL    g_m(AX), SI // SI unchanged by C code.
 247
 248         // Set vdsoPC and vdsoSP for SIGPROF traceback.
 249         // Save the old values on stack and restore them on exit,
 250         // so this function is reentrant.
 251         MOVL    m_vdsoPC(SI), CX
 252         MOVL    m_vdsoSP(SI), DX
 253         MOVL    CX, 0(SP)
 254         MOVL    DX, 4(SP)
 255
 256         LEAL    sec+0(FP), DX
 257         MOVL    -4(DX), CX
 258         MOVL    CX, m_vdsoPC(SI)
 259         MOVL    DX, m_vdsoSP(SI)
 260
 261         CMPL    AX, m_curg(SI)  // Only switch if on curg.
 262         JNE     noswitch
 263
 264         MOVL    m_g0(SI), DX
 265         MOVL    (g_sched+gobuf_sp)(DX), SP      // Set SP to g0 stack
 266
 267 noswitch:
 268         SUBL    $16, SP         // Space for results
 269         ANDL    $~15, SP        // Align for C code
 270
 271         // Stack layout, depending on call path:
 272         //  x(SP)   vDSO            INVOKE_SYSCALL
 273         //    12    ts.tv_nsec      ts.tv_nsec
 274         //     8    ts.tv_sec       ts.tv_sec
 275         //     4    &ts             -
 276         //     0    CLOCK_<id>      -
 277
 278         MOVL    runtime·vdsoClockgettimeSym(SB), AX
 279         CMPL    AX, $0
 280         JEQ     fallback
 281
 282         LEAL    8(SP), BX       // &ts (struct timespec)
 283         MOVL    BX, 4(SP)
 284         MOVL    $0, 0(SP)       // CLOCK_REALTIME
 285         CALL    AX
 286         JMP finish
 287
 288 fallback:
 289         MOVL    $SYS_clock_gettime, AX
 290         MOVL    $0, BX          // CLOCK_REALTIME
 291         LEAL    8(SP), CX
 292         INVOKE_SYSCALL
 293
 294 finish:
 295         MOVL    8(SP), AX       // sec
 296         MOVL    12(SP), BX      // nsec
 297
 298         MOVL    BP, SP          // Restore real SP
 299         // Restore vdsoPC, vdsoSP
 300         // We don't worry about being signaled between the two stores.
 301         // If we are not in a signal handler, we'll restore vdsoSP to 0,
 302         // and no one will care about vdsoPC. If we are in a signal handler,
 303         // we cannot receive another signal.
 304         MOVL    4(SP), CX
 305         MOVL    CX, m_vdsoSP(SI)
 306         MOVL    0(SP), CX
 307         MOVL    CX, m_vdsoPC(SI)
 308
 309         // sec is in AX, nsec in BX
 310         MOVL    AX, sec_lo+0(FP)
 311         MOVL    $0, sec_hi+4(FP)
 312         MOVL    BX, nsec+8(FP)
 313         RET
 314
 315 // int64 nanotime(void) so really
 316 // void nanotime(int64 *nsec)
 317 TEXT runtime·nanotime1(SB), NOSPLIT, $8-8
 318         // Switch to g0 stack. See comment above in runtime·walltime.
 319
 320         MOVL    SP, BP  // Save old SP; BP unchanged by C code.
 321
 322         get_tls(CX)
 323         MOVL    g(CX), AX
 324         MOVL    g_m(AX), SI // SI unchanged by C code.
 325
 326         // Set vdsoPC and vdsoSP for SIGPROF traceback.
 327         // Save the old values on stack and restore them on exit,
 328         // so this function is reentrant.
 329         MOVL    m_vdsoPC(SI), CX
 330         MOVL    m_vdsoSP(SI), DX
 331         MOVL    CX, 0(SP)
 332         MOVL    DX, 4(SP)
 333
 334         LEAL    ret+0(FP), DX
 335         MOVL    -4(DX), CX
 336         MOVL    CX, m_vdsoPC(SI)
 337         MOVL    DX, m_vdsoSP(SI)
 338
 339         CMPL    AX, m_curg(SI)  // Only switch if on curg.
 340         JNE     noswitch
 341
 342         MOVL    m_g0(SI), DX
 343         MOVL    (g_sched+gobuf_sp)(DX), SP      // Set SP to g0 stack
 344
 345 noswitch:
 346         SUBL    $16, SP         // Space for results
 347         ANDL    $~15, SP        // Align for C code
 348
 349         MOVL    runtime·vdsoClockgettimeSym(SB), AX
 350         CMPL    AX, $0
 351         JEQ     fallback
 352
 353         LEAL    8(SP), BX       // &ts (struct timespec)
 354         MOVL    BX, 4(SP)
 355         MOVL    $1, 0(SP)       // CLOCK_MONOTONIC
 356         CALL    AX
 357         JMP finish
 358
 359 fallback:
 360         MOVL    $SYS_clock_gettime, AX
 361         MOVL    $1, BX          // CLOCK_MONOTONIC
 362         LEAL    8(SP), CX
 363         INVOKE_SYSCALL
 364
 365 finish:
 366         MOVL    8(SP), AX       // sec
 367         MOVL    12(SP), BX      // nsec
 368
 369         MOVL    BP, SP          // Restore real SP
 370         // Restore vdsoPC, vdsoSP
 371         // We don't worry about being signaled between the two stores.
 372         // If we are not in a signal handler, we'll restore vdsoSP to 0,
 373         // and no one will care about vdsoPC. If we are in a signal handler,
 374         // we cannot receive another signal.
 375         MOVL    4(SP), CX
 376         MOVL    CX, m_vdsoSP(SI)
 377         MOVL    0(SP), CX
 378         MOVL    CX, m_vdsoPC(SI)
 379
 380         // sec is in AX, nsec in BX
 381         // convert to DX:AX nsec
 382         MOVL    $1000000000, CX
 383         MULL    CX
 384         ADDL    BX, AX
 385         ADCL    $0, DX
 386
 387         MOVL    AX, ret_lo+0(FP)
 388         MOVL    DX, ret_hi+4(FP)
 389         RET
 390
 391 TEXT runtime·rtsigprocmask(SB),NOSPLIT,$0
 392         MOVL    $SYS_rt_sigprocmask, AX
 393         MOVL    how+0(FP), BX
 394         MOVL    new+4(FP), CX
 395         MOVL    old+8(FP), DX
 396         MOVL    size+12(FP), SI
 397         INVOKE_SYSCALL
 398         CMPL    AX, $0xfffff001
 399         JLS     2(PC)
 400         INT $3
 401         RET
 402
 403 TEXT runtime·rt_sigaction(SB),NOSPLIT,$0
 404         MOVL    $SYS_rt_sigaction, AX
 405         MOVL    sig+0(FP), BX
 406         MOVL    new+4(FP), CX
 407         MOVL    old+8(FP), DX
 408         MOVL    size+12(FP), SI
 409         INVOKE_SYSCALL
 410         MOVL    AX, ret+16(FP)
 411         RET
 412
 413 TEXT runtime·sigfwd(SB),NOSPLIT,$12-16
 414         MOVL    fn+0(FP), AX
 415         MOVL    sig+4(FP), BX
 416         MOVL    info+8(FP), CX
 417         MOVL    ctx+12(FP), DX
 418         MOVL    SP, SI
 419         SUBL    $32, SP
 420         ANDL    $-15, SP        // align stack: handler might be a C function
 421         MOVL    BX, 0(SP)
 422         MOVL    CX, 4(SP)
 423         MOVL    DX, 8(SP)
 424         MOVL    SI, 12(SP)      // save SI: handler might be a Go function
 425         CALL    AX
 426         MOVL    12(SP), AX
 427         MOVL    AX, SP
 428         RET
 429
 430 // Called using C ABI.
 431 TEXT runtime·sigtramp(SB),NOSPLIT|TOPFRAME,$28
 432         // Save callee-saved C registers, since the caller may be a C signal handler.
 433         MOVL    BX, bx-4(SP)
 434         MOVL    BP, bp-8(SP)
 435         MOVL    SI, si-12(SP)
 436         MOVL    DI, di-16(SP)
 437         // We don't save mxcsr or the x87 control word because sigtrampgo doesn't
 438         // modify them.
 439
 440         MOVL    (28+4)(SP), BX
 441         MOVL    BX, 0(SP)
 442         MOVL    (28+8)(SP), BX
 443         MOVL    BX, 4(SP)
 444         MOVL    (28+12)(SP), BX
 445         MOVL    BX, 8(SP)
 446         CALL    runtime·sigtrampgo(SB)
 447
 448         MOVL    di-16(SP), DI
 449         MOVL    si-12(SP), SI
 450         MOVL    bp-8(SP),  BP
 451         MOVL    bx-4(SP),  BX
 452         RET
 453
 454 TEXT runtime·cgoSigtramp(SB),NOSPLIT,$0
 455         JMP     runtime·sigtramp(SB)
 456
 457 // For cgo unwinding to work, this function must look precisely like
 458 // the one in glibc. The glibc source code is:
 459 // https://sourceware.org/git/?p=glibc.git;a=blob;f=sysdeps/unix/sysv/linux/i386/libc_sigaction.c;h=0665b41bbcd0986f0b33bf19a7ecbcedf9961d0a#l59
 460 // The code that cares about the precise instructions used is:
 461 // https://gcc.gnu.org/git/?p=gcc.git;a=blob;f=libgcc/config/i386/linux-unwind.h;h=5486223d60272c73d5103b29ae592d2ee998e1cf#l136
 462 //
 463 // For gdb unwinding to work, this function must look precisely like the one in
 464 // glibc and must be named "__restore_rt" or contain the string "sigaction" in
 465 // the name. The gdb source code is:
 466 // https://sourceware.org/git/?p=binutils-gdb.git;a=blob;f=gdb/i386-linux-tdep.c;h=a6adeca1b97416f7194341151a8ce30723a786a3#l168
 467 TEXT runtime·sigreturn__sigaction(SB),NOSPLIT,$0
 468         MOVL    $SYS_rt_sigreturn, AX
 469         // Sigreturn expects same SP as signal handler,
 470         // so cannot CALL 0x10(GS) here.
 471         INT     $0x80
 472         INT     $3      // not reached
 473         RET
 474
 475 TEXT runtime·mmap(SB),NOSPLIT,$0
 476         MOVL    $SYS_mmap2, AX
 477         MOVL    addr+0(FP), BX
 478         MOVL    n+4(FP), CX
 479         MOVL    prot+8(FP), DX
 480         MOVL    flags+12(FP), SI
 481         MOVL    fd+16(FP), DI
 482         MOVL    off+20(FP), BP
 483         SHRL    $12, BP
 484         INVOKE_SYSCALL
 485         CMPL    AX, $0xfffff001
 486         JLS     ok
 487         NOTL    AX
 488         INCL    AX
 489         MOVL    $0, p+24(FP)
 490         MOVL    AX, err+28(FP)
 491         RET
 492 ok:
 493         MOVL    AX, p+24(FP)
 494         MOVL    $0, err+28(FP)
 495         RET
 496
 497 TEXT runtime·munmap(SB),NOSPLIT,$0
 498         MOVL    $SYS_munmap, AX
 499         MOVL    addr+0(FP), BX
 500         MOVL    n+4(FP), CX
 501         INVOKE_SYSCALL
 502         CMPL    AX, $0xfffff001
 503         JLS     2(PC)
 504         INT $3
 505         RET
 506
 507 TEXT runtime·madvise(SB),NOSPLIT,$0
 508         MOVL    $SYS_madvise, AX
 509         MOVL    addr+0(FP), BX
 510         MOVL    n+4(FP), CX
 511         MOVL    flags+8(FP), DX
 512         INVOKE_SYSCALL
 513         MOVL    AX, ret+12(FP)
 514         RET
 515
 516 // int32 futex(int32 *uaddr, int32 op, int32 val,
 517 //      struct timespec *timeout, int32 *uaddr2, int32 val2);
 518 TEXT runtime·futex(SB),NOSPLIT,$0
 519         MOVL    $SYS_futex, AX
 520         MOVL    addr+0(FP), BX
 521         MOVL    op+4(FP), CX
 522         MOVL    val+8(FP), DX
 523         MOVL    ts+12(FP), SI
 524         MOVL    addr2+16(FP), DI
 525         MOVL    val3+20(FP), BP
 526         INVOKE_SYSCALL
 527         MOVL    AX, ret+24(FP)
 528         RET
 529
 530 // int32 clone(int32 flags, void *stack, M *mp, G *gp, void (*fn)(void));
 531 TEXT runtime·clone(SB),NOSPLIT,$0
 532         MOVL    $SYS_clone, AX
 533         MOVL    flags+0(FP), BX
 534         MOVL    stk+4(FP), CX
 535         MOVL    $0, DX  // parent tid ptr
 536         MOVL    $0, DI  // child tid ptr
 537
 538         // Copy mp, gp, fn off parent stack for use by child.
 539         SUBL    $16, CX
 540         MOVL    mp+8(FP), SI
 541         MOVL    SI, 0(CX)
 542         MOVL    gp+12(FP), SI
 543         MOVL    SI, 4(CX)
 544         MOVL    fn+16(FP), SI
 545         MOVL    SI, 8(CX)
 546         MOVL    $1234, 12(CX)
 547
 548         // cannot use CALL 0x10(GS) here, because the stack changes during the
 549         // system call (after CALL 0x10(GS), the child is still using the
 550         // parent's stack when executing its RET instruction).
 551         INT     $0x80
 552
 553         // In parent, return.
 554         CMPL    AX, $0
 555         JEQ     3(PC)
 556         MOVL    AX, ret+20(FP)
 557         RET
 558
 559         // Paranoia: check that SP is as we expect.
 560         NOP     SP // tell vet SP changed - stop checking offsets
 561         MOVL    12(SP), BP
 562         CMPL    BP, $1234
 563         JEQ     2(PC)
 564         INT     $3
 565
 566         // Initialize AX to Linux tid
 567         MOVL    $SYS_gettid, AX
 568         INVOKE_SYSCALL
 569
 570         MOVL    0(SP), BX           // m
 571         MOVL    4(SP), DX           // g
 572         MOVL    8(SP), SI           // fn
 573
 574         CMPL    BX, $0
 575         JEQ     nog
 576         CMPL    DX, $0
 577         JEQ     nog
 578
 579         MOVL    AX, m_procid(BX)        // save tid as m->procid
 580
 581         // set up ldt 7+id to point at m->tls.
 582         LEAL    m_tls(BX), BP
 583         MOVL    m_id(BX), DI
 584         ADDL    $7, DI  // m0 is LDT#7. count up.
 585         // setldt(tls#, &tls, sizeof tls)
 586         PUSHAL  // save registers
 587         PUSHL   $32     // sizeof tls
 588         PUSHL   BP      // &tls
 589         PUSHL   DI      // tls #
 590         CALL    runtime·setldt(SB)
 591         POPL    AX
 592         POPL    AX
 593         POPL    AX
 594         POPAL
 595
 596         // Now segment is established. Initialize m, g.
 597         get_tls(AX)
 598         MOVL    DX, g(AX)
 599         MOVL    BX, g_m(DX)
 600
 601         CALL    runtime·stackcheck(SB) // smashes AX, CX
 602         MOVL    0(DX), DX       // paranoia; check they are not nil
 603         MOVL    0(BX), BX
 604
 605         // more paranoia; check that stack splitting code works
 606         PUSHAL
 607         CALL    runtime·emptyfunc(SB)
 608         POPAL
 609
 610 nog:
 611         CALL    SI      // fn()
 612         CALL    exit1<>(SB)
 613         MOVL    $0x1234, 0x1005
 614
 615 TEXT runtime·sigaltstack(SB),NOSPLIT,$-8
 616         MOVL    $SYS_sigaltstack, AX
 617         MOVL    new+0(FP), BX
 618         MOVL    old+4(FP), CX
 619         INVOKE_SYSCALL
 620         CMPL    AX, $0xfffff001
 621         JLS     2(PC)
 622         INT     $3
 623         RET
 624
 625 // <asm-i386/ldt.h>
 626 // struct user_desc {
 627 //      unsigned int  entry_number;
 628 //      unsigned long base_addr;
 629 //      unsigned int  limit;
 630 //      unsigned int  seg_32bit:1;
 631 //      unsigned int  contents:2;
 632 //      unsigned int  read_exec_only:1;
 633 //      unsigned int  limit_in_pages:1;
 634 //      unsigned int  seg_not_present:1;
 635 //      unsigned int  useable:1;
 636 // };
 637 #define SEG_32BIT 0x01
 638 // contents are the 2 bits 0x02 and 0x04.
 639 #define CONTENTS_DATA 0x00
 640 #define CONTENTS_STACK 0x02
 641 #define CONTENTS_CODE 0x04
 642 #define READ_EXEC_ONLY 0x08
 643 #define LIMIT_IN_PAGES 0x10
 644 #define SEG_NOT_PRESENT 0x20
 645 #define USEABLE 0x40
 646
 647 // `-1` means the kernel will pick a TLS entry on the first setldt call,
 648 // which happens during runtime init, and that we'll store back the saved
 649 // entry and reuse that on subsequent calls when creating new threads.
 650 DATA  runtime·tls_entry_number+0(SB)/4, $-1
 651 GLOBL runtime·tls_entry_number(SB), NOPTR, $4
 652
 653 // setldt(int entry, int address, int limit)
 654 // We use set_thread_area, which mucks with the GDT, instead of modify_ldt,
 655 // which would modify the LDT, but is disabled on some kernels.
 656 // The name, setldt, is a misnomer, although we leave this name as it is for
 657 // the compatibility with other platforms.
 658 TEXT runtime·setldt(SB),NOSPLIT,$32
 659         MOVL    base+4(FP), DX
 660
 661 #ifdef GOOS_android
 662         // Android stores the TLS offset in runtime·tls_g.
 663         SUBL    runtime·tls_g(SB), DX
 664         MOVL    DX, 0(DX)
 665 #else
 666         /*
 667          * When linking against the system libraries,
 668          * we use its pthread_create and let it set up %gs
 669          * for us.  When we do that, the private storage
 670          * we get is not at 0(GS), but -4(GS).
 671          * To insulate the rest of the tool chain from this
 672          * ugliness, 8l rewrites 0(TLS) into -4(GS) for us.
 673          * To accommodate that rewrite, we translate
 674          * the address here and bump the limit to 0xffffffff (no limit)
 675          * so that -4(GS) maps to 0(address).
 676          * Also, the final 0(GS) (current 4(DX)) has to point
 677          * to itself, to mimic ELF.
 678          */
 679         ADDL    $0x4, DX        // address
 680         MOVL    DX, 0(DX)
 681 #endif
 682
 683         // get entry number
 684         MOVL    runtime·tls_entry_number(SB), CX
 685
 686         // set up user_desc
 687         LEAL    16(SP), AX      // struct user_desc
 688         MOVL    CX, 0(AX)       // unsigned int entry_number
 689         MOVL    DX, 4(AX)       // unsigned long base_addr
 690         MOVL    $0xfffff, 8(AX) // unsigned int limit
 691         MOVL    $(SEG_32BIT|LIMIT_IN_PAGES|USEABLE|CONTENTS_DATA), 12(AX)       // flag bits
 692
 693         // call set_thread_area
 694         MOVL    AX, BX  // user_desc
 695         MOVL    $SYS_set_thread_area, AX
 696         // We can't call this via 0x10(GS) because this is called from setldt0 to set that up.
 697         INT     $0x80
 698
 699         // breakpoint on error
 700         CMPL AX, $0xfffff001
 701         JLS 2(PC)
 702         INT $3
 703
 704         // read allocated entry number back out of user_desc
 705         LEAL    16(SP), AX      // get our user_desc back
 706         MOVL    0(AX), AX
 707
 708         // store entry number if the kernel allocated it
 709         CMPL    CX, $-1
 710         JNE     2(PC)
 711         MOVL    AX, runtime·tls_entry_number(SB)
 712
 713         // compute segment selector - (entry*8+3)
 714         SHLL    $3, AX
 715         ADDL    $3, AX
 716         MOVW    AX, GS
 717
 718         RET
 719
 720 TEXT runtime·osyield(SB),NOSPLIT,$0
 721         MOVL    $SYS_sched_yield, AX
 722         INVOKE_SYSCALL
 723         RET
 724
 725 TEXT runtime·sched_getaffinity(SB),NOSPLIT,$0
 726         MOVL    $SYS_sched_getaffinity, AX
 727         MOVL    pid+0(FP), BX
 728         MOVL    len+4(FP), CX
 729         MOVL    buf+8(FP), DX
 730         INVOKE_SYSCALL
 731         MOVL    AX, ret+12(FP)
 732         RET
 733
 734 // int access(const char *name, int mode)
 735 TEXT runtime·access(SB),NOSPLIT,$0
 736         MOVL    $SYS_access, AX
 737         MOVL    name+0(FP), BX
 738         MOVL    mode+4(FP), CX
 739         INVOKE_SYSCALL
 740         MOVL    AX, ret+8(FP)
 741         RET
 742
 743 // int connect(int fd, const struct sockaddr *addr, socklen_t addrlen)
 744 TEXT runtime·connect(SB),NOSPLIT,$0-16
 745         // connect is implemented as socketcall(NR_socket, 3, *(rest of args))
 746         // stack already should have fd, addr, addrlen.
 747         MOVL    $SYS_socketcall, AX
 748         MOVL    $3, BX  // connect
 749         LEAL    fd+0(FP), CX
 750         INVOKE_SYSCALL
 751         MOVL    AX, ret+12(FP)
 752         RET
 753
 754 // int socket(int domain, int type, int protocol)
 755 TEXT runtime·socket(SB),NOSPLIT,$0-16
 756         // socket is implemented as socketcall(NR_socket, 1, *(rest of args))
 757         // stack already should have domain, type, protocol.
 758         MOVL    $SYS_socketcall, AX
 759         MOVL    $1, BX  // socket
 760         LEAL    domain+0(FP), CX
 761         INVOKE_SYSCALL
 762         MOVL    AX, ret+12(FP)
 763         RET
 764
 765 // func sbrk0() uintptr
 766 TEXT runtime·sbrk0(SB),NOSPLIT,$0-4
 767         // Implemented as brk(NULL).
 768         MOVL    $SYS_brk, AX
 769         MOVL    $0, BX  // NULL
 770         INVOKE_SYSCALL
 771         MOVL    AX, ret+0(FP)
 772         RET