libgcc patch committed: Improve calling non-split-stack code

[Ian Lance Taylor <iant at google dot com>]

When the gold linker sees a call from -fsplit-stack code to code
compiled without -fsplit-stack, it arranges for the function to call
__morestack_non_split instead of __morestack.  The __morestack_non_split
function requests a larger stack, one that is large enough to run code
which doesn't know about split stacks.

In libgo.so, many functions refer to TLS variables, which means that
they are calling the function __tls_get_addr, which is in libc and is
not compiled with -fsplit-stack.  This means that many libgo functions
always split the stack.  In particular, many libgo functions always
split the stack, and then call other libgo functions which themselves
always split the stack.  This leads to the stack being split many times,
far more than necessary.

This libgcc patch to __morestack_non_split partially avoids this
problem.  Before this patch, __morestack_non_split would always simply
increment the requested stack size by 0x4000 and carry on, thus always
splitting the stack.  This patch changes it to first see whether there
is enough space on the current stack to handle the requested stack size
plus 0x4000.  If there is enough space, then it simply returns without
splitting the stack.  If there is not enough space, then it increments
the requested stack size by 0x5000.  The effect of this change is that
the first function which calls non-split-stack code allocates a large
stack, and that functions which it calls in turn can continue using the
same large stack (up to a point, of course).

Splitting the stack requires blocking and unblocking signals, which is a
system call.  Making this change reduced the number of times that the
libgo net/http testsuite calls sigprogmask from 3604100 to 26597, which
is about a 99%.

Bootstrapped and ran Go testsuite on x86_64-unknown-linux-gnu.  Also ran
the split-stack C tests.  Committed to mainline.

Ian

Index: config/i386/morestack.S
===================================================================
--- config/i386/morestack.S	(revision 182418)
+++ config/i386/morestack.S	(working copy)
@@ -96,13 +96,113 @@
 #endif
 
 __morestack_non_split:
+	.cfi_startproc
 
 #ifndef __x86_64__
-	addl	$0x4000,4(%esp)
+
+	# See below for an extended explanation of the CFI instructions.
+	.cfi_offset 8, 8		# New PC stored at CFA + 8
+	.cfi_escape 0x15, 4, 0x7d	# DW_CFA_val_offset_sf, %esp, 12/-4
+					# i.e., next %esp is CFA + 12
+
+	pushl	%eax			# Save %eax in case it is a parameter.
+
+	.cfi_def_cfa %esp,8		# Account for pushed register.
+
+	movl	%esp,%eax		# Current stack,
+	subl	8(%esp),%eax		# less required stack frame size,
+	subl	$0x4000,%eax		# less space for non-split code.
+	cmpl	%gs:0x30,%eax		# See if we have enough space.
+	jb	2f			# Get more space if we need it.
+
+	# Here the stack is
+	#	%esp + 20:	stack pointer after two returns
+	#	%esp + 16:	return address of morestack caller's caller
+	#	%esp + 12:	size of parameters
+	#	%esp + 8:	new stack frame size
+	#	%esp + 4:	return address of this function
+	#	%esp:		saved %eax
+	#
+	# Since we aren't doing a full split stack, we don't need to
+	# do anything when our caller returns.  So we return to our
+	# caller rather than calling it, and let it return as usual.
+	# To make that work we adjust the return address.
+
+	# This breaks call/return address prediction for the call to
+	# this function.  I can't figure out a way to make it work
+	# short of copying the parameters down the stack, which will
+	# probably take more clock cycles than we will lose breaking
+	# call/return address prediction.  We will only break
+	# prediction for this call, not for our caller.
+
+	movl	4(%esp),%eax		# Increment the return address
+	cmpb	$0xc3,(%eax)		# to skip the ret instruction;
+	je	1f			# see above.
+	addl	$2,%eax
+1:	inc	%eax
+	movl	%eax,4(%esp)		# Update return address.
+
+	popl	%eax			# Restore %eax and stack.
+
+	.cfi_def_cfa %esp,4		# Account for popped register.
+
+	ret	$8			# Return to caller, popping args.
+
+2:
+	.cfi_def_cfa %esp,8		# Back to where we were.
+
+	popl	%eax			# Restore %eax and stack.
+
+	.cfi_def_cfa %esp,4		# Account for popped register.
+
+	addl	$0x5000+BACKOFF,4(%esp)	# Increment space we request.
+
+	# Fall through into morestack.
+
+#else
+
+	# See below for an extended explanation of the CFI instructions.
+	.cfi_offset 16, 0
+	.cfi_escape 0x15, 7, 0x7f	# DW_CFA_val_offset_sf, %esp, 8/-8
+
+	pushq	%rax			# Save %rax in case caller is using
+					# it to preserve original %r10.
+	.cfi_def_cfa %rsp,16		# Adjust for pushed register.
+
+	movq	%rsp,%rax		# Current stack,
+	subq	%r10,%rax		# less required stack frame size,
+	subq	$0x4000,%rax		# less space for non-split code.
+
+#ifdef __LP64__
+	cmpq	%fs:0x70,%rax		# See if we have enough space.
 #else
-	addq	$0x4000,%r10
+	cmpl	%fs:0x40,%eax
+#endif
+	jb	2f			# Get more space if we need it.
+
+	# This breaks call/return prediction, as described above.
+	incq	8(%rsp)			# Increment the return address.
+
+	popq	%rax			# Restore register.
+
+	.cfi_def_cfa %rsp,8		# Adjust for popped register.
+
+	ret				# Return to caller.
+
+2:
+	.cfi_def_cfa %rsp,16		# Back to where we were.
+
+	popq	%rax			# Restore register.
+
+	.cfi_def_cfa %rsp,8		# Adjust for popped register.
+
+	addq	$0x5000+BACKOFF,%r10	# Increment space we request.
+
+	# Fall throug into morestack.
+
 #endif
 
+	.cfi_endproc
 #ifdef __ELF__
 	.size	__morestack_non_split, . - __morestack_non_split
 #endif