Text file src/runtime/sys_windows_arm.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 "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(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(SB),NOSPLIT|NOFRAME,$0
   226  	MOVW	$runtime·exceptionhandler(SB), R1
   227  	B	sigtramp<>(SB)
   228  
   229  TEXT runtime·firstcontinuetramp(SB),NOSPLIT|NOFRAME,$0
   230  	MOVW	$runtime·firstcontinuehandler(SB), R1
   231  	B	sigtramp<>(SB)
   232  
   233  TEXT runtime·lastcontinuetramp(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(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(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: needs 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  	DMB	MB_ISH
   354  	MOVW	time_lo(R3), R0
   355  	DMB	MB_ISH
   356  	MOVW	time_hi2(R3), R2
   357  	CMP	R1, R2
   358  	BNE	loop
   359  
   360  	// wintime = R1:R0, multiply by 100
   361  	MOVW	$100, R2
   362  	MULLU	R0, R2, (R4, R3)    // R4:R3 = R1:R0 * R2
   363  	MULA	R1, R2, R4, R4
   364  
   365  	// wintime*100 = R4:R3
   366  	MOVW	R3, ret_lo+0(FP)
   367  	MOVW	R4, ret_hi+4(FP)
   368  	RET
   369  useQPC:
   370  	B	runtime·nanotimeQPC(SB)		// tail call
   371  
   372  // save_g saves the g register (R10) into thread local memory
   373  // so that we can call externally compiled
   374  // ARM code that will overwrite those registers.
   375  // NOTE: runtime.gogo assumes that R1 is preserved by this function.
   376  //       runtime.mcall assumes this function only clobbers R0 and R11.
   377  // Returns with g in R0.
   378  // Save the value in the _TEB->TlsSlots array.
   379  // Effectively implements TlsSetValue().
   380  // tls_g stores the TLS slot allocated TlsAlloc().
   381  TEXT runtime·save_g(SB),NOSPLIT|NOFRAME,$0
   382  	MRC	15, 0, R0, C13, C0, 2
   383  	ADD	$0xe10, R0
   384  	MOVW 	$runtime·tls_g(SB), R11
   385  	MOVW	(R11), R11
   386  	MOVW	g, R11<<2(R0)
   387  	MOVW	g, R0	// preserve R0 across call to setg<>
   388  	RET
   389  
   390  // load_g loads the g register from thread-local memory,
   391  // for use after calling externally compiled
   392  // ARM code that overwrote those registers.
   393  // Get the value from the _TEB->TlsSlots array.
   394  // Effectively implements TlsGetValue().
   395  TEXT runtime·load_g(SB),NOSPLIT|NOFRAME,$0
   396  	MRC	15, 0, R0, C13, C0, 2
   397  	ADD	$0xe10, R0
   398  	MOVW 	$runtime·tls_g(SB), g
   399  	MOVW	(g), g
   400  	MOVW	g<<2(R0), g
   401  	RET
   402  
   403  // This is called from rt0_go, which runs on the system stack
   404  // using the initial stack allocated by the OS.
   405  // It calls back into standard C using the BL below.
   406  // To do that, the stack pointer must be 8-byte-aligned.
   407  TEXT runtime·_initcgo(SB),NOSPLIT|NOFRAME,$0
   408  	MOVM.DB.W [R4, R14], (R13)	// push {r4, lr}
   409  
   410  	// Ensure stack is 8-byte aligned before calling C code
   411  	MOVW	R13, R4
   412  	BIC	$0x7, R13
   413  
   414  	// Allocate a TLS slot to hold g across calls to external code
   415  	MOVW 	$runtime·_TlsAlloc(SB), R0
   416  	MOVW	(R0), R0
   417  	BL	(R0)
   418  
   419  	// Assert that slot is less than 64 so we can use _TEB->TlsSlots
   420  	CMP	$64, R0
   421  	MOVW	$runtime·abort(SB), R1
   422  	BL.GE	(R1)
   423  
   424  	// Save Slot into tls_g
   425  	MOVW 	$runtime·tls_g(SB), R1
   426  	MOVW	R0, (R1)
   427  
   428  	MOVW	R4, R13
   429  	MOVM.IA.W (R13), [R4, R15]	// pop {r4, pc}
   430  
   431  // Holds the TLS Slot, which was allocated by TlsAlloc()
   432  GLOBL runtime·tls_g+0(SB), NOPTR, $4
   433  

View as plain text