Text file
src/runtime/sys_windows_amd64.s
Documentation: runtime
1 // Copyright 2011 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 // maxargs should be divisible by 2, as Windows stack
10 // must be kept 16-byte aligned on syscall entry.
11 #define maxargs 16
12
13 // void runtime·asmstdcall(void *c);
14 TEXT runtime·asmstdcall(SB),NOSPLIT|NOFRAME,$0
15 // asmcgocall will put first argument into CX.
16 PUSHQ CX // save for later
17 MOVQ libcall_fn(CX), AX
18 MOVQ libcall_args(CX), SI
19 MOVQ libcall_n(CX), CX
20
21 // SetLastError(0).
22 MOVQ 0x30(GS), DI
23 MOVL $0, 0x68(DI)
24
25 SUBQ $(maxargs*8), SP // room for args
26
27 // Fast version, do not store args on the stack.
28 CMPL CX, $4
29 JLE loadregs
30
31 // Check we have enough room for args.
32 CMPL CX, $maxargs
33 JLE 2(PC)
34 INT $3 // not enough room -> crash
35
36 // Copy args to the stack.
37 MOVQ SP, DI
38 CLD
39 REP; MOVSQ
40 MOVQ SP, SI
41
42 loadregs:
43 // Load first 4 args into correspondent registers.
44 MOVQ 0(SI), CX
45 MOVQ 8(SI), DX
46 MOVQ 16(SI), R8
47 MOVQ 24(SI), R9
48 // Floating point arguments are passed in the XMM
49 // registers. Set them here in case any of the arguments
50 // are floating point values. For details see
51 // https://msdn.microsoft.com/en-us/library/zthk2dkh.aspx
52 MOVQ CX, X0
53 MOVQ DX, X1
54 MOVQ R8, X2
55 MOVQ R9, X3
56
57 // Call stdcall function.
58 CALL AX
59
60 ADDQ $(maxargs*8), SP
61
62 // Return result.
63 POPQ CX
64 MOVQ AX, libcall_r1(CX)
65 // Floating point return values are returned in XMM0. Setting r2 to this
66 // value in case this call returned a floating point value. For details,
67 // see https://docs.microsoft.com/en-us/cpp/build/x64-calling-convention
68 MOVQ X0, libcall_r2(CX)
69
70 // GetLastError().
71 MOVQ 0x30(GS), DI
72 MOVL 0x68(DI), AX
73 MOVQ AX, libcall_err(CX)
74
75 RET
76
77 TEXT runtime·badsignal2(SB),NOSPLIT|NOFRAME,$48
78 // stderr
79 MOVQ $-12, CX // stderr
80 MOVQ CX, 0(SP)
81 MOVQ runtime·_GetStdHandle(SB), AX
82 CALL AX
83
84 MOVQ AX, CX // handle
85 MOVQ CX, 0(SP)
86 MOVQ $runtime·badsignalmsg(SB), DX // pointer
87 MOVQ DX, 8(SP)
88 MOVL $runtime·badsignallen(SB), R8 // count
89 MOVQ R8, 16(SP)
90 LEAQ 40(SP), R9 // written count
91 MOVQ $0, 0(R9)
92 MOVQ R9, 24(SP)
93 MOVQ $0, 32(SP) // overlapped
94 MOVQ runtime·_WriteFile(SB), AX
95 CALL AX
96
97 RET
98
99 // faster get/set last error
100 TEXT runtime·getlasterror(SB),NOSPLIT,$0
101 MOVQ 0x30(GS), AX
102 MOVL 0x68(AX), AX
103 MOVL AX, ret+0(FP)
104 RET
105
106 TEXT runtime·setlasterror(SB),NOSPLIT,$0
107 MOVL err+0(FP), AX
108 MOVQ 0x30(GS), CX
109 MOVL AX, 0x68(CX)
110 RET
111
112 // Called by Windows as a Vectored Exception Handler (VEH).
113 // First argument is pointer to struct containing
114 // exception record and context pointers.
115 // Handler function is stored in AX.
116 // Return 0 for 'not handled', -1 for handled.
117 TEXT sigtramp<>(SB),NOSPLIT|NOFRAME,$0-0
118 // CX: PEXCEPTION_POINTERS ExceptionInfo
119
120 // DI SI BP BX R12 R13 R14 R15 registers and DF flag are preserved
121 // as required by windows callback convention.
122 PUSHFQ
123 SUBQ $112, SP
124 MOVQ DI, 80(SP)
125 MOVQ SI, 72(SP)
126 MOVQ BP, 64(SP)
127 MOVQ BX, 56(SP)
128 MOVQ R12, 48(SP)
129 MOVQ R13, 40(SP)
130 MOVQ R14, 32(SP)
131 MOVQ R15, 88(SP)
132
133 MOVQ AX, R15 // save handler address
134
135 // find g
136 get_tls(DX)
137 CMPQ DX, $0
138 JNE 3(PC)
139 MOVQ $0, AX // continue
140 JMP done
141 MOVQ g(DX), DX
142 CMPQ DX, $0
143 JNE 2(PC)
144 CALL runtime·badsignal2(SB)
145
146 // save g and SP in case of stack switch
147 MOVQ DX, 96(SP) // g
148 MOVQ SP, 104(SP)
149
150 // do we need to switch to the g0 stack?
151 MOVQ g_m(DX), BX
152 MOVQ m_g0(BX), BX
153 CMPQ DX, BX
154 JEQ g0
155
156 // switch to g0 stack
157 get_tls(BP)
158 MOVQ BX, g(BP)
159 MOVQ (g_sched+gobuf_sp)(BX), DI
160 // make it look like mstart called us on g0, to stop traceback
161 SUBQ $8, DI
162 MOVQ $runtime·mstart(SB), SI
163 MOVQ SI, 0(DI)
164 // traceback will think that we've done PUSHFQ and SUBQ
165 // on this stack, so subtract them here to match.
166 // (we need room for sighandler arguments anyway).
167 // and re-save old SP for restoring later.
168 SUBQ $(112+8), DI
169 // save g, save old stack pointer.
170 MOVQ SP, 104(DI)
171 MOVQ DI, SP
172
173 g0:
174 MOVQ 0(CX), BX // ExceptionRecord*
175 MOVQ 8(CX), CX // Context*
176 MOVQ BX, 0(SP)
177 MOVQ CX, 8(SP)
178 MOVQ DX, 16(SP)
179 CALL R15 // call handler
180 // AX is set to report result back to Windows
181 MOVL 24(SP), AX
182
183 // switch back to original stack and g
184 // no-op if we never left.
185 MOVQ 104(SP), SP
186 MOVQ 96(SP), DX
187 get_tls(BP)
188 MOVQ DX, g(BP)
189
190 done:
191 // restore registers as required for windows callback
192 MOVQ 88(SP), R15
193 MOVQ 32(SP), R14
194 MOVQ 40(SP), R13
195 MOVQ 48(SP), R12
196 MOVQ 56(SP), BX
197 MOVQ 64(SP), BP
198 MOVQ 72(SP), SI
199 MOVQ 80(SP), DI
200 ADDQ $112, SP
201 POPFQ
202
203 RET
204
205 TEXT runtime·exceptiontramp(SB),NOSPLIT|NOFRAME,$0
206 MOVQ $runtime·exceptionhandler(SB), AX
207 JMP sigtramp<>(SB)
208
209 TEXT runtime·firstcontinuetramp(SB),NOSPLIT|NOFRAME,$0-0
210 MOVQ $runtime·firstcontinuehandler(SB), AX
211 JMP sigtramp<>(SB)
212
213 TEXT runtime·lastcontinuetramp(SB),NOSPLIT|NOFRAME,$0-0
214 MOVQ $runtime·lastcontinuehandler(SB), AX
215 JMP sigtramp<>(SB)
216
217 TEXT runtime·ctrlhandler(SB),NOSPLIT|NOFRAME,$8
218 MOVQ CX, 16(SP) // spill
219 MOVQ $runtime·ctrlhandler1(SB), CX
220 MOVQ CX, 0(SP)
221 CALL runtime·externalthreadhandler(SB)
222 RET
223
224 TEXT runtime·profileloop(SB),NOSPLIT|NOFRAME,$8
225 MOVQ $runtime·profileloop1(SB), CX
226 MOVQ CX, 0(SP)
227 CALL runtime·externalthreadhandler(SB)
228 RET
229
230 TEXT runtime·externalthreadhandler(SB),NOSPLIT|NOFRAME,$0
231 PUSHQ BP
232 MOVQ SP, BP
233 PUSHQ BX
234 PUSHQ SI
235 PUSHQ DI
236 PUSHQ 0x28(GS)
237 MOVQ SP, DX
238
239 // setup dummy m, g
240 SUBQ $m__size, SP // space for M
241 MOVQ SP, 0(SP)
242 MOVQ $m__size, 8(SP)
243 CALL runtime·memclrNoHeapPointers(SB) // smashes AX,BX,CX, maybe BP
244
245 LEAQ m_tls(SP), CX
246 MOVQ CX, 0x28(GS)
247 MOVQ SP, BX
248 SUBQ $g__size, SP // space for G
249 MOVQ SP, g(CX)
250 MOVQ SP, m_g0(BX)
251
252 MOVQ SP, 0(SP)
253 MOVQ $g__size, 8(SP)
254 CALL runtime·memclrNoHeapPointers(SB) // smashes AX,BX,CX, maybe BP
255 LEAQ g__size(SP), BX
256 MOVQ BX, g_m(SP)
257
258 LEAQ -32768(SP), CX // must be less than SizeOfStackReserve set by linker
259 MOVQ CX, (g_stack+stack_lo)(SP)
260 ADDQ $const__StackGuard, CX
261 MOVQ CX, g_stackguard0(SP)
262 MOVQ CX, g_stackguard1(SP)
263 MOVQ DX, (g_stack+stack_hi)(SP)
264
265 PUSHQ AX // room for return value
266 PUSHQ 32(BP) // arg for handler
267 CALL 16(BP)
268 POPQ CX
269 POPQ AX // pass return value to Windows in AX
270
271 get_tls(CX)
272 MOVQ g(CX), CX
273 MOVQ (g_stack+stack_hi)(CX), SP
274 POPQ 0x28(GS)
275 POPQ DI
276 POPQ SI
277 POPQ BX
278 POPQ BP
279 RET
280
281 GLOBL runtime·cbctxts(SB), NOPTR, $8
282
283 TEXT runtime·callbackasm1(SB),NOSPLIT,$0
284 // Construct args vector for cgocallback().
285 // By windows/amd64 calling convention first 4 args are in CX, DX, R8, R9
286 // args from the 5th on are on the stack.
287 // In any case, even if function has 0,1,2,3,4 args, there is reserved
288 // but uninitialized "shadow space" for the first 4 args.
289 // The values are in registers.
290 MOVQ CX, (16+0)(SP)
291 MOVQ DX, (16+8)(SP)
292 MOVQ R8, (16+16)(SP)
293 MOVQ R9, (16+24)(SP)
294 // R8 = address of args vector
295 LEAQ (16+0)(SP), R8
296
297 // remove return address from stack, we are not returning to callbackasm, but to its caller.
298 MOVQ 0(SP), AX
299 ADDQ $8, SP
300
301 // determine index into runtime·cbs table
302 MOVQ $runtime·callbackasm(SB), DX
303 SUBQ DX, AX
304 MOVQ $0, DX
305 MOVQ $5, CX // divide by 5 because each call instruction in runtime·callbacks is 5 bytes long
306 DIVL CX
307 SUBQ $1, AX // subtract 1 because return PC is to the next slot
308
309 // DI SI BP BX R12 R13 R14 R15 registers and DF flag are preserved
310 // as required by windows callback convention.
311 PUSHFQ
312 SUBQ $64, SP
313 MOVQ DI, 56(SP)
314 MOVQ SI, 48(SP)
315 MOVQ BP, 40(SP)
316 MOVQ BX, 32(SP)
317 MOVQ R12, 24(SP)
318 MOVQ R13, 16(SP)
319 MOVQ R14, 8(SP)
320 MOVQ R15, 0(SP)
321
322 // Go ABI requires DF flag to be cleared.
323 CLD
324
325 // Create a struct callbackArgs on our stack to be passed as
326 // the "frame" to cgocallback and on to callbackWrap.
327 SUBQ $(24+callbackArgs__size), SP
328 MOVQ AX, (24+callbackArgs_index)(SP) // callback index
329 MOVQ R8, (24+callbackArgs_args)(SP) // address of args vector
330 MOVQ $0, (24+callbackArgs_result)(SP) // result
331 LEAQ 24(SP), AX
332 // Call cgocallback, which will call callbackWrap(frame).
333 MOVQ $0, 16(SP) // context
334 MOVQ AX, 8(SP) // frame (address of callbackArgs)
335 LEAQ ·callbackWrap(SB), BX
336 MOVQ BX, 0(SP) // PC of function value to call (callbackWrap)
337 CALL ·cgocallback(SB)
338 // Get callback result.
339 MOVQ (24+callbackArgs_result)(SP), AX
340 ADDQ $(24+callbackArgs__size), SP
341
342 // restore registers as required for windows callback
343 MOVQ 0(SP), R15
344 MOVQ 8(SP), R14
345 MOVQ 16(SP), R13
346 MOVQ 24(SP), R12
347 MOVQ 32(SP), BX
348 MOVQ 40(SP), BP
349 MOVQ 48(SP), SI
350 MOVQ 56(SP), DI
351 ADDQ $64, SP
352 POPFQ
353
354 // The return value was placed in AX above.
355 RET
356
357 // uint32 tstart_stdcall(M *newm);
358 TEXT runtime·tstart_stdcall(SB),NOSPLIT,$0
359 // CX contains first arg newm
360 MOVQ m_g0(CX), DX // g
361
362 // Layout new m scheduler stack on os stack.
363 MOVQ SP, AX
364 MOVQ AX, (g_stack+stack_hi)(DX)
365 SUBQ $(64*1024), AX // initial stack size (adjusted later)
366 MOVQ AX, (g_stack+stack_lo)(DX)
367 ADDQ $const__StackGuard, AX
368 MOVQ AX, g_stackguard0(DX)
369 MOVQ AX, g_stackguard1(DX)
370
371 // Set up tls.
372 LEAQ m_tls(CX), SI
373 MOVQ SI, 0x28(GS)
374 MOVQ CX, g_m(DX)
375 MOVQ DX, g(SI)
376
377 // Someday the convention will be D is always cleared.
378 CLD
379
380 CALL runtime·stackcheck(SB) // clobbers AX,CX
381 CALL runtime·mstart(SB)
382
383 XORL AX, AX // return 0 == success
384 RET
385
386 // set tls base to DI
387 TEXT runtime·settls(SB),NOSPLIT,$0
388 MOVQ DI, 0x28(GS)
389 RET
390
391 // func onosstack(fn unsafe.Pointer, arg uint32)
392 TEXT runtime·onosstack(SB),NOSPLIT,$0
393 MOVQ fn+0(FP), AX // to hide from 6l
394 MOVL arg+8(FP), BX
395
396 // Execute call on m->g0 stack, in case we are not actually
397 // calling a system call wrapper, like when running under WINE.
398 get_tls(R15)
399 CMPQ R15, $0
400 JNE 3(PC)
401 // Not a Go-managed thread. Do not switch stack.
402 CALL AX
403 RET
404
405 MOVQ g(R15), R13
406 MOVQ g_m(R13), R13
407
408 // leave pc/sp for cpu profiler
409 MOVQ (SP), R12
410 MOVQ R12, m_libcallpc(R13)
411 MOVQ g(R15), R12
412 MOVQ R12, m_libcallg(R13)
413 // sp must be the last, because once async cpu profiler finds
414 // all three values to be non-zero, it will use them
415 LEAQ fn+0(FP), R12
416 MOVQ R12, m_libcallsp(R13)
417
418 MOVQ m_g0(R13), R14
419 CMPQ g(R15), R14
420 JNE switch
421 // executing on m->g0 already
422 CALL AX
423 JMP ret
424
425 switch:
426 // Switch to m->g0 stack and back.
427 MOVQ (g_sched+gobuf_sp)(R14), R14
428 MOVQ SP, -8(R14)
429 LEAQ -8(R14), SP
430 CALL AX
431 MOVQ 0(SP), SP
432
433 ret:
434 MOVQ $0, m_libcallsp(R13)
435 RET
436
437 // Runs on OS stack. duration (in 100ns units) is in BX.
438 // The function leaves room for 4 syscall parameters
439 // (as per windows amd64 calling convention).
440 TEXT runtime·usleep2(SB),NOSPLIT|NOFRAME,$48
441 MOVQ SP, AX
442 ANDQ $~15, SP // alignment as per Windows requirement
443 MOVQ AX, 40(SP)
444 // Want negative 100ns units.
445 NEGQ BX
446 LEAQ 32(SP), R8 // ptime
447 MOVQ BX, (R8)
448 MOVQ $-1, CX // handle
449 MOVQ $0, DX // alertable
450 MOVQ runtime·_NtWaitForSingleObject(SB), AX
451 CALL AX
452 MOVQ 40(SP), SP
453 RET
454
455 // Runs on OS stack. duration (in 100ns units) is in BX.
456 TEXT runtime·usleep2HighRes(SB),NOSPLIT|NOFRAME,$72
457 get_tls(CX)
458 CMPQ CX, $0
459 JE gisnotset
460
461 MOVQ SP, AX
462 ANDQ $~15, SP // alignment as per Windows requirement
463 MOVQ AX, 64(SP)
464
465 MOVQ g(CX), CX
466 MOVQ g_m(CX), CX
467 MOVQ (m_mOS+mOS_highResTimer)(CX), CX // hTimer
468 MOVQ CX, 48(SP) // save hTimer for later
469 // Want negative 100ns units.
470 NEGQ BX
471 LEAQ 56(SP), DX // lpDueTime
472 MOVQ BX, (DX)
473 MOVQ $0, R8 // lPeriod
474 MOVQ $0, R9 // pfnCompletionRoutine
475 MOVQ $0, AX
476 MOVQ AX, 32(SP) // lpArgToCompletionRoutine
477 MOVQ AX, 40(SP) // fResume
478 MOVQ runtime·_SetWaitableTimer(SB), AX
479 CALL AX
480
481 MOVQ 48(SP), CX // handle
482 MOVQ $0, DX // alertable
483 MOVQ $0, R8 // ptime
484 MOVQ runtime·_NtWaitForSingleObject(SB), AX
485 CALL AX
486
487 MOVQ 64(SP), SP
488 RET
489
490 gisnotset:
491 // TLS is not configured. Call usleep2 instead.
492 MOVQ $runtime·usleep2(SB), AX
493 CALL AX
494 RET
495
496 // Runs on OS stack.
497 TEXT runtime·switchtothread(SB),NOSPLIT|NOFRAME,$0
498 MOVQ SP, AX
499 ANDQ $~15, SP // alignment as per Windows requirement
500 SUBQ $(48), SP // room for SP and 4 args as per Windows requirement
501 // plus one extra word to keep stack 16 bytes aligned
502 MOVQ AX, 32(SP)
503 MOVQ runtime·_SwitchToThread(SB), AX
504 CALL AX
505 MOVQ 32(SP), SP
506 RET
507
508 // See https://www.dcl.hpi.uni-potsdam.de/research/WRK/2007/08/getting-os-information-the-kuser_shared_data-structure/
509 // Must read hi1, then lo, then hi2. The snapshot is valid if hi1 == hi2.
510 #define _INTERRUPT_TIME 0x7ffe0008
511 #define _SYSTEM_TIME 0x7ffe0014
512 #define time_lo 0
513 #define time_hi1 4
514 #define time_hi2 8
515
516 TEXT runtime·nanotime1(SB),NOSPLIT,$0-8
517 CMPB runtime·useQPCTime(SB), $0
518 JNE useQPC
519 MOVQ $_INTERRUPT_TIME, DI
520 loop:
521 MOVL time_hi1(DI), AX
522 MOVL time_lo(DI), BX
523 MOVL time_hi2(DI), CX
524 CMPL AX, CX
525 JNE loop
526 SHLQ $32, CX
527 ORQ BX, CX
528 IMULQ $100, CX
529 MOVQ CX, ret+0(FP)
530 RET
531 useQPC:
532 JMP runtime·nanotimeQPC(SB)
533 RET
534
535 TEXT time·now(SB),NOSPLIT,$0-24
536 CMPB runtime·useQPCTime(SB), $0
537 JNE useQPC
538 MOVQ $_INTERRUPT_TIME, DI
539 loop:
540 MOVL time_hi1(DI), AX
541 MOVL time_lo(DI), BX
542 MOVL time_hi2(DI), CX
543 CMPL AX, CX
544 JNE loop
545 SHLQ $32, AX
546 ORQ BX, AX
547 IMULQ $100, AX
548 MOVQ AX, mono+16(FP)
549
550 MOVQ $_SYSTEM_TIME, DI
551 wall:
552 MOVL time_hi1(DI), AX
553 MOVL time_lo(DI), BX
554 MOVL time_hi2(DI), CX
555 CMPL AX, CX
556 JNE wall
557 SHLQ $32, AX
558 ORQ BX, AX
559 MOVQ $116444736000000000, DI
560 SUBQ DI, AX
561 IMULQ $100, AX
562
563 // generated code for
564 // func f(x uint64) (uint64, uint64) { return x/1000000000, x%100000000 }
565 // adapted to reduce duplication
566 MOVQ AX, CX
567 MOVQ $1360296554856532783, AX
568 MULQ CX
569 ADDQ CX, DX
570 RCRQ $1, DX
571 SHRQ $29, DX
572 MOVQ DX, sec+0(FP)
573 IMULQ $1000000000, DX
574 SUBQ DX, CX
575 MOVL CX, nsec+8(FP)
576 RET
577 useQPC:
578 JMP runtime·nowQPC(SB)
579 RET
580
View as plain text