Text file
src/runtime/sys_windows_arm.s
Documentation: runtime
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 "time_windows.h"
9
10 // Note: For system ABI, R0-R3 are args, R4-R11 are callee-save.
11
12 // void runtime·asmstdcall(void *c);
13 TEXT runtime·asmstdcall<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
14 MOVM.DB.W [R4, R5, R14], (R13) // push {r4, r5, lr}
15 MOVW R0, R4 // put libcall * in r4
16 MOVW R13, R5 // save stack pointer in r5
17
18 // SetLastError(0)
19 MOVW $0, R0
20 MRC 15, 0, R1, C13, C0, 2
21 MOVW R0, 0x34(R1)
22
23 MOVW 8(R4), R12 // libcall->args
24
25 // Do we have more than 4 arguments?
26 MOVW 4(R4), R0 // libcall->n
27 SUB.S $4, R0, R2
28 BLE loadregs
29
30 // Reserve stack space for remaining args
31 SUB R2<<2, R13
32 BIC $0x7, R13 // alignment for ABI
33
34 // R0: count of arguments
35 // R1:
36 // R2: loop counter, from 0 to (n-4)
37 // R3: scratch
38 // R4: pointer to libcall struct
39 // R12: libcall->args
40 MOVW $0, R2
41 stackargs:
42 ADD $4, R2, R3 // r3 = args[4 + i]
43 MOVW R3<<2(R12), R3
44 MOVW R3, R2<<2(R13) // stack[i] = r3
45
46 ADD $1, R2 // i++
47 SUB $4, R0, R3 // while (i < (n - 4))
48 CMP R3, R2
49 BLT stackargs
50
51 loadregs:
52 CMP $3, R0
53 MOVW.GT 12(R12), R3
54
55 CMP $2, R0
56 MOVW.GT 8(R12), R2
57
58 CMP $1, R0
59 MOVW.GT 4(R12), R1
60
61 CMP $0, R0
62 MOVW.GT 0(R12), R0
63
64 BIC $0x7, R13 // alignment for ABI
65 MOVW 0(R4), R12 // branch to libcall->fn
66 BL (R12)
67
68 MOVW R5, R13 // free stack space
69 MOVW R0, 12(R4) // save return value to libcall->r1
70 MOVW R1, 16(R4)
71
72 // GetLastError
73 MRC 15, 0, R1, C13, C0, 2
74 MOVW 0x34(R1), R0
75 MOVW R0, 20(R4) // store in libcall->err
76
77 MOVM.IA.W (R13), [R4, R5, R15]
78
79 TEXT runtime·badsignal2(SB),NOSPLIT|NOFRAME,$0
80 MOVM.DB.W [R4, R14], (R13) // push {r4, lr}
81 MOVW R13, R4 // save original stack pointer
82 SUB $8, R13 // space for 2 variables
83 BIC $0x7, R13 // alignment for ABI
84
85 // stderr
86 MOVW runtime·_GetStdHandle(SB), R1
87 MOVW $-12, R0
88 BL (R1)
89
90 MOVW $runtime·badsignalmsg(SB), R1 // lpBuffer
91 MOVW $runtime·badsignallen(SB), R2 // lpNumberOfBytesToWrite
92 MOVW (R2), R2
93 ADD $0x4, R13, R3 // lpNumberOfBytesWritten
94 MOVW $0, R12 // lpOverlapped
95 MOVW R12, (R13)
96
97 MOVW runtime·_WriteFile(SB), R12
98 BL (R12)
99
100 // Does not return.
101 B runtime·abort(SB)
102
103 TEXT runtime·getlasterror(SB),NOSPLIT,$0
104 MRC 15, 0, R0, C13, C0, 2
105 MOVW 0x34(R0), R0
106 MOVW R0, ret+0(FP)
107 RET
108
109 // Called by Windows as a Vectored Exception Handler (VEH).
110 // First argument is pointer to struct containing
111 // exception record and context pointers.
112 // Handler function is stored in R1
113 // Return 0 for 'not handled', -1 for handled.
114 // int32_t sigtramp(
115 // PEXCEPTION_POINTERS ExceptionInfo,
116 // func *GoExceptionHandler);
117 TEXT sigtramp<>(SB),NOSPLIT|NOFRAME,$0
118 MOVM.DB.W [R0, R4-R11, R14], (R13) // push {r0, r4-r11, lr} (SP-=40)
119 SUB $(8+20), R13 // reserve space for g, sp, and
120 // parameters/retval to go call
121
122 MOVW R0, R6 // Save param0
123 MOVW R1, R7 // Save param1
124
125 BL runtime·load_g(SB)
126 CMP $0, g // is there a current g?
127 BL.EQ runtime·badsignal2(SB)
128
129 // save g and SP in case of stack switch
130 MOVW R13, 24(R13)
131 MOVW g, 20(R13)
132
133 // do we need to switch to the g0 stack?
134 MOVW g, R5 // R5 = g
135 MOVW g_m(R5), R2 // R2 = m
136 MOVW m_g0(R2), R4 // R4 = g0
137 CMP R5, R4 // if curg == g0
138 BEQ g0
139
140 // switch to g0 stack
141 MOVW R4, g // g = g0
142 MOVW (g_sched+gobuf_sp)(g), R3 // R3 = g->gobuf.sp
143 BL runtime·save_g(SB)
144
145 // make room for sighandler arguments
146 // and re-save old SP for restoring later.
147 // (note that the 24(R3) here must match the 24(R13) above.)
148 SUB $40, R3
149 MOVW R13, 24(R3) // save old stack pointer
150 MOVW R3, R13 // switch stack
151
152 g0:
153 MOVW 0(R6), R2 // R2 = ExceptionPointers->ExceptionRecord
154 MOVW 4(R6), R3 // R3 = ExceptionPointers->ContextRecord
155
156 MOVW $0, R4
157 MOVW R4, 0(R13) // No saved link register.
158 MOVW R2, 4(R13) // Move arg0 (ExceptionRecord) into position
159 MOVW R3, 8(R13) // Move arg1 (ContextRecord) into position
160 MOVW R5, 12(R13) // Move arg2 (original g) into position
161 BL (R7) // Call the goroutine
162 MOVW 16(R13), R4 // Fetch return value from stack
163
164 // Save system stack pointer for sigresume setup below.
165 // The exact value does not matter - nothing is read or written
166 // from this address. It just needs to be on the system stack.
167 MOVW R13, R12
168
169 // switch back to original stack and g
170 MOVW 24(R13), R13
171 MOVW 20(R13), g
172 BL runtime·save_g(SB)
173
174 done:
175 MOVW R4, R0 // move retval into position
176 ADD $(8 + 20), R13 // free locals
177 MOVM.IA.W (R13), [R3, R4-R11, R14] // pop {r3, r4-r11, lr}
178
179 // if return value is CONTINUE_SEARCH, do not set up control
180 // flow guard workaround
181 CMP $0, R0
182 BEQ return
183
184 // Check if we need to set up the control flow guard workaround.
185 // On Windows, the stack pointer in the context must lie within
186 // system stack limits when we resume from exception.
187 // Store the resume SP and PC on the g0 stack,
188 // and return to sigresume on the g0 stack. sigresume
189 // pops the saved PC and SP from the g0 stack, resuming execution
190 // at the desired location.
191 // If sigresume has already been set up by a previous exception
192 // handler, don't clobber the stored SP and PC on the stack.
193 MOVW 4(R3), R3 // PEXCEPTION_POINTERS->Context
194 MOVW context_pc(R3), R2 // load PC from context record
195 MOVW $sigresume<>(SB), R1
196 CMP R1, R2
197 B.EQ return // do not clobber saved SP/PC
198
199 // Save resume SP and PC into R0, R1.
200 MOVW context_spr(R3), R2
201 MOVW R2, context_r0(R3)
202 MOVW context_pc(R3), R2
203 MOVW R2, context_r1(R3)
204
205 // Set up context record to return to sigresume on g0 stack
206 MOVW R12, context_spr(R3)
207 MOVW $sigresume<>(SB), R2
208 MOVW R2, context_pc(R3)
209
210 return:
211 B (R14) // return
212
213 // Trampoline to resume execution from exception handler.
214 // This is part of the control flow guard workaround.
215 // It switches stacks and jumps to the continuation address.
216 // R0 and R1 are set above at the end of sigtramp<>
217 // in the context that starts executing at sigresume<>.
218 TEXT sigresume<>(SB),NOSPLIT|NOFRAME,$0
219 // Important: do not smash LR,
220 // which is set to a live value when handling
221 // a signal by pushing a call to sigpanic onto the stack.
222 MOVW R0, R13
223 B (R1)
224
225 TEXT runtime·exceptiontramp<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
226 MOVW $runtime·exceptionhandler(SB), R1
227 B sigtramp<>(SB)
228
229 TEXT runtime·firstcontinuetramp<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
230 MOVW $runtime·firstcontinuehandler(SB), R1
231 B sigtramp<>(SB)
232
233 TEXT runtime·lastcontinuetramp<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
234 MOVW $runtime·lastcontinuehandler(SB), R1
235 B sigtramp<>(SB)
236
237 GLOBL runtime·cbctxts(SB), NOPTR, $4
238
239 TEXT runtime·callbackasm1<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
240 // On entry, the trampoline in zcallback_windows_arm.s left
241 // the callback index in R12 (which is volatile in the C ABI).
242
243 // Push callback register arguments r0-r3. We do this first so
244 // they're contiguous with stack arguments.
245 MOVM.DB.W [R0-R3], (R13)
246 // Push C callee-save registers r4-r11 and lr.
247 MOVM.DB.W [R4-R11, R14], (R13)
248 SUB $(16 + callbackArgs__size), R13 // space for locals
249
250 // Create a struct callbackArgs on our stack.
251 MOVW R12, (16+callbackArgs_index)(R13) // callback index
252 MOVW $(16+callbackArgs__size+4*9)(R13), R0
253 MOVW R0, (16+callbackArgs_args)(R13) // address of args vector
254 MOVW $0, R0
255 MOVW R0, (16+callbackArgs_result)(R13) // result
256
257 // Prepare for entry to Go.
258 BL runtime·load_g(SB)
259
260 // Call cgocallback, which will call callbackWrap(frame).
261 MOVW $0, R0
262 MOVW R0, 12(R13) // context
263 MOVW $16(R13), R1 // R1 = &callbackArgs{...}
264 MOVW R1, 8(R13) // frame (address of callbackArgs)
265 MOVW $·callbackWrap(SB), R1
266 MOVW R1, 4(R13) // PC of function to call
267 BL runtime·cgocallback(SB)
268
269 // Get callback result.
270 MOVW (16+callbackArgs_result)(R13), R0
271
272 ADD $(16 + callbackArgs__size), R13 // free locals
273 MOVM.IA.W (R13), [R4-R11, R12] // pop {r4-r11, lr=>r12}
274 ADD $(4*4), R13 // skip r0-r3
275 B (R12) // return
276
277 // uint32 tstart_stdcall(M *newm);
278 TEXT runtime·tstart_stdcall<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
279 MOVM.DB.W [R4-R11, R14], (R13) // push {r4-r11, lr}
280
281 MOVW m_g0(R0), g
282 MOVW R0, g_m(g)
283 BL runtime·save_g(SB)
284
285 // Layout new m scheduler stack on os stack.
286 MOVW R13, R0
287 MOVW R0, g_stack+stack_hi(g)
288 SUB $(64*1024), R0
289 MOVW R0, (g_stack+stack_lo)(g)
290 MOVW R0, g_stackguard0(g)
291 MOVW R0, g_stackguard1(g)
292
293 BL runtime·emptyfunc(SB) // fault if stack check is wrong
294 BL runtime·mstart(SB)
295
296 // Exit the thread.
297 MOVW $0, R0
298 MOVM.IA.W (R13), [R4-R11, R15] // pop {r4-r11, pc}
299
300 // Runs on OS stack.
301 // duration (in -100ns units) is in dt+0(FP).
302 // g may be nil.
303 TEXT runtime·usleep2(SB),NOSPLIT|NOFRAME,$0-4
304 MOVW dt+0(FP), R3
305 MOVM.DB.W [R4, R14], (R13) // push {r4, lr}
306 MOVW R13, R4 // Save SP
307 SUB $8, R13 // R13 = R13 - 8
308 BIC $0x7, R13 // Align SP for ABI
309 MOVW $0, R1 // R1 = FALSE (alertable)
310 MOVW $-1, R0 // R0 = handle
311 MOVW R13, R2 // R2 = pTime
312 MOVW R3, 0(R2) // time_lo
313 MOVW R0, 4(R2) // time_hi
314 MOVW runtime·_NtWaitForSingleObject(SB), R3
315 BL (R3)
316 MOVW R4, R13 // Restore SP
317 MOVM.IA.W (R13), [R4, R15] // pop {R4, pc}
318
319 // Runs on OS stack.
320 // duration (in -100ns units) is in dt+0(FP).
321 // g is valid.
322 // TODO: neeeds to be implemented properly.
323 TEXT runtime·usleep2HighRes(SB),NOSPLIT|NOFRAME,$0-4
324 B runtime·abort(SB)
325
326 // Runs on OS stack.
327 TEXT runtime·switchtothread(SB),NOSPLIT|NOFRAME,$0
328 MOVM.DB.W [R4, R14], (R13) // push {R4, lr}
329 MOVW R13, R4
330 BIC $0x7, R13 // alignment for ABI
331 MOVW runtime·_SwitchToThread(SB), R0
332 BL (R0)
333 MOVW R4, R13 // restore stack pointer
334 MOVM.IA.W (R13), [R4, R15] // pop {R4, pc}
335
336 TEXT ·publicationBarrier(SB),NOSPLIT|NOFRAME,$0-0
337 B runtime·armPublicationBarrier(SB)
338
339 // never called (this is a GOARM=7 platform)
340 TEXT runtime·read_tls_fallback(SB),NOSPLIT|NOFRAME,$0
341 MOVW $0xabcd, R0
342 MOVW R0, (R0)
343 RET
344
345 TEXT runtime·nanotime1(SB),NOSPLIT|NOFRAME,$0-8
346 MOVW $0, R0
347 MOVB runtime·useQPCTime(SB), R0
348 CMP $0, R0
349 BNE useQPC
350 MOVW $_INTERRUPT_TIME, R3
351 loop:
352 MOVW time_hi1(R3), R1
353 MOVW time_lo(R3), R0
354 MOVW time_hi2(R3), R2
355 CMP R1, R2
356 BNE loop
357
358 // wintime = R1:R0, multiply by 100
359 MOVW $100, R2
360 MULLU R0, R2, (R4, R3) // R4:R3 = R1:R0 * R2
361 MULA R1, R2, R4, R4
362
363 // wintime*100 = R4:R3
364 MOVW R3, ret_lo+0(FP)
365 MOVW R4, ret_hi+4(FP)
366 RET
367 useQPC:
368 B runtime·nanotimeQPC(SB) // tail call
369
370 // save_g saves the g register (R10) into thread local memory
371 // so that we can call externally compiled
372 // ARM code that will overwrite those registers.
373 // NOTE: runtime.gogo assumes that R1 is preserved by this function.
374 // runtime.mcall assumes this function only clobbers R0 and R11.
375 // Returns with g in R0.
376 // Save the value in the _TEB->TlsSlots array.
377 // Effectively implements TlsSetValue().
378 // tls_g stores the TLS slot allocated TlsAlloc().
379 TEXT runtime·save_g(SB),NOSPLIT|NOFRAME,$0
380 MRC 15, 0, R0, C13, C0, 2
381 ADD $0xe10, R0
382 MOVW $runtime·tls_g(SB), R11
383 MOVW (R11), R11
384 MOVW g, R11<<2(R0)
385 MOVW g, R0 // preserve R0 across call to setg<>
386 RET
387
388 // load_g loads the g register from thread-local memory,
389 // for use after calling externally compiled
390 // ARM code that overwrote those registers.
391 // Get the value from the _TEB->TlsSlots array.
392 // Effectively implements TlsGetValue().
393 TEXT runtime·load_g(SB),NOSPLIT|NOFRAME,$0
394 MRC 15, 0, R0, C13, C0, 2
395 ADD $0xe10, R0
396 MOVW $runtime·tls_g(SB), g
397 MOVW (g), g
398 MOVW g<<2(R0), g
399 RET
400
401 // This is called from rt0_go, which runs on the system stack
402 // using the initial stack allocated by the OS.
403 // It calls back into standard C using the BL below.
404 // To do that, the stack pointer must be 8-byte-aligned.
405 TEXT runtime·_initcgo(SB),NOSPLIT|NOFRAME,$0
406 MOVM.DB.W [R4, R14], (R13) // push {r4, lr}
407
408 // Ensure stack is 8-byte aligned before calling C code
409 MOVW R13, R4
410 BIC $0x7, R13
411
412 // Allocate a TLS slot to hold g across calls to external code
413 MOVW $runtime·_TlsAlloc(SB), R0
414 MOVW (R0), R0
415 BL (R0)
416
417 // Assert that slot is less than 64 so we can use _TEB->TlsSlots
418 CMP $64, R0
419 MOVW $runtime·abort(SB), R1
420 BL.GE (R1)
421
422 // Save Slot into tls_g
423 MOVW $runtime·tls_g(SB), R1
424 MOVW R0, (R1)
425
426 MOVW R4, R13
427 MOVM.IA.W (R13), [R4, R15] // pop {r4, pc}
428
429 // Holds the TLS Slot, which was allocated by TlsAlloc()
430 GLOBL runtime·tls_g+0(SB), NOPTR, $4
431
View as plain text