Text file src/runtime/asm_s390x.s

     1  // Copyright 2016 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 "funcdata.h"
     8  #include "textflag.h"
     9  
    10  // _rt0_s390x_lib is common startup code for s390x systems when
    11  // using -buildmode=c-archive or -buildmode=c-shared. The linker will
    12  // arrange to invoke this function as a global constructor (for
    13  // c-archive) or when the shared library is loaded (for c-shared).
    14  // We expect argc and argv to be passed in the usual C ABI registers
    15  // R2 and R3.
    16  TEXT _rt0_s390x_lib(SB), NOSPLIT|NOFRAME, $0
    17  	STMG	R6, R15, 48(R15)
    18  	MOVD	R2, _rt0_s390x_lib_argc<>(SB)
    19  	MOVD	R3, _rt0_s390x_lib_argv<>(SB)
    20  
    21  	// Save R6-R15 in the register save area of the calling function.
    22  	STMG	R6, R15, 48(R15)
    23  
    24  	// Allocate 80 bytes on the stack.
    25  	MOVD	$-80(R15), R15
    26  
    27  	// Save F8-F15 in our stack frame.
    28  	FMOVD	F8, 16(R15)
    29  	FMOVD	F9, 24(R15)
    30  	FMOVD	F10, 32(R15)
    31  	FMOVD	F11, 40(R15)
    32  	FMOVD	F12, 48(R15)
    33  	FMOVD	F13, 56(R15)
    34  	FMOVD	F14, 64(R15)
    35  	FMOVD	F15, 72(R15)
    36  
    37  	// Synchronous initialization.
    38  	MOVD	$runtime·libpreinit(SB), R1
    39  	BL	R1
    40  
    41  	// Create a new thread to finish Go runtime initialization.
    42  	MOVD	_cgo_sys_thread_create(SB), R1
    43  	CMP	R1, $0
    44  	BEQ	nocgo
    45  	MOVD	$_rt0_s390x_lib_go(SB), R2
    46  	MOVD	$0, R3
    47  	BL	R1
    48  	BR	restore
    49  
    50  nocgo:
    51  	MOVD	$0x800000, R1              // stacksize
    52  	MOVD	R1, 0(R15)
    53  	MOVD	$_rt0_s390x_lib_go(SB), R1
    54  	MOVD	R1, 8(R15)                 // fn
    55  	MOVD	$runtime·newosproc(SB), R1
    56  	BL	R1
    57  
    58  restore:
    59  	// Restore F8-F15 from our stack frame.
    60  	FMOVD	16(R15), F8
    61  	FMOVD	24(R15), F9
    62  	FMOVD	32(R15), F10
    63  	FMOVD	40(R15), F11
    64  	FMOVD	48(R15), F12
    65  	FMOVD	56(R15), F13
    66  	FMOVD	64(R15), F14
    67  	FMOVD	72(R15), F15
    68  	MOVD	$80(R15), R15
    69  
    70  	// Restore R6-R15.
    71  	LMG	48(R15), R6, R15
    72  	RET
    73  
    74  // _rt0_s390x_lib_go initializes the Go runtime.
    75  // This is started in a separate thread by _rt0_s390x_lib.
    76  TEXT _rt0_s390x_lib_go(SB), NOSPLIT|NOFRAME, $0
    77  	MOVD	_rt0_s390x_lib_argc<>(SB), R2
    78  	MOVD	_rt0_s390x_lib_argv<>(SB), R3
    79  	MOVD	$runtime·rt0_go(SB), R1
    80  	BR	R1
    81  
    82  DATA _rt0_s390x_lib_argc<>(SB)/8, $0
    83  GLOBL _rt0_s390x_lib_argc<>(SB), NOPTR, $8
    84  DATA _rt0_s90x_lib_argv<>(SB)/8, $0
    85  GLOBL _rt0_s390x_lib_argv<>(SB), NOPTR, $8
    86  
    87  TEXT runtime·rt0_go(SB),NOSPLIT|TOPFRAME,$0
    88  	// R2 = argc; R3 = argv; R11 = temp; R13 = g; R15 = stack pointer
    89  	// C TLS base pointer in AR0:AR1
    90  
    91  	// initialize essential registers
    92  	XOR	R0, R0
    93  
    94  	SUB	$24, R15
    95  	MOVW	R2, 8(R15) // argc
    96  	MOVD	R3, 16(R15) // argv
    97  
    98  	// create istack out of the given (operating system) stack.
    99  	// _cgo_init may update stackguard.
   100  	MOVD	$runtime·g0(SB), g
   101  	MOVD	R15, R11
   102  	SUB	$(64*1024), R11
   103  	MOVD	R11, g_stackguard0(g)
   104  	MOVD	R11, g_stackguard1(g)
   105  	MOVD	R11, (g_stack+stack_lo)(g)
   106  	MOVD	R15, (g_stack+stack_hi)(g)
   107  
   108  	// if there is a _cgo_init, call it using the gcc ABI.
   109  	MOVD	_cgo_init(SB), R11
   110  	CMPBEQ	R11, $0, nocgo
   111  	MOVW	AR0, R4			// (AR0 << 32 | AR1) is the TLS base pointer; MOVD is translated to EAR
   112  	SLD	$32, R4, R4
   113  	MOVW	AR1, R4			// arg 2: TLS base pointer
   114  	MOVD	$setg_gcc<>(SB), R3 	// arg 1: setg
   115  	MOVD	g, R2			// arg 0: G
   116  	// C functions expect 160 bytes of space on caller stack frame
   117  	// and an 8-byte aligned stack pointer
   118  	MOVD	R15, R9			// save current stack (R9 is preserved in the Linux ABI)
   119  	SUB	$160, R15		// reserve 160 bytes
   120  	MOVD    $~7, R6
   121  	AND 	R6, R15			// 8-byte align
   122  	BL	R11			// this call clobbers volatile registers according to Linux ABI (R0-R5, R14)
   123  	MOVD	R9, R15			// restore stack
   124  	XOR	R0, R0			// zero R0
   125  
   126  nocgo:
   127  	// update stackguard after _cgo_init
   128  	MOVD	(g_stack+stack_lo)(g), R2
   129  	ADD	$const__StackGuard, R2
   130  	MOVD	R2, g_stackguard0(g)
   131  	MOVD	R2, g_stackguard1(g)
   132  
   133  	// set the per-goroutine and per-mach "registers"
   134  	MOVD	$runtime·m0(SB), R2
   135  
   136  	// save m->g0 = g0
   137  	MOVD	g, m_g0(R2)
   138  	// save m0 to g0->m
   139  	MOVD	R2, g_m(g)
   140  
   141  	BL	runtime·check(SB)
   142  
   143  	// argc/argv are already prepared on stack
   144  	BL	runtime·args(SB)
   145  	BL	runtime·osinit(SB)
   146  	BL	runtime·schedinit(SB)
   147  
   148  	// create a new goroutine to start program
   149  	MOVD	$runtime·mainPC(SB), R2		// entry
   150  	SUB     $16, R15
   151  	MOVD 	R2, 8(R15)
   152  	MOVD 	$0, 0(R15)
   153  	BL	runtime·newproc(SB)
   154  	ADD	$16, R15
   155  
   156  	// start this M
   157  	BL	runtime·mstart(SB)
   158  
   159  	MOVD	$0, 1(R0)
   160  	RET
   161  
   162  DATA	runtime·mainPC+0(SB)/8,$runtime·main(SB)
   163  GLOBL	runtime·mainPC(SB),RODATA,$8
   164  
   165  TEXT runtime·breakpoint(SB),NOSPLIT|NOFRAME,$0-0
   166  	MOVD	$0, 2(R0)
   167  	RET
   168  
   169  TEXT runtime·asminit(SB),NOSPLIT|NOFRAME,$0-0
   170  	RET
   171  
   172  TEXT runtime·mstart(SB),NOSPLIT|TOPFRAME,$0
   173  	CALL	runtime·mstart0(SB)
   174  	RET // not reached
   175  
   176  /*
   177   *  go-routine
   178   */
   179  
   180  // void gogo(Gobuf*)
   181  // restore state from Gobuf; longjmp
   182  TEXT runtime·gogo(SB), NOSPLIT|NOFRAME, $0-8
   183  	MOVD	buf+0(FP), R5
   184  	MOVD	gobuf_g(R5), R6
   185  	MOVD	0(R6), R7	// make sure g != nil
   186  	BR	gogo<>(SB)
   187  
   188  TEXT gogo<>(SB), NOSPLIT|NOFRAME, $0
   189  	MOVD	R6, g
   190  	BL	runtime·save_g(SB)
   191  
   192  	MOVD	0(g), R4
   193  	MOVD	gobuf_sp(R5), R15
   194  	MOVD	gobuf_lr(R5), LR
   195  	MOVD	gobuf_ret(R5), R3
   196  	MOVD	gobuf_ctxt(R5), R12
   197  	MOVD	$0, gobuf_sp(R5)
   198  	MOVD	$0, gobuf_ret(R5)
   199  	MOVD	$0, gobuf_lr(R5)
   200  	MOVD	$0, gobuf_ctxt(R5)
   201  	CMP	R0, R0 // set condition codes for == test, needed by stack split
   202  	MOVD	gobuf_pc(R5), R6
   203  	BR	(R6)
   204  
   205  // void mcall(fn func(*g))
   206  // Switch to m->g0's stack, call fn(g).
   207  // Fn must never return.  It should gogo(&g->sched)
   208  // to keep running g.
   209  TEXT runtime·mcall(SB), NOSPLIT, $-8-8
   210  	// Save caller state in g->sched
   211  	MOVD	R15, (g_sched+gobuf_sp)(g)
   212  	MOVD	LR, (g_sched+gobuf_pc)(g)
   213  	MOVD	$0, (g_sched+gobuf_lr)(g)
   214  
   215  	// Switch to m->g0 & its stack, call fn.
   216  	MOVD	g, R3
   217  	MOVD	g_m(g), R8
   218  	MOVD	m_g0(R8), g
   219  	BL	runtime·save_g(SB)
   220  	CMP	g, R3
   221  	BNE	2(PC)
   222  	BR	runtime·badmcall(SB)
   223  	MOVD	fn+0(FP), R12			// context
   224  	MOVD	0(R12), R4			// code pointer
   225  	MOVD	(g_sched+gobuf_sp)(g), R15	// sp = m->g0->sched.sp
   226  	SUB	$16, R15
   227  	MOVD	R3, 8(R15)
   228  	MOVD	$0, 0(R15)
   229  	BL	(R4)
   230  	BR	runtime·badmcall2(SB)
   231  
   232  // systemstack_switch is a dummy routine that systemstack leaves at the bottom
   233  // of the G stack.  We need to distinguish the routine that
   234  // lives at the bottom of the G stack from the one that lives
   235  // at the top of the system stack because the one at the top of
   236  // the system stack terminates the stack walk (see topofstack()).
   237  TEXT runtime·systemstack_switch(SB), NOSPLIT, $0-0
   238  	UNDEF
   239  	BL	(LR)	// make sure this function is not leaf
   240  	RET
   241  
   242  // func systemstack(fn func())
   243  TEXT runtime·systemstack(SB), NOSPLIT, $0-8
   244  	MOVD	fn+0(FP), R3	// R3 = fn
   245  	MOVD	R3, R12		// context
   246  	MOVD	g_m(g), R4	// R4 = m
   247  
   248  	MOVD	m_gsignal(R4), R5	// R5 = gsignal
   249  	CMPBEQ	g, R5, noswitch
   250  
   251  	MOVD	m_g0(R4), R5	// R5 = g0
   252  	CMPBEQ	g, R5, noswitch
   253  
   254  	MOVD	m_curg(R4), R6
   255  	CMPBEQ	g, R6, switch
   256  
   257  	// Bad: g is not gsignal, not g0, not curg. What is it?
   258  	// Hide call from linker nosplit analysis.
   259  	MOVD	$runtime·badsystemstack(SB), R3
   260  	BL	(R3)
   261  	BL	runtime·abort(SB)
   262  
   263  switch:
   264  	// save our state in g->sched.  Pretend to
   265  	// be systemstack_switch if the G stack is scanned.
   266  	BL	gosave_systemstack_switch<>(SB)
   267  
   268  	// switch to g0
   269  	MOVD	R5, g
   270  	BL	runtime·save_g(SB)
   271  	MOVD	(g_sched+gobuf_sp)(g), R15
   272  
   273  	// call target function
   274  	MOVD	0(R12), R3	// code pointer
   275  	BL	(R3)
   276  
   277  	// switch back to g
   278  	MOVD	g_m(g), R3
   279  	MOVD	m_curg(R3), g
   280  	BL	runtime·save_g(SB)
   281  	MOVD	(g_sched+gobuf_sp)(g), R15
   282  	MOVD	$0, (g_sched+gobuf_sp)(g)
   283  	RET
   284  
   285  noswitch:
   286  	// already on m stack, just call directly
   287  	// Using a tail call here cleans up tracebacks since we won't stop
   288  	// at an intermediate systemstack.
   289  	MOVD	0(R12), R3	// code pointer
   290  	MOVD	0(R15), LR	// restore LR
   291  	ADD	$8, R15
   292  	BR	(R3)
   293  
   294  /*
   295   * support for morestack
   296   */
   297  
   298  // Called during function prolog when more stack is needed.
   299  // Caller has already loaded:
   300  // R3: framesize, R4: argsize, R5: LR
   301  //
   302  // The traceback routines see morestack on a g0 as being
   303  // the top of a stack (for example, morestack calling newstack
   304  // calling the scheduler calling newm calling gc), so we must
   305  // record an argument size. For that purpose, it has no arguments.
   306  TEXT runtime·morestack(SB),NOSPLIT|NOFRAME,$0-0
   307  	// Cannot grow scheduler stack (m->g0).
   308  	MOVD	g_m(g), R7
   309  	MOVD	m_g0(R7), R8
   310  	CMPBNE	g, R8, 3(PC)
   311  	BL	runtime·badmorestackg0(SB)
   312  	BL	runtime·abort(SB)
   313  
   314  	// Cannot grow signal stack (m->gsignal).
   315  	MOVD	m_gsignal(R7), R8
   316  	CMP	g, R8
   317  	BNE	3(PC)
   318  	BL	runtime·badmorestackgsignal(SB)
   319  	BL	runtime·abort(SB)
   320  
   321  	// Called from f.
   322  	// Set g->sched to context in f.
   323  	MOVD	R15, (g_sched+gobuf_sp)(g)
   324  	MOVD	LR, R8
   325  	MOVD	R8, (g_sched+gobuf_pc)(g)
   326  	MOVD	R5, (g_sched+gobuf_lr)(g)
   327  	MOVD	R12, (g_sched+gobuf_ctxt)(g)
   328  
   329  	// Called from f.
   330  	// Set m->morebuf to f's caller.
   331  	MOVD	R5, (m_morebuf+gobuf_pc)(R7)	// f's caller's PC
   332  	MOVD	R15, (m_morebuf+gobuf_sp)(R7)	// f's caller's SP
   333  	MOVD	g, (m_morebuf+gobuf_g)(R7)
   334  
   335  	// Call newstack on m->g0's stack.
   336  	MOVD	m_g0(R7), g
   337  	BL	runtime·save_g(SB)
   338  	MOVD	(g_sched+gobuf_sp)(g), R15
   339  	// Create a stack frame on g0 to call newstack.
   340  	MOVD	$0, -8(R15)	// Zero saved LR in frame
   341  	SUB	$8, R15
   342  	BL	runtime·newstack(SB)
   343  
   344  	// Not reached, but make sure the return PC from the call to newstack
   345  	// is still in this function, and not the beginning of the next.
   346  	UNDEF
   347  
   348  TEXT runtime·morestack_noctxt(SB),NOSPLIT|NOFRAME,$0-0
   349  	// Force SPWRITE. This function doesn't actually write SP,
   350  	// but it is called with a special calling convention where
   351  	// the caller doesn't save LR on stack but passes it as a
   352  	// register (R5), and the unwinder currently doesn't understand.
   353  	// Make it SPWRITE to stop unwinding. (See issue 54332)
   354  	MOVD	R15, R15
   355  
   356  	MOVD	$0, R12
   357  	BR	runtime·morestack(SB)
   358  
   359  // reflectcall: call a function with the given argument list
   360  // func call(stackArgsType *_type, f *FuncVal, stackArgs *byte, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs).
   361  // we don't have variable-sized frames, so we use a small number
   362  // of constant-sized-frame functions to encode a few bits of size in the pc.
   363  // Caution: ugly multiline assembly macros in your future!
   364  
   365  #define DISPATCH(NAME,MAXSIZE)		\
   366  	MOVD	$MAXSIZE, R4;		\
   367  	CMP	R3, R4;		\
   368  	BGT	3(PC);			\
   369  	MOVD	$NAME(SB), R5;	\
   370  	BR	(R5)
   371  // Note: can't just "BR NAME(SB)" - bad inlining results.
   372  
   373  TEXT ·reflectcall(SB), NOSPLIT, $-8-48
   374  	MOVWZ	frameSize+32(FP), R3
   375  	DISPATCH(runtime·call16, 16)
   376  	DISPATCH(runtime·call32, 32)
   377  	DISPATCH(runtime·call64, 64)
   378  	DISPATCH(runtime·call128, 128)
   379  	DISPATCH(runtime·call256, 256)
   380  	DISPATCH(runtime·call512, 512)
   381  	DISPATCH(runtime·call1024, 1024)
   382  	DISPATCH(runtime·call2048, 2048)
   383  	DISPATCH(runtime·call4096, 4096)
   384  	DISPATCH(runtime·call8192, 8192)
   385  	DISPATCH(runtime·call16384, 16384)
   386  	DISPATCH(runtime·call32768, 32768)
   387  	DISPATCH(runtime·call65536, 65536)
   388  	DISPATCH(runtime·call131072, 131072)
   389  	DISPATCH(runtime·call262144, 262144)
   390  	DISPATCH(runtime·call524288, 524288)
   391  	DISPATCH(runtime·call1048576, 1048576)
   392  	DISPATCH(runtime·call2097152, 2097152)
   393  	DISPATCH(runtime·call4194304, 4194304)
   394  	DISPATCH(runtime·call8388608, 8388608)
   395  	DISPATCH(runtime·call16777216, 16777216)
   396  	DISPATCH(runtime·call33554432, 33554432)
   397  	DISPATCH(runtime·call67108864, 67108864)
   398  	DISPATCH(runtime·call134217728, 134217728)
   399  	DISPATCH(runtime·call268435456, 268435456)
   400  	DISPATCH(runtime·call536870912, 536870912)
   401  	DISPATCH(runtime·call1073741824, 1073741824)
   402  	MOVD	$runtime·badreflectcall(SB), R5
   403  	BR	(R5)
   404  
   405  #define CALLFN(NAME,MAXSIZE)			\
   406  TEXT NAME(SB), WRAPPER, $MAXSIZE-48;		\
   407  	NO_LOCAL_POINTERS;			\
   408  	/* copy arguments to stack */		\
   409  	MOVD	stackArgs+16(FP), R4;			\
   410  	MOVWZ	stackArgsSize+24(FP), R5;		\
   411  	MOVD	$stack-MAXSIZE(SP), R6;		\
   412  loopArgs: /* copy 256 bytes at a time */	\
   413  	CMP	R5, $256;			\
   414  	BLT	tailArgs;			\
   415  	SUB	$256, R5;			\
   416  	MVC	$256, 0(R4), 0(R6);		\
   417  	MOVD	$256(R4), R4;			\
   418  	MOVD	$256(R6), R6;			\
   419  	BR	loopArgs;			\
   420  tailArgs: /* copy remaining bytes */		\
   421  	CMP	R5, $0;				\
   422  	BEQ	callFunction;			\
   423  	SUB	$1, R5;				\
   424  	EXRL	$callfnMVC<>(SB), R5;		\
   425  callFunction:					\
   426  	MOVD	f+8(FP), R12;			\
   427  	MOVD	(R12), R8;			\
   428  	PCDATA  $PCDATA_StackMapIndex, $0;	\
   429  	BL	(R8);				\
   430  	/* copy return values back */		\
   431  	MOVD	stackArgsType+0(FP), R7;		\
   432  	MOVD	stackArgs+16(FP), R6;			\
   433  	MOVWZ	stackArgsSize+24(FP), R5;			\
   434  	MOVD	$stack-MAXSIZE(SP), R4;		\
   435  	MOVWZ	stackRetOffset+28(FP), R1;		\
   436  	ADD	R1, R4;				\
   437  	ADD	R1, R6;				\
   438  	SUB	R1, R5;				\
   439  	BL	callRet<>(SB);			\
   440  	RET
   441  
   442  // callRet copies return values back at the end of call*. This is a
   443  // separate function so it can allocate stack space for the arguments
   444  // to reflectcallmove. It does not follow the Go ABI; it expects its
   445  // arguments in registers.
   446  TEXT callRet<>(SB), NOSPLIT, $40-0
   447  	MOVD	R7, 8(R15)
   448  	MOVD	R6, 16(R15)
   449  	MOVD	R4, 24(R15)
   450  	MOVD	R5, 32(R15)
   451  	MOVD	$0, 40(R15)
   452  	BL	runtime·reflectcallmove(SB)
   453  	RET
   454  
   455  CALLFN(·call16, 16)
   456  CALLFN(·call32, 32)
   457  CALLFN(·call64, 64)
   458  CALLFN(·call128, 128)
   459  CALLFN(·call256, 256)
   460  CALLFN(·call512, 512)
   461  CALLFN(·call1024, 1024)
   462  CALLFN(·call2048, 2048)
   463  CALLFN(·call4096, 4096)
   464  CALLFN(·call8192, 8192)
   465  CALLFN(·call16384, 16384)
   466  CALLFN(·call32768, 32768)
   467  CALLFN(·call65536, 65536)
   468  CALLFN(·call131072, 131072)
   469  CALLFN(·call262144, 262144)
   470  CALLFN(·call524288, 524288)
   471  CALLFN(·call1048576, 1048576)
   472  CALLFN(·call2097152, 2097152)
   473  CALLFN(·call4194304, 4194304)
   474  CALLFN(·call8388608, 8388608)
   475  CALLFN(·call16777216, 16777216)
   476  CALLFN(·call33554432, 33554432)
   477  CALLFN(·call67108864, 67108864)
   478  CALLFN(·call134217728, 134217728)
   479  CALLFN(·call268435456, 268435456)
   480  CALLFN(·call536870912, 536870912)
   481  CALLFN(·call1073741824, 1073741824)
   482  
   483  // Not a function: target for EXRL (execute relative long) instruction.
   484  TEXT callfnMVC<>(SB),NOSPLIT|NOFRAME,$0-0
   485  	MVC	$1, 0(R4), 0(R6)
   486  
   487  TEXT runtime·procyield(SB),NOSPLIT,$0-0
   488  	RET
   489  
   490  // Save state of caller into g->sched,
   491  // but using fake PC from systemstack_switch.
   492  // Must only be called from functions with no locals ($0)
   493  // or else unwinding from systemstack_switch is incorrect.
   494  // Smashes R1.
   495  TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$0
   496  	MOVD	$runtime·systemstack_switch(SB), R1
   497  	ADD	$16, R1	// get past prologue
   498  	MOVD	R1, (g_sched+gobuf_pc)(g)
   499  	MOVD	R15, (g_sched+gobuf_sp)(g)
   500  	MOVD	$0, (g_sched+gobuf_lr)(g)
   501  	MOVD	$0, (g_sched+gobuf_ret)(g)
   502  	// Assert ctxt is zero. See func save.
   503  	MOVD	(g_sched+gobuf_ctxt)(g), R1
   504  	CMPBEQ	R1, $0, 2(PC)
   505  	BL	runtime·abort(SB)
   506  	RET
   507  
   508  // func asmcgocall(fn, arg unsafe.Pointer) int32
   509  // Call fn(arg) on the scheduler stack,
   510  // aligned appropriately for the gcc ABI.
   511  // See cgocall.go for more details.
   512  TEXT ·asmcgocall(SB),NOSPLIT,$0-20
   513  	// R2 = argc; R3 = argv; R11 = temp; R13 = g; R15 = stack pointer
   514  	// C TLS base pointer in AR0:AR1
   515  	MOVD	fn+0(FP), R3
   516  	MOVD	arg+8(FP), R4
   517  
   518  	MOVD	R15, R2		// save original stack pointer
   519  	MOVD	g, R5
   520  
   521  	// Figure out if we need to switch to m->g0 stack.
   522  	// We get called to create new OS threads too, and those
   523  	// come in on the m->g0 stack already. Or we might already
   524  	// be on the m->gsignal stack.
   525  	MOVD	g_m(g), R6
   526  	MOVD	m_gsignal(R6), R7
   527  	CMPBEQ	R7, g, g0
   528  	MOVD	m_g0(R6), R7
   529  	CMPBEQ	R7, g, g0
   530  	BL	gosave_systemstack_switch<>(SB)
   531  	MOVD	R7, g
   532  	BL	runtime·save_g(SB)
   533  	MOVD	(g_sched+gobuf_sp)(g), R15
   534  
   535  	// Now on a scheduling stack (a pthread-created stack).
   536  g0:
   537  	// Save room for two of our pointers, plus 160 bytes of callee
   538  	// save area that lives on the caller stack.
   539  	SUB	$176, R15
   540  	MOVD	$~7, R6
   541  	AND	R6, R15                 // 8-byte alignment for gcc ABI
   542  	MOVD	R5, 168(R15)             // save old g on stack
   543  	MOVD	(g_stack+stack_hi)(R5), R5
   544  	SUB	R2, R5
   545  	MOVD	R5, 160(R15)             // save depth in old g stack (can't just save SP, as stack might be copied during a callback)
   546  	MOVD	$0, 0(R15)              // clear back chain pointer (TODO can we give it real back trace information?)
   547  	MOVD	R4, R2                  // arg in R2
   548  	BL	R3                      // can clobber: R0-R5, R14, F0-F3, F5, F7-F15
   549  
   550  	XOR	R0, R0                  // set R0 back to 0.
   551  	// Restore g, stack pointer.
   552  	MOVD	168(R15), g
   553  	BL	runtime·save_g(SB)
   554  	MOVD	(g_stack+stack_hi)(g), R5
   555  	MOVD	160(R15), R6
   556  	SUB	R6, R5
   557  	MOVD	R5, R15
   558  
   559  	MOVW	R2, ret+16(FP)
   560  	RET
   561  
   562  // cgocallback(fn, frame unsafe.Pointer, ctxt uintptr)
   563  // See cgocall.go for more details.
   564  TEXT ·cgocallback(SB),NOSPLIT,$24-24
   565  	NO_LOCAL_POINTERS
   566  
   567  	// Load m and g from thread-local storage.
   568  	MOVB	runtime·iscgo(SB), R3
   569  	CMPBEQ	R3, $0, nocgo
   570  	BL	runtime·load_g(SB)
   571  
   572  nocgo:
   573  	// If g is nil, Go did not create the current thread.
   574  	// Call needm to obtain one for temporary use.
   575  	// In this case, we're running on the thread stack, so there's
   576  	// lots of space, but the linker doesn't know. Hide the call from
   577  	// the linker analysis by using an indirect call.
   578  	CMPBEQ	g, $0, needm
   579  
   580  	MOVD	g_m(g), R8
   581  	MOVD	R8, savedm-8(SP)
   582  	BR	havem
   583  
   584  needm:
   585  	MOVD	g, savedm-8(SP) // g is zero, so is m.
   586  	MOVD	$runtime·needm(SB), R3
   587  	BL	(R3)
   588  
   589  	// Set m->sched.sp = SP, so that if a panic happens
   590  	// during the function we are about to execute, it will
   591  	// have a valid SP to run on the g0 stack.
   592  	// The next few lines (after the havem label)
   593  	// will save this SP onto the stack and then write
   594  	// the same SP back to m->sched.sp. That seems redundant,
   595  	// but if an unrecovered panic happens, unwindm will
   596  	// restore the g->sched.sp from the stack location
   597  	// and then systemstack will try to use it. If we don't set it here,
   598  	// that restored SP will be uninitialized (typically 0) and
   599  	// will not be usable.
   600  	MOVD	g_m(g), R8
   601  	MOVD	m_g0(R8), R3
   602  	MOVD	R15, (g_sched+gobuf_sp)(R3)
   603  
   604  havem:
   605  	// Now there's a valid m, and we're running on its m->g0.
   606  	// Save current m->g0->sched.sp on stack and then set it to SP.
   607  	// Save current sp in m->g0->sched.sp in preparation for
   608  	// switch back to m->curg stack.
   609  	// NOTE: unwindm knows that the saved g->sched.sp is at 8(R1) aka savedsp-16(SP).
   610  	MOVD	m_g0(R8), R3
   611  	MOVD	(g_sched+gobuf_sp)(R3), R4
   612  	MOVD	R4, savedsp-24(SP)	// must match frame size
   613  	MOVD	R15, (g_sched+gobuf_sp)(R3)
   614  
   615  	// Switch to m->curg stack and call runtime.cgocallbackg.
   616  	// Because we are taking over the execution of m->curg
   617  	// but *not* resuming what had been running, we need to
   618  	// save that information (m->curg->sched) so we can restore it.
   619  	// We can restore m->curg->sched.sp easily, because calling
   620  	// runtime.cgocallbackg leaves SP unchanged upon return.
   621  	// To save m->curg->sched.pc, we push it onto the curg stack and
   622  	// open a frame the same size as cgocallback's g0 frame.
   623  	// Once we switch to the curg stack, the pushed PC will appear
   624  	// to be the return PC of cgocallback, so that the traceback
   625  	// will seamlessly trace back into the earlier calls.
   626  	MOVD	m_curg(R8), g
   627  	BL	runtime·save_g(SB)
   628  	MOVD	(g_sched+gobuf_sp)(g), R4 // prepare stack as R4
   629  	MOVD	(g_sched+gobuf_pc)(g), R5
   630  	MOVD	R5, -(24+8)(R4)	// "saved LR"; must match frame size
   631  	// Gather our arguments into registers.
   632  	MOVD	fn+0(FP), R1
   633  	MOVD	frame+8(FP), R2
   634  	MOVD	ctxt+16(FP), R3
   635  	MOVD	$-(24+8)(R4), R15	// switch stack; must match frame size
   636  	MOVD	R1, 8(R15)
   637  	MOVD	R2, 16(R15)
   638  	MOVD	R3, 24(R15)
   639  	BL	runtime·cgocallbackg(SB)
   640  
   641  	// Restore g->sched (== m->curg->sched) from saved values.
   642  	MOVD	0(R15), R5
   643  	MOVD	R5, (g_sched+gobuf_pc)(g)
   644  	MOVD	$(24+8)(R15), R4	// must match frame size
   645  	MOVD	R4, (g_sched+gobuf_sp)(g)
   646  
   647  	// Switch back to m->g0's stack and restore m->g0->sched.sp.
   648  	// (Unlike m->curg, the g0 goroutine never uses sched.pc,
   649  	// so we do not have to restore it.)
   650  	MOVD	g_m(g), R8
   651  	MOVD	m_g0(R8), g
   652  	BL	runtime·save_g(SB)
   653  	MOVD	(g_sched+gobuf_sp)(g), R15
   654  	MOVD	savedsp-24(SP), R4	// must match frame size
   655  	MOVD	R4, (g_sched+gobuf_sp)(g)
   656  
   657  	// If the m on entry was nil, we called needm above to borrow an m
   658  	// for the duration of the call. Since the call is over, return it with dropm.
   659  	MOVD	savedm-8(SP), R6
   660  	CMPBNE	R6, $0, droppedm
   661  	MOVD	$runtime·dropm(SB), R3
   662  	BL	(R3)
   663  droppedm:
   664  
   665  	// Done!
   666  	RET
   667  
   668  // void setg(G*); set g. for use by needm.
   669  TEXT runtime·setg(SB), NOSPLIT, $0-8
   670  	MOVD	gg+0(FP), g
   671  	// This only happens if iscgo, so jump straight to save_g
   672  	BL	runtime·save_g(SB)
   673  	RET
   674  
   675  // void setg_gcc(G*); set g in C TLS.
   676  // Must obey the gcc calling convention.
   677  TEXT setg_gcc<>(SB),NOSPLIT|NOFRAME,$0-0
   678  	// The standard prologue clobbers LR (R14), which is callee-save in
   679  	// the C ABI, so we have to use NOFRAME and save LR ourselves.
   680  	MOVD	LR, R1
   681  	// Also save g, R10, and R11 since they're callee-save in C ABI
   682  	MOVD	R10, R3
   683  	MOVD	g, R4
   684  	MOVD	R11, R5
   685  
   686  	MOVD	R2, g
   687  	BL	runtime·save_g(SB)
   688  
   689  	MOVD	R5, R11
   690  	MOVD	R4, g
   691  	MOVD	R3, R10
   692  	MOVD	R1, LR
   693  	RET
   694  
   695  TEXT runtime·abort(SB),NOSPLIT|NOFRAME,$0-0
   696  	MOVW	(R0), R0
   697  	UNDEF
   698  
   699  // int64 runtime·cputicks(void)
   700  TEXT runtime·cputicks(SB),NOSPLIT,$0-8
   701  	// The TOD clock on s390 counts from the year 1900 in ~250ps intervals.
   702  	// This means that since about 1972 the msb has been set, making the
   703  	// result of a call to STORE CLOCK (stck) a negative number.
   704  	// We clear the msb to make it positive.
   705  	STCK	ret+0(FP)      // serialises before and after call
   706  	MOVD	ret+0(FP), R3  // R3 will wrap to 0 in the year 2043
   707  	SLD	$1, R3
   708  	SRD	$1, R3
   709  	MOVD	R3, ret+0(FP)
   710  	RET
   711  
   712  // AES hashing not implemented for s390x
   713  TEXT runtime·memhash(SB),NOSPLIT|NOFRAME,$0-32
   714  	JMP	runtime·memhashFallback(SB)
   715  TEXT runtime·strhash(SB),NOSPLIT|NOFRAME,$0-24
   716  	JMP	runtime·strhashFallback(SB)
   717  TEXT runtime·memhash32(SB),NOSPLIT|NOFRAME,$0-24
   718  	JMP	runtime·memhash32Fallback(SB)
   719  TEXT runtime·memhash64(SB),NOSPLIT|NOFRAME,$0-24
   720  	JMP	runtime·memhash64Fallback(SB)
   721  
   722  TEXT runtime·return0(SB), NOSPLIT, $0
   723  	MOVW	$0, R3
   724  	RET
   725  
   726  // Called from cgo wrappers, this function returns g->m->curg.stack.hi.
   727  // Must obey the gcc calling convention.
   728  TEXT _cgo_topofstack(SB),NOSPLIT|NOFRAME,$0
   729  	// g (R13), R10, R11 and LR (R14) are callee-save in the C ABI, so save them
   730  	MOVD	g, R1
   731  	MOVD	R10, R3
   732  	MOVD	LR, R4
   733  	MOVD	R11, R5
   734  
   735  	BL	runtime·load_g(SB)	// clobbers g (R13), R10, R11
   736  	MOVD	g_m(g), R2
   737  	MOVD	m_curg(R2), R2
   738  	MOVD	(g_stack+stack_hi)(R2), R2
   739  
   740  	MOVD	R1, g
   741  	MOVD	R3, R10
   742  	MOVD	R4, LR
   743  	MOVD	R5, R11
   744  	RET
   745  
   746  // The top-most function running on a goroutine
   747  // returns to goexit+PCQuantum.
   748  TEXT runtime·goexit(SB),NOSPLIT|NOFRAME|TOPFRAME,$0-0
   749  	BYTE $0x07; BYTE $0x00; // 2-byte nop
   750  	BL	runtime·goexit1(SB)	// does not return
   751  	// traceback from goexit1 must hit code range of goexit
   752  	BYTE $0x07; BYTE $0x00; // 2-byte nop
   753  
   754  TEXT ·publicationBarrier(SB),NOSPLIT|NOFRAME,$0-0
   755  	// Stores are already ordered on s390x, so this is just a
   756  	// compile barrier.
   757  	RET
   758  
   759  // This is called from .init_array and follows the platform, not Go, ABI.
   760  // We are overly conservative. We could only save the registers we use.
   761  // However, since this function is only called once per loaded module
   762  // performance is unimportant.
   763  TEXT runtime·addmoduledata(SB),NOSPLIT|NOFRAME,$0-0
   764  	// Save R6-R15 in the register save area of the calling function.
   765  	// Don't bother saving F8-F15 as we aren't doing any calls.
   766  	STMG	R6, R15, 48(R15)
   767  
   768  	// append the argument (passed in R2, as per the ELF ABI) to the
   769  	// moduledata linked list.
   770  	MOVD	runtime·lastmoduledatap(SB), R1
   771  	MOVD	R2, moduledata_next(R1)
   772  	MOVD	R2, runtime·lastmoduledatap(SB)
   773  
   774  	// Restore R6-R15.
   775  	LMG	48(R15), R6, R15
   776  	RET
   777  
   778  TEXT ·checkASM(SB),NOSPLIT,$0-1
   779  	MOVB	$1, ret+0(FP)
   780  	RET
   781  
   782  // gcWriteBarrier performs a heap pointer write and informs the GC.
   783  //
   784  // gcWriteBarrier does NOT follow the Go ABI. It takes two arguments:
   785  // - R2 is the destination of the write
   786  // - R3 is the value being written at R2.
   787  // It clobbers R10 (the temp register) and R1 (used by PLT stub).
   788  // It does not clobber any other general-purpose registers,
   789  // but may clobber others (e.g., floating point registers).
   790  TEXT runtime·gcWriteBarrier(SB),NOSPLIT,$96
   791  	// Save the registers clobbered by the fast path.
   792  	MOVD	R4, 96(R15)
   793  	MOVD	g_m(g), R1
   794  	MOVD	m_p(R1), R1
   795  	// Increment wbBuf.next position.
   796  	MOVD	$16, R4
   797  	ADD	(p_wbBuf+wbBuf_next)(R1), R4
   798  	MOVD	R4, (p_wbBuf+wbBuf_next)(R1)
   799  	MOVD	(p_wbBuf+wbBuf_end)(R1), R1
   800  	// Record the write.
   801  	MOVD	R3, -16(R4) // Record value
   802  	MOVD	(R2), R10   // TODO: This turns bad writes into bad reads.
   803  	MOVD	R10, -8(R4) // Record *slot
   804  	// Is the buffer full?
   805  	CMPBEQ	R4, R1, flush
   806  ret:
   807  	MOVD	96(R15), R4
   808  	// Do the write.
   809  	MOVD	R3, (R2)
   810  	RET
   811  
   812  flush:
   813  	// Save all general purpose registers since these could be
   814  	// clobbered by wbBufFlush and were not saved by the caller.
   815  	STMG	R2, R3, 8(R15)   // set R2 and R3 as arguments for wbBufFlush
   816  	MOVD	R0, 24(R15)
   817  	// R1 already saved.
   818  	// R4 already saved.
   819  	STMG	R5, R12, 32(R15) // save R5 - R12
   820  	// R13 is g.
   821  	// R14 is LR.
   822  	// R15 is SP.
   823  
   824  	// This takes arguments R2 and R3.
   825  	CALL	runtime·wbBufFlush(SB)
   826  
   827  	LMG	8(R15), R2, R3   // restore R2 - R3
   828  	MOVD	24(R15), R0      // restore R0
   829  	LMG	32(R15), R5, R12 // restore R5 - R12
   830  	JMP	ret
   831  
   832  // Note: these functions use a special calling convention to save generated code space.
   833  // Arguments are passed in registers, but the space for those arguments are allocated
   834  // in the caller's stack frame. These stubs write the args into that stack space and
   835  // then tail call to the corresponding runtime handler.
   836  // The tail call makes these stubs disappear in backtraces.
   837  TEXT runtime·panicIndex(SB),NOSPLIT,$0-16
   838  	MOVD	R0, x+0(FP)
   839  	MOVD	R1, y+8(FP)
   840  	JMP	runtime·goPanicIndex(SB)
   841  TEXT runtime·panicIndexU(SB),NOSPLIT,$0-16
   842  	MOVD	R0, x+0(FP)
   843  	MOVD	R1, y+8(FP)
   844  	JMP	runtime·goPanicIndexU(SB)
   845  TEXT runtime·panicSliceAlen(SB),NOSPLIT,$0-16
   846  	MOVD	R1, x+0(FP)
   847  	MOVD	R2, y+8(FP)
   848  	JMP	runtime·goPanicSliceAlen(SB)
   849  TEXT runtime·panicSliceAlenU(SB),NOSPLIT,$0-16
   850  	MOVD	R1, x+0(FP)
   851  	MOVD	R2, y+8(FP)
   852  	JMP	runtime·goPanicSliceAlenU(SB)
   853  TEXT runtime·panicSliceAcap(SB),NOSPLIT,$0-16
   854  	MOVD	R1, x+0(FP)
   855  	MOVD	R2, y+8(FP)
   856  	JMP	runtime·goPanicSliceAcap(SB)
   857  TEXT runtime·panicSliceAcapU(SB),NOSPLIT,$0-16
   858  	MOVD	R1, x+0(FP)
   859  	MOVD	R2, y+8(FP)
   860  	JMP	runtime·goPanicSliceAcapU(SB)
   861  TEXT runtime·panicSliceB(SB),NOSPLIT,$0-16
   862  	MOVD	R0, x+0(FP)
   863  	MOVD	R1, y+8(FP)
   864  	JMP	runtime·goPanicSliceB(SB)
   865  TEXT runtime·panicSliceBU(SB),NOSPLIT,$0-16
   866  	MOVD	R0, x+0(FP)
   867  	MOVD	R1, y+8(FP)
   868  	JMP	runtime·goPanicSliceBU(SB)
   869  TEXT runtime·panicSlice3Alen(SB),NOSPLIT,$0-16
   870  	MOVD	R2, x+0(FP)
   871  	MOVD	R3, y+8(FP)
   872  	JMP	runtime·goPanicSlice3Alen(SB)
   873  TEXT runtime·panicSlice3AlenU(SB),NOSPLIT,$0-16
   874  	MOVD	R2, x+0(FP)
   875  	MOVD	R3, y+8(FP)
   876  	JMP	runtime·goPanicSlice3AlenU(SB)
   877  TEXT runtime·panicSlice3Acap(SB),NOSPLIT,$0-16
   878  	MOVD	R2, x+0(FP)
   879  	MOVD	R3, y+8(FP)
   880  	JMP	runtime·goPanicSlice3Acap(SB)
   881  TEXT runtime·panicSlice3AcapU(SB),NOSPLIT,$0-16
   882  	MOVD	R2, x+0(FP)
   883  	MOVD	R3, y+8(FP)
   884  	JMP	runtime·goPanicSlice3AcapU(SB)
   885  TEXT runtime·panicSlice3B(SB),NOSPLIT,$0-16
   886  	MOVD	R1, x+0(FP)
   887  	MOVD	R2, y+8(FP)
   888  	JMP	runtime·goPanicSlice3B(SB)
   889  TEXT runtime·panicSlice3BU(SB),NOSPLIT,$0-16
   890  	MOVD	R1, x+0(FP)
   891  	MOVD	R2, y+8(FP)
   892  	JMP	runtime·goPanicSlice3BU(SB)
   893  TEXT runtime·panicSlice3C(SB),NOSPLIT,$0-16
   894  	MOVD	R0, x+0(FP)
   895  	MOVD	R1, y+8(FP)
   896  	JMP	runtime·goPanicSlice3C(SB)
   897  TEXT runtime·panicSlice3CU(SB),NOSPLIT,$0-16
   898  	MOVD	R0, x+0(FP)
   899  	MOVD	R1, y+8(FP)
   900  	JMP	runtime·goPanicSlice3CU(SB)
   901  TEXT runtime·panicSliceConvert(SB),NOSPLIT,$0-16
   902  	MOVD	R2, x+0(FP)
   903  	MOVD	R3, y+8(FP)
   904  	JMP	runtime·goPanicSliceConvert(SB)
   905  

View as plain text