Text file
src/runtime/sys_windows_arm64.s
1 // Copyright 2018 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 #include "funcdata.h"
9 #include "time_windows.h"
10 #include "cgo/abi_arm64.h"
11
12 // Offsets into Thread Environment Block (pointer in R18)
13 #define TEB_error 0x68
14 #define TEB_TlsSlots 0x1480
15 #define TEB_ArbitraryPtr 0x28
16
17 // Note: R0-R7 are args, R8 is indirect return value address,
18 // R9-R15 are caller-save, R19-R29 are callee-save.
19 //
20 // load_g and save_g (in tls_arm64.s) clobber R27 (REGTMP) and R0.
21
22 TEXT runtime·asmstdcall_trampoline<ABIInternal>(SB),NOSPLIT,$0
23 B runtime·asmstdcall(SB)
24
25 // void runtime·asmstdcall(void *c);
26 TEXT runtime·asmstdcall(SB),NOSPLIT,$16
27 STP (R19, R20), 16(RSP) // save old R19, R20
28 MOVD R0, R19 // save libcall pointer
29 MOVD RSP, R20 // save stack pointer
30
31 // SetLastError(0)
32 MOVD $0, TEB_error(R18_PLATFORM)
33 MOVD libcall_args(R19), R12 // libcall->args
34
35 // Do we have more than 8 arguments?
36 MOVD libcall_n(R19), R0
37 CMP $0, R0; BEQ _0args
38 CMP $1, R0; BEQ _1args
39 CMP $2, R0; BEQ _2args
40 CMP $3, R0; BEQ _3args
41 CMP $4, R0; BEQ _4args
42 CMP $5, R0; BEQ _5args
43 CMP $6, R0; BEQ _6args
44 CMP $7, R0; BEQ _7args
45 CMP $8, R0; BEQ _8args
46
47 // Reserve stack space for remaining args
48 SUB $8, R0, R2
49 ADD $1, R2, R3 // make even number of words for stack alignment
50 AND $~1, R3
51 LSL $3, R3
52 SUB R3, RSP
53
54 // R4: size of stack arguments (n-8)*8
55 // R5: &args[8]
56 // R6: loop counter, from 0 to (n-8)*8
57 // R7: scratch
58 // R8: copy of RSP - (R2)(RSP) assembles as (R2)(ZR)
59 SUB $8, R0, R4
60 LSL $3, R4
61 ADD $(8*8), R12, R5
62 MOVD $0, R6
63 MOVD RSP, R8
64 stackargs:
65 MOVD (R6)(R5), R7
66 MOVD R7, (R6)(R8)
67 ADD $8, R6
68 CMP R6, R4
69 BNE stackargs
70
71 _8args:
72 MOVD (7*8)(R12), R7
73 _7args:
74 MOVD (6*8)(R12), R6
75 _6args:
76 MOVD (5*8)(R12), R5
77 _5args:
78 MOVD (4*8)(R12), R4
79 _4args:
80 MOVD (3*8)(R12), R3
81 _3args:
82 MOVD (2*8)(R12), R2
83 _2args:
84 MOVD (1*8)(R12), R1
85 _1args:
86 MOVD (0*8)(R12), R0
87 _0args:
88
89 MOVD libcall_fn(R19), R12 // branch to libcall->fn
90 BL (R12)
91
92 MOVD R20, RSP // free stack space
93 MOVD R0, libcall_r1(R19) // save return value to libcall->r1
94 // TODO(rsc) floating point like amd64 in libcall->r2?
95
96 // GetLastError
97 MOVD TEB_error(R18_PLATFORM), R0
98 MOVD R0, libcall_err(R19)
99
100 // Restore callee-saved registers.
101 LDP 16(RSP), (R19, R20)
102 RET
103
104 TEXT runtime·getlasterror(SB),NOSPLIT,$0
105 MOVD TEB_error(R18_PLATFORM), R0
106 MOVD R0, ret+0(FP)
107 RET
108
109 // Called by Windows as a Vectored Exception Handler (VEH).
110 // R0 is pointer to struct containing
111 // exception record and context pointers.
112 // R1 is the kind of sigtramp function.
113 // Return value of sigtrampgo is stored in R0.
114 TEXT sigtramp<>(SB),NOSPLIT,$176
115 // Switch from the host ABI to the Go ABI, safe args and lr.
116 MOVD R0, R5
117 MOVD R1, R6
118 MOVD LR, R7
119 SAVE_R19_TO_R28(8*4)
120 SAVE_F8_TO_F15(8*14)
121
122 BL runtime·load_g(SB) // Clobers R0, R27, R28 (g)
123
124 MOVD R5, R0
125 MOVD R6, R1
126 // Calling ABIInternal because TLS might be nil.
127 BL runtime·sigtrampgo<ABIInternal>(SB)
128 // Return value is already stored in R0.
129
130 // Restore callee-save registers.
131 RESTORE_R19_TO_R28(8*4)
132 RESTORE_F8_TO_F15(8*14)
133 MOVD R7, LR
134 RET
135
136 // Trampoline to resume execution from exception handler.
137 // This is part of the control flow guard workaround.
138 // It switches stacks and jumps to the continuation address.
139 // R0 and R1 are set above at the end of sigtrampgo
140 // in the context that starts executing at sigresume.
141 TEXT runtime·sigresume(SB),NOSPLIT|NOFRAME,$0
142 // Important: do not smash LR,
143 // which is set to a live value when handling
144 // a signal by pushing a call to sigpanic onto the stack.
145 MOVD R0, RSP
146 B (R1)
147
148 TEXT runtime·exceptiontramp(SB),NOSPLIT|NOFRAME,$0
149 MOVD $const_callbackVEH, R1
150 B sigtramp<>(SB)
151
152 TEXT runtime·firstcontinuetramp(SB),NOSPLIT|NOFRAME,$0
153 MOVD $const_callbackFirstVCH, R1
154 B sigtramp<>(SB)
155
156 TEXT runtime·lastcontinuetramp(SB),NOSPLIT|NOFRAME,$0
157 MOVD $const_callbackLastVCH, R1
158 B sigtramp<>(SB)
159
160 TEXT runtime·callbackasm1(SB),NOSPLIT,$208-0
161 NO_LOCAL_POINTERS
162
163 // On entry, the trampoline in zcallback_windows_arm64.s left
164 // the callback index in R12 (which is volatile in the C ABI).
165
166 // Save callback register arguments R0-R7.
167 // We do this at the top of the frame so they're contiguous with stack arguments.
168 // The 7*8 setting up R14 looks like a bug but is not: the eighth word
169 // is the space the assembler reserved for our caller's frame pointer,
170 // but we are not called from Go so that space is ours to use,
171 // and we must to be contiguous with the stack arguments.
172 MOVD $arg0-(7*8)(SP), R14
173 STP (R0, R1), (0*8)(R14)
174 STP (R2, R3), (2*8)(R14)
175 STP (R4, R5), (4*8)(R14)
176 STP (R6, R7), (6*8)(R14)
177
178 // Push C callee-save registers R19-R28.
179 // LR, FP already saved.
180 SAVE_R19_TO_R28(8*9)
181
182 // Create a struct callbackArgs on our stack.
183 MOVD $cbargs-(18*8+callbackArgs__size)(SP), R13
184 MOVD R12, callbackArgs_index(R13) // callback index
185 MOVD R14, R0
186 MOVD R0, callbackArgs_args(R13) // address of args vector
187 MOVD $0, R0
188 MOVD R0, callbackArgs_result(R13) // result
189
190 // Call cgocallback, which will call callbackWrap(frame).
191 MOVD $·callbackWrap<ABIInternal>(SB), R0 // PC of function to call, cgocallback takes an ABIInternal entry-point
192 MOVD R13, R1 // frame (&callbackArgs{...})
193 MOVD $0, R2 // context
194 STP (R0, R1), (1*8)(RSP)
195 MOVD R2, (3*8)(RSP)
196 BL runtime·cgocallback(SB)
197
198 // Get callback result.
199 MOVD $cbargs-(18*8+callbackArgs__size)(SP), R13
200 MOVD callbackArgs_result(R13), R0
201
202 RESTORE_R19_TO_R28(8*9)
203
204 RET
205
206 // uint32 tstart_stdcall(M *newm);
207 TEXT runtime·tstart_stdcall(SB),NOSPLIT,$96-0
208 SAVE_R19_TO_R28(8*3)
209
210 MOVD m_g0(R0), g
211 MOVD R0, g_m(g)
212 BL runtime·save_g(SB)
213
214 // Set up stack guards for OS stack.
215 MOVD RSP, R0
216 MOVD R0, g_stack+stack_hi(g)
217 SUB $(64*1024), R0
218 MOVD R0, (g_stack+stack_lo)(g)
219 MOVD R0, g_stackguard0(g)
220 MOVD R0, g_stackguard1(g)
221
222 BL runtime·emptyfunc(SB) // fault if stack check is wrong
223 BL runtime·mstart(SB)
224
225 RESTORE_R19_TO_R28(8*3)
226
227 // Exit the thread.
228 MOVD $0, R0
229 RET
230
231 TEXT runtime·nanotime1(SB),NOSPLIT,$0-8
232 MOVD $_INTERRUPT_TIME, R3
233 MOVD time_lo(R3), R0
234 MOVD $100, R1
235 MUL R1, R0
236 MOVD R0, ret+0(FP)
237 RET
238
239 // This is called from rt0_go, which runs on the system stack
240 // using the initial stack allocated by the OS.
241 // It calls back into standard C using the BL below.
242 TEXT runtime·wintls(SB),NOSPLIT,$0
243 // Allocate a TLS slot to hold g across calls to external code
244 MOVD runtime·_TlsAlloc(SB), R0
245 SUB $16, RSP // skip over saved frame pointer below RSP
246 BL (R0)
247 ADD $16, RSP
248
249 // Assert that slot is less than 64 so we can use _TEB->TlsSlots
250 CMP $64, R0
251 BLT ok
252 // Fallback to the TEB arbitrary pointer.
253 // TODO: don't use the arbitrary pointer (see go.dev/issue/59824)
254 MOVD $TEB_ArbitraryPtr, R0
255 B settls
256 ok:
257
258 // Save offset from R18 into tls_g.
259 LSL $3, R0
260 ADD $TEB_TlsSlots, R0
261 settls:
262 MOVD R0, runtime·tls_g(SB)
263 RET
264
View as plain text