github.com/gidoBOSSftw5731/go/src@v0.0.0-20210226122457-d24b0edbf019/runtime/sys_windows_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 #include "go_asm.h" 6 #include "go_tls.h" 7 #include "textflag.h" 8 9 // void runtime·asmstdcall(void *c); 10 TEXT runtime·asmstdcall(SB),NOSPLIT,$0 11 MOVL fn+0(FP), BX 12 13 // SetLastError(0). 14 MOVL $0, 0x34(FS) 15 16 // Copy args to the stack. 17 MOVL SP, BP 18 MOVL libcall_n(BX), CX // words 19 MOVL CX, AX 20 SALL $2, AX 21 SUBL AX, SP // room for args 22 MOVL SP, DI 23 MOVL libcall_args(BX), SI 24 CLD 25 REP; MOVSL 26 27 // Call stdcall or cdecl function. 28 // DI SI BP BX are preserved, SP is not 29 CALL libcall_fn(BX) 30 MOVL BP, SP 31 32 // Return result. 33 MOVL fn+0(FP), BX 34 MOVL AX, libcall_r1(BX) 35 MOVL DX, libcall_r2(BX) 36 37 // GetLastError(). 38 MOVL 0x34(FS), AX 39 MOVL AX, libcall_err(BX) 40 41 RET 42 43 TEXT runtime·badsignal2(SB),NOSPLIT,$24 44 // stderr 45 MOVL $-12, 0(SP) 46 MOVL SP, BP 47 CALL *runtime·_GetStdHandle(SB) 48 MOVL BP, SP 49 50 MOVL AX, 0(SP) // handle 51 MOVL $runtime·badsignalmsg(SB), DX // pointer 52 MOVL DX, 4(SP) 53 MOVL runtime·badsignallen(SB), DX // count 54 MOVL DX, 8(SP) 55 LEAL 20(SP), DX // written count 56 MOVL $0, 0(DX) 57 MOVL DX, 12(SP) 58 MOVL $0, 16(SP) // overlapped 59 CALL *runtime·_WriteFile(SB) 60 MOVL BP, SI 61 RET 62 63 // faster get/set last error 64 TEXT runtime·getlasterror(SB),NOSPLIT,$0 65 MOVL 0x34(FS), AX 66 MOVL AX, ret+0(FP) 67 RET 68 69 // Called by Windows as a Vectored Exception Handler (VEH). 70 // First argument is pointer to struct containing 71 // exception record and context pointers. 72 // Handler function is stored in AX. 73 // Return 0 for 'not handled', -1 for handled. 74 TEXT sigtramp<>(SB),NOSPLIT,$0-0 75 MOVL ptrs+0(FP), CX 76 SUBL $40, SP 77 78 // save callee-saved registers 79 MOVL BX, 28(SP) 80 MOVL BP, 16(SP) 81 MOVL SI, 20(SP) 82 MOVL DI, 24(SP) 83 84 MOVL AX, SI // save handler address 85 86 // find g 87 get_tls(DX) 88 CMPL DX, $0 89 JNE 3(PC) 90 MOVL $0, AX // continue 91 JMP done 92 MOVL g(DX), DX 93 CMPL DX, $0 94 JNE 2(PC) 95 CALL runtime·badsignal2(SB) 96 97 // save g in case of stack switch 98 MOVL DX, 32(SP) // g 99 MOVL SP, 36(SP) 100 101 // do we need to switch to the g0 stack? 102 MOVL g_m(DX), BX 103 MOVL m_g0(BX), BX 104 CMPL DX, BX 105 JEQ g0 106 107 // switch to the g0 stack 108 get_tls(BP) 109 MOVL BX, g(BP) 110 MOVL (g_sched+gobuf_sp)(BX), DI 111 // make room for sighandler arguments 112 // and re-save old SP for restoring later. 113 // (note that the 36(DI) here must match the 36(SP) above.) 114 SUBL $40, DI 115 MOVL SP, 36(DI) 116 MOVL DI, SP 117 118 g0: 119 MOVL 0(CX), BX // ExceptionRecord* 120 MOVL 4(CX), CX // Context* 121 MOVL BX, 0(SP) 122 MOVL CX, 4(SP) 123 MOVL DX, 8(SP) 124 CALL SI // call handler 125 // AX is set to report result back to Windows 126 MOVL 12(SP), AX 127 128 // switch back to original stack and g 129 // no-op if we never left. 130 MOVL 36(SP), SP 131 MOVL 32(SP), DX // note: different SP 132 get_tls(BP) 133 MOVL DX, g(BP) 134 135 done: 136 // restore callee-saved registers 137 MOVL 24(SP), DI 138 MOVL 20(SP), SI 139 MOVL 16(SP), BP 140 MOVL 28(SP), BX 141 142 ADDL $40, SP 143 // RET 4 (return and pop 4 bytes parameters) 144 BYTE $0xC2; WORD $4 145 RET // unreached; make assembler happy 146 147 TEXT runtime·exceptiontramp(SB),NOSPLIT,$0 148 MOVL $runtime·exceptionhandler(SB), AX 149 JMP sigtramp<>(SB) 150 151 TEXT runtime·firstcontinuetramp(SB),NOSPLIT,$0-0 152 // is never called 153 INT $3 154 155 TEXT runtime·lastcontinuetramp(SB),NOSPLIT,$0-0 156 MOVL $runtime·lastcontinuehandler(SB), AX 157 JMP sigtramp<>(SB) 158 159 // Called by OS using stdcall ABI: bool ctrlhandler(uint32). 160 TEXT runtime·ctrlhandler(SB),NOSPLIT,$0 161 PUSHL $runtime·ctrlhandler1(SB) 162 NOP SP // tell vet SP changed - stop checking offsets 163 CALL runtime·externalthreadhandler(SB) 164 MOVL 4(SP), CX 165 ADDL $12, SP 166 JMP CX 167 168 // Called by OS using stdcall ABI: uint32 profileloop(void*). 169 TEXT runtime·profileloop(SB),NOSPLIT,$0 170 PUSHL $runtime·profileloop1(SB) 171 NOP SP // tell vet SP changed - stop checking offsets 172 CALL runtime·externalthreadhandler(SB) 173 MOVL 4(SP), CX 174 ADDL $12, SP 175 JMP CX 176 177 TEXT runtime·externalthreadhandler(SB),NOSPLIT|TOPFRAME,$0 178 PUSHL BP 179 MOVL SP, BP 180 PUSHL BX 181 PUSHL SI 182 PUSHL DI 183 PUSHL 0x14(FS) 184 MOVL SP, DX 185 186 // setup dummy m, g 187 SUBL $m__size, SP // space for M 188 MOVL SP, 0(SP) 189 MOVL $m__size, 4(SP) 190 CALL runtime·memclrNoHeapPointers(SB) // smashes AX,BX,CX 191 192 LEAL m_tls(SP), CX 193 MOVL CX, 0x14(FS) 194 MOVL SP, BX 195 SUBL $g__size, SP // space for G 196 MOVL SP, g(CX) 197 MOVL SP, m_g0(BX) 198 199 MOVL SP, 0(SP) 200 MOVL $g__size, 4(SP) 201 CALL runtime·memclrNoHeapPointers(SB) // smashes AX,BX,CX 202 LEAL g__size(SP), BX 203 MOVL BX, g_m(SP) 204 205 LEAL -32768(SP), CX // must be less than SizeOfStackReserve set by linker 206 MOVL CX, (g_stack+stack_lo)(SP) 207 ADDL $const__StackGuard, CX 208 MOVL CX, g_stackguard0(SP) 209 MOVL CX, g_stackguard1(SP) 210 MOVL DX, (g_stack+stack_hi)(SP) 211 212 PUSHL AX // room for return value 213 PUSHL 16(BP) // arg for handler 214 CALL 8(BP) 215 POPL CX 216 POPL AX // pass return value to Windows in AX 217 218 get_tls(CX) 219 MOVL g(CX), CX 220 MOVL (g_stack+stack_hi)(CX), SP 221 POPL 0x14(FS) 222 POPL DI 223 POPL SI 224 POPL BX 225 POPL BP 226 RET 227 228 GLOBL runtime·cbctxts(SB), NOPTR, $4 229 230 TEXT runtime·callbackasm1(SB),NOSPLIT,$0 231 MOVL 0(SP), AX // will use to find our callback context 232 233 // remove return address from stack, we are not returning to callbackasm, but to its caller. 234 ADDL $4, SP 235 236 // address to callback parameters into CX 237 LEAL 4(SP), CX 238 239 // save registers as required for windows callback 240 PUSHL DI 241 PUSHL SI 242 PUSHL BP 243 PUSHL BX 244 245 // Go ABI requires DF flag to be cleared. 246 CLD 247 248 // determine index into runtime·cbs table 249 SUBL $runtime·callbackasm(SB), AX 250 MOVL $0, DX 251 MOVL $5, BX // divide by 5 because each call instruction in runtime·callbacks is 5 bytes long 252 DIVL BX 253 SUBL $1, AX // subtract 1 because return PC is to the next slot 254 255 // Create a struct callbackArgs on our stack. 256 SUBL $(12+callbackArgs__size), SP 257 MOVL AX, (12+callbackArgs_index)(SP) // callback index 258 MOVL CX, (12+callbackArgs_args)(SP) // address of args vector 259 MOVL $0, (12+callbackArgs_result)(SP) // result 260 LEAL 12(SP), AX // AX = &callbackArgs{...} 261 262 // Call cgocallback, which will call callbackWrap(frame). 263 MOVL $0, 8(SP) // context 264 MOVL AX, 4(SP) // frame (address of callbackArgs) 265 LEAL ·callbackWrap(SB), AX 266 MOVL AX, 0(SP) // PC of function to call 267 CALL runtime·cgocallback(SB) 268 269 // Get callback result. 270 MOVL (12+callbackArgs_result)(SP), AX 271 // Get popRet. 272 MOVL (12+callbackArgs_retPop)(SP), CX // Can't use a callee-save register 273 ADDL $(12+callbackArgs__size), SP 274 275 // restore registers as required for windows callback 276 POPL BX 277 POPL BP 278 POPL SI 279 POPL DI 280 281 // remove callback parameters before return (as per Windows spec) 282 POPL DX 283 ADDL CX, SP 284 PUSHL DX 285 286 CLD 287 288 RET 289 290 // void tstart(M *newm); 291 TEXT tstart<>(SB),NOSPLIT,$0 292 MOVL newm+0(FP), CX // m 293 MOVL m_g0(CX), DX // g 294 295 // Layout new m scheduler stack on os stack. 296 MOVL SP, AX 297 MOVL AX, (g_stack+stack_hi)(DX) 298 SUBL $(64*1024), AX // initial stack size (adjusted later) 299 MOVL AX, (g_stack+stack_lo)(DX) 300 ADDL $const__StackGuard, AX 301 MOVL AX, g_stackguard0(DX) 302 MOVL AX, g_stackguard1(DX) 303 304 // Set up tls. 305 LEAL m_tls(CX), SI 306 MOVL SI, 0x14(FS) 307 MOVL CX, g_m(DX) 308 MOVL DX, g(SI) 309 310 // Someday the convention will be D is always cleared. 311 CLD 312 313 CALL runtime·stackcheck(SB) // clobbers AX,CX 314 CALL runtime·mstart(SB) 315 316 RET 317 318 // uint32 tstart_stdcall(M *newm); 319 TEXT runtime·tstart_stdcall(SB),NOSPLIT,$0 320 MOVL newm+0(FP), BX 321 322 PUSHL BX 323 CALL tstart<>(SB) 324 POPL BX 325 326 // Adjust stack for stdcall to return properly. 327 MOVL (SP), AX // save return address 328 ADDL $4, SP // remove single parameter 329 MOVL AX, (SP) // restore return address 330 331 XORL AX, AX // return 0 == success 332 333 RET 334 335 // setldt(int entry, int address, int limit) 336 TEXT runtime·setldt(SB),NOSPLIT,$0 337 MOVL base+4(FP), CX 338 MOVL CX, 0x14(FS) 339 RET 340 341 // Runs on OS stack. 342 // duration (in -100ns units) is in dt+0(FP). 343 // g may be nil. 344 TEXT runtime·usleep2(SB),NOSPLIT,$20-4 345 MOVL dt+0(FP), BX 346 MOVL $-1, hi-4(SP) 347 MOVL BX, lo-8(SP) 348 LEAL lo-8(SP), BX 349 MOVL BX, ptime-12(SP) 350 MOVL $0, alertable-16(SP) 351 MOVL $-1, handle-20(SP) 352 MOVL SP, BP 353 MOVL runtime·_NtWaitForSingleObject(SB), AX 354 CALL AX 355 MOVL BP, SP 356 RET 357 358 // Runs on OS stack. 359 // duration (in -100ns units) is in dt+0(FP). 360 // g is valid. 361 TEXT runtime·usleep2HighRes(SB),NOSPLIT,$36-4 362 MOVL dt+0(FP), BX 363 MOVL $-1, hi-4(SP) 364 MOVL BX, lo-8(SP) 365 366 get_tls(CX) 367 MOVL g(CX), CX 368 MOVL g_m(CX), CX 369 MOVL (m_mOS+mOS_highResTimer)(CX), CX 370 MOVL CX, saved_timer-12(SP) 371 372 MOVL $0, fResume-16(SP) 373 MOVL $0, lpArgToCompletionRoutine-20(SP) 374 MOVL $0, pfnCompletionRoutine-24(SP) 375 MOVL $0, lPeriod-28(SP) 376 LEAL lo-8(SP), BX 377 MOVL BX, lpDueTime-32(SP) 378 MOVL CX, hTimer-36(SP) 379 MOVL SP, BP 380 MOVL runtime·_SetWaitableTimer(SB), AX 381 CALL AX 382 MOVL BP, SP 383 384 MOVL $0, ptime-28(SP) 385 MOVL $0, alertable-32(SP) 386 MOVL saved_timer-12(SP), CX 387 MOVL CX, handle-36(SP) 388 MOVL SP, BP 389 MOVL runtime·_NtWaitForSingleObject(SB), AX 390 CALL AX 391 MOVL BP, SP 392 393 RET 394 395 // Runs on OS stack. 396 TEXT runtime·switchtothread(SB),NOSPLIT,$0 397 MOVL SP, BP 398 MOVL runtime·_SwitchToThread(SB), AX 399 CALL AX 400 MOVL BP, SP 401 RET 402 403 // See https://www.dcl.hpi.uni-potsdam.de/research/WRK/2007/08/getting-os-information-the-kuser_shared_data-structure/ 404 // Must read hi1, then lo, then hi2. The snapshot is valid if hi1 == hi2. 405 #define _INTERRUPT_TIME 0x7ffe0008 406 #define _SYSTEM_TIME 0x7ffe0014 407 #define time_lo 0 408 #define time_hi1 4 409 #define time_hi2 8 410 411 TEXT runtime·nanotime1(SB),NOSPLIT,$0-8 412 CMPB runtime·useQPCTime(SB), $0 413 JNE useQPC 414 loop: 415 MOVL (_INTERRUPT_TIME+time_hi1), AX 416 MOVL (_INTERRUPT_TIME+time_lo), CX 417 MOVL (_INTERRUPT_TIME+time_hi2), DI 418 CMPL AX, DI 419 JNE loop 420 421 // wintime = DI:CX, multiply by 100 422 MOVL $100, AX 423 MULL CX 424 IMULL $100, DI 425 ADDL DI, DX 426 // wintime*100 = DX:AX 427 MOVL AX, ret_lo+0(FP) 428 MOVL DX, ret_hi+4(FP) 429 RET 430 useQPC: 431 JMP runtime·nanotimeQPC(SB) 432 RET 433 434 TEXT time·now(SB),NOSPLIT,$0-20 435 CMPB runtime·useQPCTime(SB), $0 436 JNE useQPC 437 loop: 438 MOVL (_INTERRUPT_TIME+time_hi1), AX 439 MOVL (_INTERRUPT_TIME+time_lo), CX 440 MOVL (_INTERRUPT_TIME+time_hi2), DI 441 CMPL AX, DI 442 JNE loop 443 444 // w = DI:CX 445 // multiply by 100 446 MOVL $100, AX 447 MULL CX 448 IMULL $100, DI 449 ADDL DI, DX 450 // w*100 = DX:AX 451 MOVL AX, mono+12(FP) 452 MOVL DX, mono+16(FP) 453 454 wall: 455 MOVL (_SYSTEM_TIME+time_hi1), CX 456 MOVL (_SYSTEM_TIME+time_lo), AX 457 MOVL (_SYSTEM_TIME+time_hi2), DX 458 CMPL CX, DX 459 JNE wall 460 461 // w = DX:AX 462 // convert to Unix epoch (but still 100ns units) 463 #define delta 116444736000000000 464 SUBL $(delta & 0xFFFFFFFF), AX 465 SBBL $(delta >> 32), DX 466 467 // nano/100 = DX:AX 468 // split into two decimal halves by div 1e9. 469 // (decimal point is two spots over from correct place, 470 // but we avoid overflow in the high word.) 471 MOVL $1000000000, CX 472 DIVL CX 473 MOVL AX, DI 474 MOVL DX, SI 475 476 // DI = nano/100/1e9 = nano/1e11 = sec/100, DX = SI = nano/100%1e9 477 // split DX into seconds and nanoseconds by div 1e7 magic multiply. 478 MOVL DX, AX 479 MOVL $1801439851, CX 480 MULL CX 481 SHRL $22, DX 482 MOVL DX, BX 483 IMULL $10000000, DX 484 MOVL SI, CX 485 SUBL DX, CX 486 487 // DI = sec/100 (still) 488 // BX = (nano/100%1e9)/1e7 = (nano/1e9)%100 = sec%100 489 // CX = (nano/100%1e9)%1e7 = (nano%1e9)/100 = nsec/100 490 // store nsec for return 491 IMULL $100, CX 492 MOVL CX, nsec+8(FP) 493 494 // DI = sec/100 (still) 495 // BX = sec%100 496 // construct DX:AX = 64-bit sec and store for return 497 MOVL $0, DX 498 MOVL $100, AX 499 MULL DI 500 ADDL BX, AX 501 ADCL $0, DX 502 MOVL AX, sec+0(FP) 503 MOVL DX, sec+4(FP) 504 RET 505 useQPC: 506 JMP runtime·nowQPC(SB) 507 RET