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