github.com/comwrg/go/src@v0.0.0-20220319063731-c238d0440370/runtime/sys_freebsd_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 // System calls and other sys.stuff for AMD64, FreeBSD 6 // /usr/src/sys/kern/syscalls.master for syscall numbers. 7 // 8 9 #include "go_asm.h" 10 #include "go_tls.h" 11 #include "textflag.h" 12 #include "cgo/abi_amd64.h" 13 14 TEXT runtime·sys_umtx_op(SB),NOSPLIT,$0 15 MOVQ addr+0(FP), DI 16 MOVL mode+8(FP), SI 17 MOVL val+12(FP), DX 18 MOVQ uaddr1+16(FP), R10 19 MOVQ ut+24(FP), R8 20 MOVL $454, AX 21 SYSCALL 22 JCC 2(PC) 23 NEGQ AX 24 MOVL AX, ret+32(FP) 25 RET 26 27 TEXT runtime·thr_new(SB),NOSPLIT,$0 28 MOVQ param+0(FP), DI 29 MOVL size+8(FP), SI 30 MOVL $455, AX 31 SYSCALL 32 JCC 2(PC) 33 NEGQ AX 34 MOVL AX, ret+16(FP) 35 RET 36 37 TEXT runtime·thr_start(SB),NOSPLIT,$0 38 MOVQ DI, R13 // m 39 40 // set up FS to point at m->tls 41 LEAQ m_tls(R13), DI 42 CALL runtime·settls(SB) // smashes DI 43 44 // set up m, g 45 get_tls(CX) 46 MOVQ m_g0(R13), DI 47 MOVQ R13, g_m(DI) 48 MOVQ DI, g(CX) 49 50 CALL runtime·stackcheck(SB) 51 CALL runtime·mstart(SB) 52 53 MOVQ 0, AX // crash (not reached) 54 55 // Exit the entire program (like C exit) 56 TEXT runtime·exit(SB),NOSPLIT,$-8 57 MOVL code+0(FP), DI // arg 1 exit status 58 MOVL $1, AX 59 SYSCALL 60 MOVL $0xf1, 0xf1 // crash 61 RET 62 63 // func exitThread(wait *uint32) 64 TEXT runtime·exitThread(SB),NOSPLIT,$0-8 65 MOVQ wait+0(FP), AX 66 // We're done using the stack. 67 MOVL $0, (AX) 68 MOVL $0, DI // arg 1 long *state 69 MOVL $431, AX // thr_exit 70 SYSCALL 71 MOVL $0xf1, 0xf1 // crash 72 JMP 0(PC) 73 74 TEXT runtime·open(SB),NOSPLIT,$-8 75 MOVQ name+0(FP), DI // arg 1 pathname 76 MOVL mode+8(FP), SI // arg 2 flags 77 MOVL perm+12(FP), DX // arg 3 mode 78 MOVL $5, AX 79 SYSCALL 80 JCC 2(PC) 81 MOVL $-1, AX 82 MOVL AX, ret+16(FP) 83 RET 84 85 TEXT runtime·closefd(SB),NOSPLIT,$-8 86 MOVL fd+0(FP), DI // arg 1 fd 87 MOVL $6, AX 88 SYSCALL 89 JCC 2(PC) 90 MOVL $-1, AX 91 MOVL AX, ret+8(FP) 92 RET 93 94 TEXT runtime·read(SB),NOSPLIT,$-8 95 MOVL fd+0(FP), DI // arg 1 fd 96 MOVQ p+8(FP), SI // arg 2 buf 97 MOVL n+16(FP), DX // arg 3 count 98 MOVL $3, AX 99 SYSCALL 100 JCC 2(PC) 101 NEGQ AX // caller expects negative errno 102 MOVL AX, ret+24(FP) 103 RET 104 105 // func pipe() (r, w int32, errno int32) 106 TEXT runtime·pipe(SB),NOSPLIT,$0-12 107 MOVL $42, AX 108 SYSCALL 109 JCC ok 110 MOVL $0, r+0(FP) 111 MOVL $0, w+4(FP) 112 MOVL AX, errno+8(FP) 113 RET 114 ok: 115 MOVL AX, r+0(FP) 116 MOVL DX, w+4(FP) 117 MOVL $0, errno+8(FP) 118 RET 119 120 // func pipe2(flags int32) (r, w int32, errno int32) 121 TEXT runtime·pipe2(SB),NOSPLIT,$0-20 122 LEAQ r+8(FP), DI 123 MOVL flags+0(FP), SI 124 MOVL $542, AX 125 SYSCALL 126 JCC 2(PC) 127 NEGQ AX 128 MOVL AX, errno+16(FP) 129 RET 130 131 TEXT runtime·write1(SB),NOSPLIT,$-8 132 MOVQ fd+0(FP), DI // arg 1 fd 133 MOVQ p+8(FP), SI // arg 2 buf 134 MOVL n+16(FP), DX // arg 3 count 135 MOVL $4, AX 136 SYSCALL 137 JCC 2(PC) 138 NEGQ AX // caller expects negative errno 139 MOVL AX, ret+24(FP) 140 RET 141 142 TEXT runtime·thr_self(SB),NOSPLIT,$0-8 143 // thr_self(&0(FP)) 144 LEAQ ret+0(FP), DI // arg 1 145 MOVL $432, AX 146 SYSCALL 147 RET 148 149 TEXT runtime·thr_kill(SB),NOSPLIT,$0-16 150 // thr_kill(tid, sig) 151 MOVQ tid+0(FP), DI // arg 1 id 152 MOVQ sig+8(FP), SI // arg 2 sig 153 MOVL $433, AX 154 SYSCALL 155 RET 156 157 TEXT runtime·raiseproc(SB),NOSPLIT,$0 158 // getpid 159 MOVL $20, AX 160 SYSCALL 161 // kill(self, sig) 162 MOVQ AX, DI // arg 1 pid 163 MOVL sig+0(FP), SI // arg 2 sig 164 MOVL $37, AX 165 SYSCALL 166 RET 167 168 TEXT runtime·setitimer(SB), NOSPLIT, $-8 169 MOVL mode+0(FP), DI 170 MOVQ new+8(FP), SI 171 MOVQ old+16(FP), DX 172 MOVL $83, AX 173 SYSCALL 174 RET 175 176 // func fallback_walltime() (sec int64, nsec int32) 177 TEXT runtime·fallback_walltime(SB), NOSPLIT, $32-12 178 MOVL $232, AX // clock_gettime 179 MOVQ $0, DI // CLOCK_REALTIME 180 LEAQ 8(SP), SI 181 SYSCALL 182 MOVQ 8(SP), AX // sec 183 MOVQ 16(SP), DX // nsec 184 185 // sec is in AX, nsec in DX 186 MOVQ AX, sec+0(FP) 187 MOVL DX, nsec+8(FP) 188 RET 189 190 TEXT runtime·fallback_nanotime(SB), NOSPLIT, $32-8 191 MOVL $232, AX 192 MOVQ $4, DI // CLOCK_MONOTONIC 193 LEAQ 8(SP), SI 194 SYSCALL 195 MOVQ 8(SP), AX // sec 196 MOVQ 16(SP), DX // nsec 197 198 // sec is in AX, nsec in DX 199 // return nsec in AX 200 IMULQ $1000000000, AX 201 ADDQ DX, AX 202 MOVQ AX, ret+0(FP) 203 RET 204 205 TEXT runtime·asmSigaction(SB),NOSPLIT,$0 206 MOVQ sig+0(FP), DI // arg 1 sig 207 MOVQ new+8(FP), SI // arg 2 act 208 MOVQ old+16(FP), DX // arg 3 oact 209 MOVL $416, AX 210 SYSCALL 211 JCC 2(PC) 212 MOVL $-1, AX 213 MOVL AX, ret+24(FP) 214 RET 215 216 TEXT runtime·callCgoSigaction(SB),NOSPLIT,$16 217 MOVQ sig+0(FP), DI // arg 1 sig 218 MOVQ new+8(FP), SI // arg 2 act 219 MOVQ old+16(FP), DX // arg 3 oact 220 MOVQ _cgo_sigaction(SB), AX 221 MOVQ SP, BX // callee-saved 222 ANDQ $~15, SP // alignment as per amd64 psABI 223 CALL AX 224 MOVQ BX, SP 225 MOVL AX, ret+24(FP) 226 RET 227 228 TEXT runtime·sigfwd(SB),NOSPLIT,$0-32 229 MOVQ fn+0(FP), AX 230 MOVL sig+8(FP), DI 231 MOVQ info+16(FP), SI 232 MOVQ ctx+24(FP), DX 233 PUSHQ BP 234 MOVQ SP, BP 235 ANDQ $~15, SP // alignment for x86_64 ABI 236 CALL AX 237 MOVQ BP, SP 238 POPQ BP 239 RET 240 241 // Called using C ABI. 242 TEXT runtime·sigtramp(SB),NOSPLIT,$0 243 // Transition from C ABI to Go ABI. 244 PUSH_REGS_HOST_TO_ABI0() 245 246 // Call into the Go signal handler 247 NOP SP // disable vet stack checking 248 ADJSP $24 249 MOVQ DI, 0(SP) // sig 250 MOVQ SI, 8(SP) // info 251 MOVQ DX, 16(SP) // ctx 252 CALL ·sigtrampgo(SB) 253 ADJSP $-24 254 255 POP_REGS_HOST_TO_ABI0() 256 RET 257 258 // Used instead of sigtramp in programs that use cgo. 259 // Arguments from kernel are in DI, SI, DX. 260 TEXT runtime·cgoSigtramp(SB),NOSPLIT,$0 261 // If no traceback function, do usual sigtramp. 262 MOVQ runtime·cgoTraceback(SB), AX 263 TESTQ AX, AX 264 JZ sigtramp 265 266 // If no traceback support function, which means that 267 // runtime/cgo was not linked in, do usual sigtramp. 268 MOVQ _cgo_callers(SB), AX 269 TESTQ AX, AX 270 JZ sigtramp 271 272 // Figure out if we are currently in a cgo call. 273 // If not, just do usual sigtramp. 274 get_tls(CX) 275 MOVQ g(CX),AX 276 TESTQ AX, AX 277 JZ sigtrampnog // g == nil 278 MOVQ g_m(AX), AX 279 TESTQ AX, AX 280 JZ sigtramp // g.m == nil 281 MOVL m_ncgo(AX), CX 282 TESTL CX, CX 283 JZ sigtramp // g.m.ncgo == 0 284 MOVQ m_curg(AX), CX 285 TESTQ CX, CX 286 JZ sigtramp // g.m.curg == nil 287 MOVQ g_syscallsp(CX), CX 288 TESTQ CX, CX 289 JZ sigtramp // g.m.curg.syscallsp == 0 290 MOVQ m_cgoCallers(AX), R8 291 TESTQ R8, R8 292 JZ sigtramp // g.m.cgoCallers == nil 293 MOVL m_cgoCallersUse(AX), CX 294 TESTL CX, CX 295 JNZ sigtramp // g.m.cgoCallersUse != 0 296 297 // Jump to a function in runtime/cgo. 298 // That function, written in C, will call the user's traceback 299 // function with proper unwind info, and will then call back here. 300 // The first three arguments, and the fifth, are already in registers. 301 // Set the two remaining arguments now. 302 MOVQ runtime·cgoTraceback(SB), CX 303 MOVQ $runtime·sigtramp(SB), R9 304 MOVQ _cgo_callers(SB), AX 305 JMP AX 306 307 sigtramp: 308 JMP runtime·sigtramp(SB) 309 310 sigtrampnog: 311 // Signal arrived on a non-Go thread. If this is SIGPROF, get a 312 // stack trace. 313 CMPL DI, $27 // 27 == SIGPROF 314 JNZ sigtramp 315 316 // Lock sigprofCallersUse. 317 MOVL $0, AX 318 MOVL $1, CX 319 MOVQ $runtime·sigprofCallersUse(SB), R11 320 LOCK 321 CMPXCHGL CX, 0(R11) 322 JNZ sigtramp // Skip stack trace if already locked. 323 324 // Jump to the traceback function in runtime/cgo. 325 // It will call back to sigprofNonGo, which will ignore the 326 // arguments passed in registers. 327 // First three arguments to traceback function are in registers already. 328 MOVQ runtime·cgoTraceback(SB), CX 329 MOVQ $runtime·sigprofCallers(SB), R8 330 MOVQ $runtime·sigprofNonGo(SB), R9 331 MOVQ _cgo_callers(SB), AX 332 JMP AX 333 334 TEXT runtime·mmap(SB),NOSPLIT,$0 335 MOVQ addr+0(FP), DI // arg 1 addr 336 MOVQ n+8(FP), SI // arg 2 len 337 MOVL prot+16(FP), DX // arg 3 prot 338 MOVL flags+20(FP), R10 // arg 4 flags 339 MOVL fd+24(FP), R8 // arg 5 fid 340 MOVL off+28(FP), R9 // arg 6 offset 341 MOVL $477, AX 342 SYSCALL 343 JCC ok 344 MOVQ $0, p+32(FP) 345 MOVQ AX, err+40(FP) 346 RET 347 ok: 348 MOVQ AX, p+32(FP) 349 MOVQ $0, err+40(FP) 350 RET 351 352 TEXT runtime·munmap(SB),NOSPLIT,$0 353 MOVQ addr+0(FP), DI // arg 1 addr 354 MOVQ n+8(FP), SI // arg 2 len 355 MOVL $73, AX 356 SYSCALL 357 JCC 2(PC) 358 MOVL $0xf1, 0xf1 // crash 359 RET 360 361 TEXT runtime·madvise(SB),NOSPLIT,$0 362 MOVQ addr+0(FP), DI 363 MOVQ n+8(FP), SI 364 MOVL flags+16(FP), DX 365 MOVQ $75, AX // madvise 366 SYSCALL 367 JCC 2(PC) 368 MOVL $-1, AX 369 MOVL AX, ret+24(FP) 370 RET 371 372 TEXT runtime·sigaltstack(SB),NOSPLIT,$-8 373 MOVQ new+0(FP), DI 374 MOVQ old+8(FP), SI 375 MOVQ $53, AX 376 SYSCALL 377 JCC 2(PC) 378 MOVL $0xf1, 0xf1 // crash 379 RET 380 381 TEXT runtime·usleep(SB),NOSPLIT,$16 382 MOVL $0, DX 383 MOVL usec+0(FP), AX 384 MOVL $1000000, CX 385 DIVL CX 386 MOVQ AX, 0(SP) // tv_sec 387 MOVL $1000, AX 388 MULL DX 389 MOVQ AX, 8(SP) // tv_nsec 390 391 MOVQ SP, DI // arg 1 - rqtp 392 MOVQ $0, SI // arg 2 - rmtp 393 MOVL $240, AX // sys_nanosleep 394 SYSCALL 395 RET 396 397 // set tls base to DI 398 TEXT runtime·settls(SB),NOSPLIT,$8 399 ADDQ $8, DI // adjust for ELF: wants to use -8(FS) for g and m 400 MOVQ DI, 0(SP) 401 MOVQ SP, SI 402 MOVQ $129, DI // AMD64_SET_FSBASE 403 MOVQ $165, AX // sysarch 404 SYSCALL 405 JCC 2(PC) 406 MOVL $0xf1, 0xf1 // crash 407 RET 408 409 TEXT runtime·sysctl(SB),NOSPLIT,$0 410 MOVQ mib+0(FP), DI // arg 1 - name 411 MOVL miblen+8(FP), SI // arg 2 - namelen 412 MOVQ out+16(FP), DX // arg 3 - oldp 413 MOVQ size+24(FP), R10 // arg 4 - oldlenp 414 MOVQ dst+32(FP), R8 // arg 5 - newp 415 MOVQ ndst+40(FP), R9 // arg 6 - newlen 416 MOVQ $202, AX // sys___sysctl 417 SYSCALL 418 JCC 4(PC) 419 NEGQ AX 420 MOVL AX, ret+48(FP) 421 RET 422 MOVL $0, AX 423 MOVL AX, ret+48(FP) 424 RET 425 426 TEXT runtime·osyield(SB),NOSPLIT,$-4 427 MOVL $331, AX // sys_sched_yield 428 SYSCALL 429 RET 430 431 TEXT runtime·sigprocmask(SB),NOSPLIT,$0 432 MOVL how+0(FP), DI // arg 1 - how 433 MOVQ new+8(FP), SI // arg 2 - set 434 MOVQ old+16(FP), DX // arg 3 - oset 435 MOVL $340, AX // sys_sigprocmask 436 SYSCALL 437 JAE 2(PC) 438 MOVL $0xf1, 0xf1 // crash 439 RET 440 441 // int32 runtime·kqueue(void); 442 TEXT runtime·kqueue(SB),NOSPLIT,$0 443 MOVQ $0, DI 444 MOVQ $0, SI 445 MOVQ $0, DX 446 MOVL $362, AX 447 SYSCALL 448 JCC 2(PC) 449 NEGQ AX 450 MOVL AX, ret+0(FP) 451 RET 452 453 // int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout); 454 TEXT runtime·kevent(SB),NOSPLIT,$0 455 MOVL kq+0(FP), DI 456 MOVQ ch+8(FP), SI 457 MOVL nch+16(FP), DX 458 MOVQ ev+24(FP), R10 459 MOVL nev+32(FP), R8 460 MOVQ ts+40(FP), R9 461 MOVL $363, AX 462 SYSCALL 463 JCC 2(PC) 464 NEGQ AX 465 MOVL AX, ret+48(FP) 466 RET 467 468 // void runtime·closeonexec(int32 fd); 469 TEXT runtime·closeonexec(SB),NOSPLIT,$0 470 MOVL fd+0(FP), DI // fd 471 MOVQ $2, SI // F_SETFD 472 MOVQ $1, DX // FD_CLOEXEC 473 MOVL $92, AX // fcntl 474 SYSCALL 475 RET 476 477 // func runtime·setNonblock(int32 fd) 478 TEXT runtime·setNonblock(SB),NOSPLIT,$0-4 479 MOVL fd+0(FP), DI // fd 480 MOVQ $3, SI // F_GETFL 481 MOVQ $0, DX 482 MOVL $92, AX // fcntl 483 SYSCALL 484 MOVL fd+0(FP), DI // fd 485 MOVQ $4, SI // F_SETFL 486 MOVQ $4, DX // O_NONBLOCK 487 ORL AX, DX 488 MOVL $92, AX // fcntl 489 SYSCALL 490 RET 491 492 // func cpuset_getaffinity(level int, which int, id int64, size int, mask *byte) int32 493 TEXT runtime·cpuset_getaffinity(SB), NOSPLIT, $0-44 494 MOVQ level+0(FP), DI 495 MOVQ which+8(FP), SI 496 MOVQ id+16(FP), DX 497 MOVQ size+24(FP), R10 498 MOVQ mask+32(FP), R8 499 MOVL $487, AX 500 SYSCALL 501 JCC 2(PC) 502 NEGQ AX 503 MOVL AX, ret+40(FP) 504 RET