github.com/varialus/godfly@v0.0.0-20130904042352-1934f9f095ab/src/pkg/runtime/sys_openbsd_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, OpenBSD 6 // /usr/src/sys/kern/syscalls.master for syscall numbers. 7 // 8 9 #include "zasm_GOOS_GOARCH.h" 10 #include "../../cmd/ld/textflag.h" 11 12 // Exit the entire program (like C exit) 13 TEXT runtime·exit(SB),NOSPLIT,$-4 14 MOVL $1, AX 15 INT $0x80 16 MOVL $0xf1, 0xf1 // crash 17 RET 18 19 TEXT runtime·exit1(SB),NOSPLIT,$8 20 MOVL $0, 0(SP) 21 MOVL $0, 4(SP) // arg 1 - notdead 22 MOVL $302, AX // sys___threxit 23 INT $0x80 24 JAE 2(PC) 25 MOVL $0xf1, 0xf1 // crash 26 RET 27 28 TEXT runtime·open(SB),NOSPLIT,$-4 29 MOVL $5, AX 30 INT $0x80 31 RET 32 33 TEXT runtime·close(SB),NOSPLIT,$-4 34 MOVL $6, AX 35 INT $0x80 36 RET 37 38 TEXT runtime·read(SB),NOSPLIT,$-4 39 MOVL $3, AX 40 INT $0x80 41 RET 42 43 TEXT runtime·write(SB),NOSPLIT,$-4 44 MOVL $4, AX // sys_write 45 INT $0x80 46 RET 47 48 TEXT runtime·usleep(SB),NOSPLIT,$20 49 MOVL $0, DX 50 MOVL usec+0(FP), AX 51 MOVL $1000000, CX 52 DIVL CX 53 MOVL AX, 12(SP) // tv_sec 54 MOVL $1000, AX 55 MULL DX 56 MOVL AX, 16(SP) // tv_nsec 57 58 MOVL $0, 0(SP) 59 LEAL 12(SP), AX 60 MOVL AX, 4(SP) // arg 1 - rqtp 61 MOVL $0, 8(SP) // arg 2 - rmtp 62 MOVL $240, AX // sys_nanosleep 63 INT $0x80 64 RET 65 66 TEXT runtime·raise(SB),NOSPLIT,$12 67 MOVL $299, AX // sys_getthrid 68 INT $0x80 69 MOVL $0, 0(SP) 70 MOVL AX, 4(SP) // arg 1 - pid 71 MOVL sig+0(FP), AX 72 MOVL AX, 8(SP) // arg 2 - signum 73 MOVL $37, AX // sys_kill 74 INT $0x80 75 RET 76 77 TEXT runtime·mmap(SB),NOSPLIT,$36 78 LEAL arg0+0(FP), SI 79 LEAL 4(SP), DI 80 CLD 81 MOVSL // arg 1 - addr 82 MOVSL // arg 2 - len 83 MOVSL // arg 3 - prot 84 MOVSL // arg 4 - flags 85 MOVSL // arg 5 - fd 86 MOVL $0, AX 87 STOSL // arg 6 - pad 88 MOVSL // arg 7 - offset 89 MOVL $0, AX // top 32 bits of file offset 90 STOSL 91 MOVL $197, AX // sys_mmap 92 INT $0x80 93 RET 94 95 TEXT runtime·munmap(SB),NOSPLIT,$-4 96 MOVL $73, AX // sys_munmap 97 INT $0x80 98 JAE 2(PC) 99 MOVL $0xf1, 0xf1 // crash 100 RET 101 102 TEXT runtime·madvise(SB),NOSPLIT,$-4 103 MOVL $75, AX // sys_madvise 104 INT $0x80 105 JAE 2(PC) 106 MOVL $0xf1, 0xf1 // crash 107 RET 108 109 TEXT runtime·setitimer(SB),NOSPLIT,$-4 110 MOVL $83, AX 111 INT $0x80 112 RET 113 114 // func now() (sec int64, nsec int32) 115 TEXT time·now(SB), NOSPLIT, $32 116 MOVL $232, AX 117 LEAL 12(SP), BX 118 MOVL $0, 4(SP) 119 MOVL BX, 8(SP) 120 INT $0x80 121 MOVL 12(SP), AX // sec 122 MOVL 16(SP), BX // nsec 123 124 // sec is in AX, nsec in BX 125 MOVL AX, sec+0(FP) 126 MOVL $0, sec+4(FP) 127 MOVL BX, nsec+8(FP) 128 RET 129 130 // int64 nanotime(void) so really 131 // void nanotime(int64 *nsec) 132 TEXT runtime·nanotime(SB),NOSPLIT,$32 133 MOVL $232, AX 134 LEAL 12(SP), BX 135 MOVL $0, 4(SP) 136 MOVL BX, 8(SP) 137 INT $0x80 138 MOVL 12(SP), AX // sec 139 MOVL 16(SP), BX // nsec 140 141 // sec is in AX, nsec in BX 142 // convert to DX:AX nsec 143 MOVL $1000000000, CX 144 MULL CX 145 ADDL BX, AX 146 ADCL $0, DX 147 148 MOVL ret+0(FP), DI 149 MOVL AX, 0(DI) 150 MOVL DX, 4(DI) 151 RET 152 153 TEXT runtime·sigaction(SB),NOSPLIT,$-4 154 MOVL $46, AX // sys_sigaction 155 INT $0x80 156 JAE 2(PC) 157 MOVL $0xf1, 0xf1 // crash 158 RET 159 160 TEXT runtime·sigprocmask(SB),NOSPLIT,$-4 161 MOVL $48, AX // sys_sigprocmask 162 INT $0x80 163 JAE 2(PC) 164 MOVL $0xf1, 0xf1 // crash 165 MOVL AX, oset+0(FP) 166 RET 167 168 TEXT runtime·sigtramp(SB),NOSPLIT,$44 169 get_tls(CX) 170 171 // check that m exists 172 MOVL m(CX), BX 173 CMPL BX, $0 174 JNE 6(PC) 175 MOVL signo+0(FP), BX 176 MOVL BX, 0(SP) 177 MOVL $runtime·badsignal(SB), AX 178 CALL AX 179 JMP sigtramp_ret 180 181 // save g 182 MOVL g(CX), DI 183 MOVL DI, 20(SP) 184 185 // g = m->gsignal 186 MOVL m_gsignal(BX), BX 187 MOVL BX, g(CX) 188 189 // copy arguments for call to sighandler 190 MOVL signo+0(FP), BX 191 MOVL BX, 0(SP) 192 MOVL info+4(FP), BX 193 MOVL BX, 4(SP) 194 MOVL context+8(FP), BX 195 MOVL BX, 8(SP) 196 MOVL DI, 12(SP) 197 198 CALL runtime·sighandler(SB) 199 200 // restore g 201 get_tls(CX) 202 MOVL 20(SP), BX 203 MOVL BX, g(CX) 204 205 sigtramp_ret: 206 // call sigreturn 207 MOVL context+8(FP), AX 208 MOVL $0, 0(SP) // syscall gap 209 MOVL AX, 4(SP) // arg 1 - sigcontext 210 MOVL $103, AX // sys_sigreturn 211 INT $0x80 212 MOVL $0xf1, 0xf1 // crash 213 RET 214 215 // int32 tfork(void *param, uintptr psize, M *mp, G *gp, void (*fn)(void)); 216 TEXT runtime·tfork(SB),NOSPLIT,$12 217 218 // Copy mp, gp and fn from the parent stack onto the child stack. 219 MOVL params+4(FP), AX 220 MOVL 8(AX), CX // tf_stack 221 SUBL $16, CX 222 MOVL CX, 8(AX) 223 MOVL mm+12(FP), SI 224 MOVL SI, 0(CX) 225 MOVL gg+16(FP), SI 226 MOVL SI, 4(CX) 227 MOVL fn+20(FP), SI 228 MOVL SI, 8(CX) 229 MOVL $1234, 12(CX) 230 231 MOVL $0, 0(SP) // syscall gap 232 MOVL params+4(FP), AX 233 MOVL AX, 4(SP) // arg 1 - param 234 MOVL psize+8(FP), AX 235 MOVL AX, 8(SP) // arg 2 - psize 236 MOVL $8, AX // sys___tfork 237 INT $0x80 238 239 // Return if tfork syscall failed. 240 JCC 5(PC) 241 NEGL AX 242 MOVL ret+0(FP), DX 243 MOVL AX, 0(DX) 244 RET 245 246 // In parent, return. 247 CMPL AX, $0 248 JEQ 4(PC) 249 MOVL ret+0(FP), DX 250 MOVL AX, 0(DX) 251 RET 252 253 // Paranoia: check that SP is as we expect. 254 MOVL 12(SP), BP 255 CMPL BP, $1234 256 JEQ 2(PC) 257 INT $3 258 259 // Reload registers. 260 MOVL 0(SP), BX // m 261 MOVL 4(SP), DX // g 262 MOVL 8(SP), SI // fn 263 264 // Set FS to point at m->tls. 265 LEAL m_tls(BX), BP 266 PUSHAL // save registers 267 PUSHL BP 268 CALL runtime·settls(SB) 269 POPL AX 270 POPAL 271 272 // Now segment is established. Initialize m, g. 273 get_tls(AX) 274 MOVL DX, g(AX) 275 MOVL BX, m(AX) 276 277 CALL runtime·stackcheck(SB) // smashes AX, CX 278 MOVL 0(DX), DX // paranoia; check they are not nil 279 MOVL 0(BX), BX 280 281 // More paranoia; check that stack splitting code works. 282 PUSHAL 283 CALL runtime·emptyfunc(SB) 284 POPAL 285 286 // Call fn. 287 CALL SI 288 289 CALL runtime·exit1(SB) 290 MOVL $0x1234, 0x1005 291 RET 292 293 TEXT runtime·sigaltstack(SB),NOSPLIT,$-8 294 MOVL $288, AX // sys_sigaltstack 295 MOVL new+4(SP), BX 296 MOVL old+8(SP), CX 297 INT $0x80 298 CMPL AX, $0xfffff001 299 JLS 2(PC) 300 INT $3 301 RET 302 303 TEXT runtime·setldt(SB),NOSPLIT,$4 304 // Under OpenBSD we set the GS base instead of messing with the LDT. 305 MOVL tls0+4(FP), AX 306 MOVL AX, 0(SP) 307 CALL runtime·settls(SB) 308 RET 309 310 TEXT runtime·settls(SB),NOSPLIT,$8 311 // adjust for ELF: wants to use -8(GS) and -4(GS) for g and m 312 MOVL tlsbase+0(FP), CX 313 ADDL $8, CX 314 MOVL $0, 0(SP) // syscall gap 315 MOVL CX, 4(SP) // arg 1 - tcb 316 MOVL $329, AX // sys___set_tcb 317 INT $0x80 318 JCC 2(PC) 319 MOVL $0xf1, 0xf1 // crash 320 RET 321 322 TEXT runtime·osyield(SB),NOSPLIT,$-4 323 MOVL $298, AX // sys_sched_yield 324 INT $0x80 325 RET 326 327 TEXT runtime·thrsleep(SB),NOSPLIT,$-4 328 MOVL $300, AX // sys___thrsleep 329 INT $0x80 330 RET 331 332 TEXT runtime·thrwakeup(SB),NOSPLIT,$-4 333 MOVL $301, AX // sys___thrwakeup 334 INT $0x80 335 RET 336 337 TEXT runtime·sysctl(SB),NOSPLIT,$28 338 LEAL arg0+0(FP), SI 339 LEAL 4(SP), DI 340 CLD 341 MOVSL // arg 1 - name 342 MOVSL // arg 2 - namelen 343 MOVSL // arg 3 - oldp 344 MOVSL // arg 4 - oldlenp 345 MOVSL // arg 5 - newp 346 MOVSL // arg 6 - newlen 347 MOVL $202, AX // sys___sysctl 348 INT $0x80 349 JCC 3(PC) 350 NEGL AX 351 RET 352 MOVL $0, AX 353 RET 354 355 // int32 runtime·kqueue(void); 356 TEXT runtime·kqueue(SB),NOSPLIT,$0 357 MOVL $269, AX 358 INT $0x80 359 JAE 2(PC) 360 NEGL AX 361 RET 362 363 // int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout); 364 TEXT runtime·kevent(SB),NOSPLIT,$0 365 MOVL $270, AX 366 INT $0x80 367 JAE 2(PC) 368 NEGL AX 369 RET 370 371 // int32 runtime·closeonexec(int32 fd); 372 TEXT runtime·closeonexec(SB),NOSPLIT,$32 373 MOVL $92, AX // fcntl 374 // 0(SP) is where the caller PC would be; kernel skips it 375 MOVL fd+0(FP), BX 376 MOVL BX, 4(SP) // fd 377 MOVL $2, 8(SP) // F_SETFD 378 MOVL $1, 12(SP) // FD_CLOEXEC 379 INT $0x80 380 JAE 2(PC) 381 NEGL AX 382 RET 383 384 GLOBL runtime·tlsoffset(SB),$4