github.com/m10x/go/src@v0.0.0-20220112094212-ba61592315da/runtime/sys_freebsd_386.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 386, 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,$-4 14 MOVL $454, AX 15 INT $0x80 16 JAE 2(PC) 17 NEGL AX 18 MOVL AX, ret+20(FP) 19 RET 20 21 TEXT runtime·thr_new(SB),NOSPLIT,$-4 22 MOVL $455, AX 23 INT $0x80 24 JAE 2(PC) 25 NEGL AX 26 MOVL AX, ret+8(FP) 27 RET 28 29 // Called by OS using C ABI. 30 TEXT runtime·thr_start(SB),NOSPLIT,$0 31 NOP SP // tell vet SP changed - stop checking offsets 32 MOVL 4(SP), AX // m 33 MOVL m_g0(AX), BX 34 LEAL m_tls(AX), BP 35 MOVL m_id(AX), DI 36 ADDL $7, DI 37 PUSHAL 38 PUSHL $32 39 PUSHL BP 40 PUSHL DI 41 CALL runtime·setldt(SB) 42 POPL AX 43 POPL AX 44 POPL AX 45 POPAL 46 get_tls(CX) 47 MOVL BX, g(CX) 48 49 MOVL AX, g_m(BX) 50 CALL runtime·stackcheck(SB) // smashes AX 51 CALL runtime·mstart(SB) 52 53 MOVL 0, AX // crash (not reached) 54 55 // Exit the entire program (like C exit) 56 TEXT runtime·exit(SB),NOSPLIT,$-4 57 MOVL $1, AX 58 INT $0x80 59 MOVL $0xf1, 0xf1 // crash 60 RET 61 62 GLOBL exitStack<>(SB),RODATA,$8 63 DATA exitStack<>+0x00(SB)/4, $0 64 DATA exitStack<>+0x04(SB)/4, $0 65 66 // func exitThread(wait *uint32) 67 TEXT runtime·exitThread(SB),NOSPLIT,$0-4 68 MOVL wait+0(FP), AX 69 // We're done using the stack. 70 MOVL $0, (AX) 71 // thr_exit takes a single pointer argument, which it expects 72 // on the stack. We want to pass 0, so switch over to a fake 73 // stack of 0s. It won't write to the stack. 74 MOVL $exitStack<>(SB), SP 75 MOVL $431, AX // thr_exit 76 INT $0x80 77 MOVL $0xf1, 0xf1 // crash 78 JMP 0(PC) 79 80 TEXT runtime·open(SB),NOSPLIT,$-4 81 MOVL $5, AX 82 INT $0x80 83 JAE 2(PC) 84 MOVL $-1, AX 85 MOVL AX, ret+12(FP) 86 RET 87 88 TEXT runtime·closefd(SB),NOSPLIT,$-4 89 MOVL $6, AX 90 INT $0x80 91 JAE 2(PC) 92 MOVL $-1, AX 93 MOVL AX, ret+4(FP) 94 RET 95 96 TEXT runtime·read(SB),NOSPLIT,$-4 97 MOVL $3, AX 98 INT $0x80 99 JAE 2(PC) 100 NEGL AX // caller expects negative errno 101 MOVL AX, ret+12(FP) 102 RET 103 104 // func pipe() (r, w int32, errno int32) 105 TEXT runtime·pipe(SB),NOSPLIT,$8-12 106 MOVL $42, AX 107 INT $0x80 108 JAE 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,$12-16 121 MOVL $542, AX 122 LEAL r+4(FP), BX 123 MOVL BX, 4(SP) 124 MOVL flags+0(FP), BX 125 MOVL BX, 8(SP) 126 INT $0x80 127 JAE 2(PC) 128 NEGL AX 129 MOVL AX, errno+12(FP) 130 RET 131 132 TEXT runtime·write1(SB),NOSPLIT,$-4 133 MOVL $4, AX 134 INT $0x80 135 JAE 2(PC) 136 NEGL AX // caller expects negative errno 137 MOVL AX, ret+12(FP) 138 RET 139 140 TEXT runtime·thr_self(SB),NOSPLIT,$8-4 141 // thr_self(&0(FP)) 142 LEAL ret+0(FP), AX 143 MOVL AX, 4(SP) 144 MOVL $432, AX 145 INT $0x80 146 RET 147 148 TEXT runtime·thr_kill(SB),NOSPLIT,$-4 149 // thr_kill(tid, sig) 150 MOVL $433, AX 151 INT $0x80 152 RET 153 154 TEXT runtime·raiseproc(SB),NOSPLIT,$16 155 // getpid 156 MOVL $20, AX 157 INT $0x80 158 // kill(self, sig) 159 MOVL AX, 4(SP) 160 MOVL sig+0(FP), AX 161 MOVL AX, 8(SP) 162 MOVL $37, AX 163 INT $0x80 164 RET 165 166 TEXT runtime·mmap(SB),NOSPLIT,$32 167 LEAL addr+0(FP), SI 168 LEAL 4(SP), DI 169 CLD 170 MOVSL 171 MOVSL 172 MOVSL 173 MOVSL 174 MOVSL 175 MOVSL 176 MOVL $0, AX // top 32 bits of file offset 177 STOSL 178 MOVL $477, AX 179 INT $0x80 180 JAE ok 181 MOVL $0, p+24(FP) 182 MOVL AX, err+28(FP) 183 RET 184 ok: 185 MOVL AX, p+24(FP) 186 MOVL $0, err+28(FP) 187 RET 188 189 TEXT runtime·munmap(SB),NOSPLIT,$-4 190 MOVL $73, AX 191 INT $0x80 192 JAE 2(PC) 193 MOVL $0xf1, 0xf1 // crash 194 RET 195 196 TEXT runtime·madvise(SB),NOSPLIT,$-4 197 MOVL $75, AX // madvise 198 INT $0x80 199 JAE 2(PC) 200 MOVL $-1, AX 201 MOVL AX, ret+12(FP) 202 RET 203 204 TEXT runtime·setitimer(SB), NOSPLIT, $-4 205 MOVL $83, AX 206 INT $0x80 207 RET 208 209 // func fallback_walltime() (sec int64, nsec int32) 210 TEXT runtime·fallback_walltime(SB), NOSPLIT, $32-12 211 MOVL $232, AX // clock_gettime 212 LEAL 12(SP), BX 213 MOVL $0, 4(SP) // CLOCK_REALTIME 214 MOVL BX, 8(SP) 215 INT $0x80 216 MOVL 12(SP), AX // sec 217 MOVL 16(SP), BX // nsec 218 219 // sec is in AX, nsec in BX 220 MOVL AX, sec_lo+0(FP) 221 MOVL $0, sec_hi+4(FP) 222 MOVL BX, nsec+8(FP) 223 RET 224 225 // func fallback_nanotime() int64 226 TEXT runtime·fallback_nanotime(SB), NOSPLIT, $32-8 227 MOVL $232, AX 228 LEAL 12(SP), BX 229 MOVL $4, 4(SP) // CLOCK_MONOTONIC 230 MOVL BX, 8(SP) 231 INT $0x80 232 MOVL 12(SP), AX // sec 233 MOVL 16(SP), BX // nsec 234 235 // sec is in AX, nsec in BX 236 // convert to DX:AX nsec 237 MOVL $1000000000, CX 238 MULL CX 239 ADDL BX, AX 240 ADCL $0, DX 241 242 MOVL AX, ret_lo+0(FP) 243 MOVL DX, ret_hi+4(FP) 244 RET 245 246 247 TEXT runtime·asmSigaction(SB),NOSPLIT,$-4 248 MOVL $416, AX 249 INT $0x80 250 MOVL AX, ret+12(FP) 251 RET 252 253 TEXT runtime·sigfwd(SB),NOSPLIT,$12-16 254 MOVL fn+0(FP), AX 255 MOVL sig+4(FP), BX 256 MOVL info+8(FP), CX 257 MOVL ctx+12(FP), DX 258 MOVL SP, SI 259 SUBL $32, SP 260 ANDL $~15, SP // align stack: handler might be a C function 261 MOVL BX, 0(SP) 262 MOVL CX, 4(SP) 263 MOVL DX, 8(SP) 264 MOVL SI, 12(SP) // save SI: handler might be a Go function 265 CALL AX 266 MOVL 12(SP), AX 267 MOVL AX, SP 268 RET 269 270 // Called by OS using C ABI. 271 TEXT runtime·sigtramp(SB),NOSPLIT,$12 272 NOP SP // tell vet SP changed - stop checking offsets 273 MOVL 16(SP), BX // signo 274 MOVL BX, 0(SP) 275 MOVL 20(SP), BX // info 276 MOVL BX, 4(SP) 277 MOVL 24(SP), BX // context 278 MOVL BX, 8(SP) 279 CALL runtime·sigtrampgo(SB) 280 281 // call sigreturn 282 MOVL 24(SP), AX // context 283 MOVL $0, 0(SP) // syscall gap 284 MOVL AX, 4(SP) 285 MOVL $417, AX // sigreturn(ucontext) 286 INT $0x80 287 MOVL $0xf1, 0xf1 // crash 288 RET 289 290 TEXT runtime·sigaltstack(SB),NOSPLIT,$0 291 MOVL $53, AX 292 INT $0x80 293 JAE 2(PC) 294 MOVL $0xf1, 0xf1 // crash 295 RET 296 297 TEXT runtime·usleep(SB),NOSPLIT,$20 298 MOVL $0, DX 299 MOVL usec+0(FP), AX 300 MOVL $1000000, CX 301 DIVL CX 302 MOVL AX, 12(SP) // tv_sec 303 MOVL $1000, AX 304 MULL DX 305 MOVL AX, 16(SP) // tv_nsec 306 307 MOVL $0, 0(SP) 308 LEAL 12(SP), AX 309 MOVL AX, 4(SP) // arg 1 - rqtp 310 MOVL $0, 8(SP) // arg 2 - rmtp 311 MOVL $240, AX // sys_nanosleep 312 INT $0x80 313 RET 314 315 /* 316 descriptor entry format for system call 317 is the native machine format, ugly as it is: 318 319 2-byte limit 320 3-byte base 321 1-byte: 0x80=present, 0x60=dpl<<5, 0x1F=type 322 1-byte: 0x80=limit is *4k, 0x40=32-bit operand size, 323 0x0F=4 more bits of limit 324 1 byte: 8 more bits of base 325 326 int i386_get_ldt(int, union ldt_entry *, int); 327 int i386_set_ldt(int, const union ldt_entry *, int); 328 329 */ 330 331 // setldt(int entry, int address, int limit) 332 TEXT runtime·setldt(SB),NOSPLIT,$32 333 MOVL base+4(FP), BX 334 // see comment in sys_linux_386.s; freebsd is similar 335 ADDL $0x4, BX 336 337 // set up data_desc 338 LEAL 16(SP), AX // struct data_desc 339 MOVL $0, 0(AX) 340 MOVL $0, 4(AX) 341 342 MOVW BX, 2(AX) 343 SHRL $16, BX 344 MOVB BX, 4(AX) 345 SHRL $8, BX 346 MOVB BX, 7(AX) 347 348 MOVW $0xffff, 0(AX) 349 MOVB $0xCF, 6(AX) // 32-bit operand, 4k limit unit, 4 more bits of limit 350 351 MOVB $0xF2, 5(AX) // r/w data descriptor, dpl=3, present 352 353 // call i386_set_ldt(entry, desc, 1) 354 MOVL $0xffffffff, 0(SP) // auto-allocate entry and return in AX 355 MOVL AX, 4(SP) 356 MOVL $1, 8(SP) 357 CALL i386_set_ldt<>(SB) 358 359 // compute segment selector - (entry*8+7) 360 SHLL $3, AX 361 ADDL $7, AX 362 MOVW AX, GS 363 RET 364 365 TEXT i386_set_ldt<>(SB),NOSPLIT,$16 366 LEAL args+0(FP), AX // 0(FP) == 4(SP) before SP got moved 367 MOVL $0, 0(SP) // syscall gap 368 MOVL $1, 4(SP) 369 MOVL AX, 8(SP) 370 MOVL $165, AX 371 INT $0x80 372 JAE 2(PC) 373 INT $3 374 RET 375 376 TEXT runtime·sysctl(SB),NOSPLIT,$28 377 LEAL mib+0(FP), SI 378 LEAL 4(SP), DI 379 CLD 380 MOVSL // arg 1 - name 381 MOVSL // arg 2 - namelen 382 MOVSL // arg 3 - oldp 383 MOVSL // arg 4 - oldlenp 384 MOVSL // arg 5 - newp 385 MOVSL // arg 6 - newlen 386 MOVL $202, AX // sys___sysctl 387 INT $0x80 388 JAE 4(PC) 389 NEGL AX 390 MOVL AX, ret+24(FP) 391 RET 392 MOVL $0, AX 393 MOVL AX, ret+24(FP) 394 RET 395 396 TEXT runtime·osyield(SB),NOSPLIT,$-4 397 MOVL $331, AX // sys_sched_yield 398 INT $0x80 399 RET 400 401 TEXT runtime·sigprocmask(SB),NOSPLIT,$16 402 MOVL $0, 0(SP) // syscall gap 403 MOVL how+0(FP), AX // arg 1 - how 404 MOVL AX, 4(SP) 405 MOVL new+4(FP), AX 406 MOVL AX, 8(SP) // arg 2 - set 407 MOVL old+8(FP), AX 408 MOVL AX, 12(SP) // arg 3 - oset 409 MOVL $340, AX // sys_sigprocmask 410 INT $0x80 411 JAE 2(PC) 412 MOVL $0xf1, 0xf1 // crash 413 RET 414 415 // int32 runtime·kqueue(void); 416 TEXT runtime·kqueue(SB),NOSPLIT,$0 417 MOVL $362, AX 418 INT $0x80 419 JAE 2(PC) 420 NEGL AX 421 MOVL AX, ret+0(FP) 422 RET 423 424 // int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout); 425 TEXT runtime·kevent(SB),NOSPLIT,$0 426 MOVL $363, AX 427 INT $0x80 428 JAE 2(PC) 429 NEGL AX 430 MOVL AX, ret+24(FP) 431 RET 432 433 // int32 runtime·closeonexec(int32 fd); 434 TEXT runtime·closeonexec(SB),NOSPLIT,$32 435 MOVL $92, AX // fcntl 436 // 0(SP) is where the caller PC would be; kernel skips it 437 MOVL fd+0(FP), BX 438 MOVL BX, 4(SP) // fd 439 MOVL $2, 8(SP) // F_SETFD 440 MOVL $1, 12(SP) // FD_CLOEXEC 441 INT $0x80 442 JAE 2(PC) 443 NEGL AX 444 RET 445 446 // func runtime·setNonblock(fd int32) 447 TEXT runtime·setNonblock(SB),NOSPLIT,$16-4 448 MOVL $92, AX // fcntl 449 MOVL fd+0(FP), BX // fd 450 MOVL BX, 4(SP) 451 MOVL $3, 8(SP) // F_GETFL 452 MOVL $0, 12(SP) 453 INT $0x80 454 MOVL fd+0(FP), BX // fd 455 MOVL BX, 4(SP) 456 MOVL $4, 8(SP) // F_SETFL 457 ORL $4, AX // O_NONBLOCK 458 MOVL AX, 12(SP) 459 MOVL $92, AX // fcntl 460 INT $0x80 461 RET 462 463 // func cpuset_getaffinity(level int, which int, id int64, size int, mask *byte) int32 464 TEXT runtime·cpuset_getaffinity(SB), NOSPLIT, $0-28 465 MOVL $487, AX 466 INT $0x80 467 JAE 2(PC) 468 NEGL AX 469 MOVL AX, ret+24(FP) 470 RET 471 472 GLOBL runtime·tlsoffset(SB),NOPTR,$4