 @@ -1,175 +1,176 @@
  # Alpha 21064 __udiv_qrnnd
  # Copyright (C) 1992-2013 Free Software Foundation, Inc.
  # This file is part of GCC.
  # The GNU MP Library is free software; you can redistribute it and/or modify
  # it under the terms of the GNU General Public License as published by
  # the Free Software Foundation; either version 3 of the License, or (at your
  # option) any later version.
  # This file is distributed in the hope that it will be useful, but
  # WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
  # License for more details.
  # Under Section 7 of GPL version 3, you are granted additional
  # permissions described in the GCC Runtime Library Exception, version
  # 3.1, as published by the Free Software Foundation.
  # You should have received a copy of the GNU General Public License and
  # a copy of the GCC Runtime Library Exception along with this program;
  # see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  # <http://www.gnu.org/licenses/>.
-#ifdef __ELF__
+#if defined(__ELF__) && defined(__linux__)
 .section .note.GNU-stack,""
 .previous
 #endif
         .set noreorder
         .set noat
 	.text
 	.globl __udiv_qrnnd
 	.ent __udiv_qrnnd
 #ifdef __VMS__
 __udiv_qrnnd..en:
 	.frame $29,0,$26,0
 	.prologue
 #else
 __udiv_qrnnd:
 	.frame $30,0,$26,0
 	.prologue 0
 #endif
 #define cnt	$2
 #define tmp	$3
 #define rem_ptr	$16
 #define n1	$17
 #define n0	$18
 #define d	$19
 #define qb	$20
 #define AT	$at
 	ldiq	cnt,16
 	blt	d,$largedivisor
 $loop1:	cmplt	n0,0,tmp
 	addq	n1,n1,n1
 	bis	n1,tmp,n1
 	addq	n0,n0,n0
 	cmpule	d,n1,qb
 	subq	n1,d,tmp
 	cmovne	qb,tmp,n1
 	bis	n0,qb,n0
 	cmplt	n0,0,tmp
 	addq	n1,n1,n1
 	bis	n1,tmp,n1
 	addq	n0,n0,n0
 	cmpule	d,n1,qb
 	subq	n1,d,tmp
 	cmovne	qb,tmp,n1
 	bis	n0,qb,n0
 	cmplt	n0,0,tmp
 	addq	n1,n1,n1
 	bis	n1,tmp,n1
 	addq	n0,n0,n0
 	cmpule	d,n1,qb
 	subq	n1,d,tmp
 	cmovne	qb,tmp,n1
 	bis	n0,qb,n0
 	cmplt	n0,0,tmp
 	addq	n1,n1,n1
 	bis	n1,tmp,n1
 	addq	n0,n0,n0
 	cmpule	d,n1,qb
 	subq	n1,d,tmp
 	cmovne	qb,tmp,n1
 	bis	n0,qb,n0
 	subq	cnt,1,cnt
 	bgt	cnt,$loop1
 	stq	n1,0(rem_ptr)
 	bis	$31,n0,$0
 	ret	$31,($26),1
 $largedivisor:
 	and	n0,1,$4
 	srl	n0,1,n0
 	sll	n1,63,tmp
 	or	tmp,n0,n0
 	srl	n1,1,n1
 	and	d,1,$6
 	srl	d,1,$5
 	addq	$5,$6,$5
 $loop2:	cmplt	n0,0,tmp
 	addq	n1,n1,n1
 	bis	n1,tmp,n1
 	addq	n0,n0,n0
 	cmpule	$5,n1,qb
 	subq	n1,$5,tmp
 	cmovne	qb,tmp,n1
 	bis	n0,qb,n0
 	cmplt	n0,0,tmp
 	addq	n1,n1,n1
 	bis	n1,tmp,n1
 	addq	n0,n0,n0
 	cmpule	$5,n1,qb
 	subq	n1,$5,tmp
 	cmovne	qb,tmp,n1
 	bis	n0,qb,n0
 	cmplt	n0,0,tmp
 	addq	n1,n1,n1
 	bis	n1,tmp,n1
 	addq	n0,n0,n0
 	cmpule	$5,n1,qb
 	subq	n1,$5,tmp
 	cmovne	qb,tmp,n1
 	bis	n0,qb,n0
 	cmplt	n0,0,tmp
 	addq	n1,n1,n1
 	bis	n1,tmp,n1
 	addq	n0,n0,n0
 	cmpule	$5,n1,qb
 	subq	n1,$5,tmp
 	cmovne	qb,tmp,n1
 	bis	n0,qb,n0
 	subq	cnt,1,cnt
 	bgt	cnt,$loop2
 	addq	n1,n1,n1
 	addq	$4,n1,n1
 	bne	$6,$Odd
 	stq	n1,0(rem_ptr)
 	bis	$31,n0,$0
 	ret	$31,($26),1
 $Odd:
 	/* q' in n0. r' in n1 */
 	addq	n1,n0,n1
 	cmpult	n1,n0,tmp	# tmp := carry from addq
 	subq	n1,d,AT
 	addq	n0,tmp,n0
 	cmovne	tmp,AT,n1
 	cmpult	n1,d,tmp
 	addq	n0,1,AT
 	cmoveq	tmp,AT,n0
 	subq	n1,d,AT
 	cmoveq	tmp,AT,n1
 	stq	n1,0(rem_ptr)
 	bis	$31,n0,$0
 	ret	$31,($26),1
 #ifdef __VMS__
 	.link
 	.align 3
 __udiv_qrnnd:
 	.pdesc	__udiv_qrnnd..en,null
 #endif
 	.end	__udiv_qrnnd

 @@ -1,860 +1,860 @@
 # x86/x86_64 support for -fsplit-stack.
 # Copyright (C) 2009-2013 Free Software Foundation, Inc.
 # Contributed by Ian Lance Taylor <iant@google.com>.
 # This file is part of GCC.
 # GCC is free software; you can redistribute it and/or modify it under
 # the terms of the GNU General Public License as published by the Free
 # Software Foundation; either version 3, or (at your option) any later
 # version.
 # GCC is distributed in the hope that it will be useful, but WITHOUT ANY
 # WARRANTY; without even the implied warranty of MERCHANTABILITY or
 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 # for more details.
 # Under Section 7 of GPL version 3, you are granted additional
 # permissions described in the GCC Runtime Library Exception, version
 # 3.1, as published by the Free Software Foundation.
 # You should have received a copy of the GNU General Public License and
 # a copy of the GCC Runtime Library Exception along with this program;
 # see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 # <http://www.gnu.org/licenses/>.
 # Support for allocating more stack space when using -fsplit-stack.
 # When a function discovers that it needs more stack space, it will
 # call __morestack with the size of the stack frame and the size of
 # the parameters to copy from the old stack frame to the new one.
 # The __morestack function preserves the parameter registers and
 # calls __generic_morestack to actually allocate the stack space.
 # When this is called stack space is very low, but we ensure that
 # there is enough space to push the parameter registers and to call
 # __generic_morestack.
 # When calling __generic_morestack, FRAME_SIZE points to the size of
 # the desired frame when the function is called, and the function
 # sets it to the size of the allocated stack.  OLD_STACK points to
 # the parameters on the old stack and PARAM_SIZE is the number of
 # bytes of parameters to copy to the new stack.  These are the
 # parameters of the function that called __morestack.  The
 # __generic_morestack function returns the new stack pointer,
 # pointing to the address of the first copied parameter.  The return
 # value minus the returned *FRAME_SIZE will be the first address on
 # the stack which we should not use.
 # void *__generic_morestack (size_t *frame_size, void *old_stack,
 #			     size_t param_size);
 # The __morestack routine has to arrange for the caller to return to a
 # stub on the new stack.  The stub is responsible for restoring the
 # old stack pointer and returning to the caller's caller.  This calls
 # __generic_releasestack to retrieve the old stack pointer and release
 # the newly allocated stack.
 # void *__generic_releasestack (size_t *available);
 # We do a little dance so that the processor's call/return return
 # address prediction works out.  The compiler arranges for the caller
 # to look like this:
 #   call __generic_morestack
 #   ret
 #  L:
 #   // carry on with function
 # After we allocate more stack, we call L, which is in our caller.
 # When that returns (to the predicted instruction), we release the
 # stack segment and reset the stack pointer.  We then return to the
 # predicted instruction, namely the ret instruction immediately after
 # the call to __generic_morestack.  That then returns to the caller of
 # the original caller.
 # The amount of extra space we ask for.  In general this has to be
 # enough for the dynamic loader to find a symbol and for a signal
 # handler to run.
 #ifndef __x86_64__
 #define BACKOFF (1024)
 #else
 #define BACKOFF (1536)
 #endif
 # The amount of space we ask for when calling non-split-stack code.
 #define NON_SPLIT_STACK 0x100000
 # This entry point is for split-stack code which calls non-split-stack
 # code.  When the linker sees this case, it converts the call to
 # __morestack to call __morestack_non_split instead.  We just bump the
 # requested stack space by 16K.
 	.global __morestack_non_split
 	.hidden	__morestack_non_split
 #ifdef __ELF__
        .type	__morestack_non_split,@function
 #endif
 __morestack_non_split:
 	.cfi_startproc
 #ifndef __x86_64__
 	# See below for an extended explanation of this.
 	.cfi_def_cfa %esp,16
 	pushl	%eax			# Save %eax in case it is a parameter.
 	.cfi_adjust_cfa_offset 4	# Account for pushed register.
 	movl	%esp,%eax		# Current stack,
 	subl	8(%esp),%eax		# less required stack frame size,
 	subl	$NON_SPLIT_STACK,%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
 :	inc	%eax
 	# If the instruction that we return to is
 	#   leal  20(%ebp),{%eax,%ecx,%edx}
 	# then we have been called by a varargs function that expects
 	# %ebp to hold a real value.  That can only work if we do the
 	# full stack split routine.  FIXME: This is fragile.
 	cmpb	$0x8d,(%eax)
 	jne	3f
 	cmpb	$0x14,2(%eax)
 	jne	3f
 	cmpb	$0x45,1(%eax)
 	je	2f
 	cmpb	$0x4d,1(%eax)
 	je	2f
 	cmpb	$0x55,1(%eax)
 	je	2f
 :
 	movl	%eax,4(%esp)		# Update return address.
 	popl	%eax			# Restore %eax and stack.
 	.cfi_adjust_cfa_offset -4	# Account for popped register.
 	ret	$8			# Return to caller, popping args.
 :
 	.cfi_adjust_cfa_offset 4	# Back to where we were.
 	popl	%eax			# Restore %eax and stack.
 	.cfi_adjust_cfa_offset -4	# Account for popped register.
 	# Increment space we request.
 	addl	$NON_SPLIT_STACK+0x1000+BACKOFF,4(%esp)
 	# Fall through into morestack.
 #else
 	# See below for an extended explanation of this.
 	.cfi_def_cfa %rsp,16
 	pushq	%rax			# Save %rax in case caller is using
 					# it to preserve original %r10.
 	.cfi_adjust_cfa_offset 8	# Adjust for pushed register.
 	movq	%rsp,%rax		# Current stack,
 	subq	%r10,%rax		# less required stack frame size,
 	subq	$NON_SPLIT_STACK,%rax	# less space for non-split code.
 #ifdef __LP64__
 	cmpq	%fs:0x70,%rax		# See if we have enough space.
 #else
 	cmpl	%fs:0x40,%eax
 #endif
 	jb	2f			# Get more space if we need it.
 	# If the instruction that we return to is
 	#   leaq  24(%rbp), %r11n
 	# then we have been called by a varargs function that expects
 	# %ebp to hold a real value.  That can only work if we do the
 	# full stack split routine.  FIXME: This is fragile.
 	movq	8(%rsp),%rax
 	incq	%rax			# Skip ret instruction in caller.
 	cmpl	$0x185d8d4c,(%rax)
 	je	2f
 	# This breaks call/return prediction, as described above.
 	incq	8(%rsp)			# Increment the return address.
 	popq	%rax			# Restore register.
 	.cfi_adjust_cfa_offset -8	# Adjust for popped register.
 	ret				# Return to caller.
 :
 	popq	%rax			# Restore register.
 	.cfi_adjust_cfa_offset -8	# Adjust for popped register.
 	# Increment space we request.
 	addq	$NON_SPLIT_STACK+0x1000+BACKOFF,%r10
 	# Fall through into morestack.
 #endif
 	.cfi_endproc
 #ifdef __ELF__
 	.size	__morestack_non_split, . - __morestack_non_split
 #endif
 # __morestack_non_split falls through into __morestack.
 # The __morestack function.
 	.global	__morestack
 	.hidden	__morestack
 #ifdef __ELF__
 	.type	__morestack,@function
 #endif
 __morestack:
 .LFB1:
 	.cfi_startproc
 #ifndef __x86_64__
 # The 32-bit __morestack function.
 	# We use a cleanup to restore the stack guard if an exception
 	# is thrown through this code.
 #ifndef __PIC__
 	.cfi_personality 0,__gcc_personality_v0
 	.cfi_lsda 0,.LLSDA1
 #else
 	.cfi_personality 0x9b,DW.ref.__gcc_personality_v0
 	.cfi_lsda 0x1b,.LLSDA1
 #endif
 	# We return below with a ret $8.  We will return to a single
 	# return instruction, which will return to the caller of our
 	# caller.  We let the unwinder skip that single return
 	# instruction, and just return to the real caller.
 	# Here CFA points just past the return address on the stack,
 	# e.g., on function entry it is %esp + 4.  The stack looks
 	# like this:
 	#	CFA + 12:	stack pointer after two returns
 	#	CFA + 8:	return address of morestack caller's caller
 	#	CFA + 4:	size of parameters
 	#	CFA:		new stack frame size
 	#	CFA - 4:	return address of this function
 	#	CFA - 8:	previous value of %ebp; %ebp points here
 	# Setting the new CFA to be the current CFA + 12 (i.e., %esp +
 	# 16) will make the unwinder pick up the right return address.
 	.cfi_def_cfa %esp,16
 	pushl	%ebp
 	.cfi_adjust_cfa_offset 4
 	.cfi_offset %ebp, -20
 	movl	%esp,%ebp
 	.cfi_def_cfa_register %ebp
 	# In 32-bit mode the parameters are pushed on the stack.  The
 	# argument size is pushed then the new stack frame size is
 	# pushed.
 	# In the body of a non-leaf function, the stack pointer will
 	# be aligned to a 16-byte boundary.  That is CFA + 12 in the
 	# stack picture above: (CFA + 12) % 16 == 0.  At this point we
 	# have %esp == CFA - 8, so %esp % 16 == 12.  We need some
 	# space for saving registers and passing parameters, and we
 	# need to wind up with %esp % 16 == 0.
 	subl	$44,%esp
 	# Because our cleanup code may need to clobber %ebx, we need
 	# to save it here so the unwinder can restore the value used
 	# by the caller.  Note that we don't have to restore the
 	# register, since we don't change it, we just have to save it
 	# for the unwinder.
 	movl	%ebx,-4(%ebp)
 	.cfi_offset %ebx, -24
 	# In 32-bit mode the registers %eax, %edx, and %ecx may be
 	# used for parameters, depending on the regparm and fastcall
 	# attributes.
 	movl	%eax,-8(%ebp)
 	movl	%edx,-12(%ebp)
 	movl	%ecx,-16(%ebp)
 	call	__morestack_block_signals
 	movl	12(%ebp),%eax		# The size of the parameters.
 	movl	%eax,8(%esp)
 	leal	20(%ebp),%eax		# Address of caller's parameters.
 	movl	%eax,4(%esp)
 	addl	$BACKOFF,8(%ebp)	# Ask for backoff bytes.
 	leal	8(%ebp),%eax		# The address of the new frame size.
 	movl	%eax,(%esp)
 	call	__generic_morestack
 	movl	%eax,%esp		# Switch to the new stack.
 	subl	8(%ebp),%eax		# The end of the stack space.
 	addl	$BACKOFF,%eax		# Back off 512 bytes.
 .LEHB0:
 	# FIXME: The offset must match
 	# TARGET_THREAD_SPLIT_STACK_OFFSET in
 	# gcc/config/i386/linux.h.
 	movl	%eax,%gs:0x30		# Save the new stack boundary.
 	call	__morestack_unblock_signals
 	movl	-12(%ebp),%edx		# Restore registers.
 	movl	-16(%ebp),%ecx
 	movl	4(%ebp),%eax		# Increment the return address
 	cmpb	$0xc3,(%eax)		# to skip the ret instruction;
 	je	1f			# see above.
 	addl	$2,%eax
 :	inc	%eax
 	movl	%eax,-12(%ebp)		# Store return address in an
 					# unused slot.
 	movl	-8(%ebp),%eax		# Restore the last register.
 	call	*-12(%ebp)		# Call our caller!
 	# The caller will return here, as predicted.
 	# Save the registers which may hold a return value.  We
 	# assume that __generic_releasestack does not touch any
 	# floating point or vector registers.
 	pushl	%eax
 	pushl	%edx
 	# Push the arguments to __generic_releasestack now so that the
 	# stack is at a 16-byte boundary for
 	# __morestack_block_signals.
 	pushl	$0			# Where the available space is returned.
 	leal	0(%esp),%eax		# Push its address.
 	push	%eax
 	call	__morestack_block_signals
 	call	__generic_releasestack
 	subl	4(%esp),%eax		# Subtract available space.
 	addl	$BACKOFF,%eax		# Back off 512 bytes.
 .LEHE0:
 	movl	%eax,%gs:0x30		# Save the new stack boundary.
 	addl	$8,%esp			# Remove values from stack.
 	# We need to restore the old stack pointer, which is in %rbp,
 	# before we unblock signals.  We also need to restore %eax and
 	# %edx after we unblock signals but before we return.  Do this
 	# by moving %eax and %edx from the current stack to the old
 	# stack.
 	popl	%edx			# Pop return value from current stack.
 	popl	%eax
 	movl	%ebp,%esp		# Restore stack pointer.
 	# As before, we now have %esp % 16 == 12.
 	pushl	%eax			# Push return value on old stack.
 	pushl	%edx
 	subl	$4,%esp			# Align stack to 16-byte boundary.
 	call	__morestack_unblock_signals
 	addl	$4,%esp
 	popl	%edx			# Restore return value.
 	popl	%eax
 	.cfi_remember_state
 	# We never changed %ebx, so we don't have to actually restore it.
 	.cfi_restore %ebx
 	popl	%ebp
 	.cfi_restore %ebp
 	.cfi_def_cfa %esp, 16
 	ret	$8			# Return to caller, which will
 					# immediately return.  Pop
 					# arguments as we go.
 # This is the cleanup code called by the stack unwinder when unwinding
 # through the code between .LEHB0 and .LEHE0 above.
 .L1:
 	.cfi_restore_state
 	subl	$16,%esp		# Maintain 16 byte alignment.
 	movl	%eax,4(%esp)		# Save exception header.
 	movl	%ebp,(%esp)		# Stack pointer after resume.
 	call	__generic_findstack
 	movl	%ebp,%ecx		# Get the stack pointer.
 	subl	%eax,%ecx		# Subtract available space.
 	addl	$BACKOFF,%ecx		# Back off 512 bytes.
 	movl	%ecx,%gs:0x30		# Save new stack boundary.
 	movl	4(%esp),%eax		# Function argument.
 	movl	%eax,(%esp)
 #ifdef __PIC__
 	call	__x86.get_pc_thunk.bx	# %ebx may not be set up for us.
 	addl	$_GLOBAL_OFFSET_TABLE_, %ebx
 	call	_Unwind_Resume@PLT	# Resume unwinding.
 #else
 	call	_Unwind_Resume
 #endif
 #else /* defined(__x86_64__) */
 # The 64-bit __morestack function.
 	# We use a cleanup to restore the stack guard if an exception
 	# is thrown through this code.
 #ifndef __PIC__
 	.cfi_personality 0x3,__gcc_personality_v0
 	.cfi_lsda 0x3,.LLSDA1
 #else
 	.cfi_personality 0x9b,DW.ref.__gcc_personality_v0
 	.cfi_lsda 0x1b,.LLSDA1
 #endif
 	# We will return a single return instruction, which will
 	# return to the caller of our caller.  Let the unwinder skip
 	# that single return instruction, and just return to the real
 	# caller.
 	.cfi_def_cfa %rsp,16
 	# Set up a normal backtrace.
 	pushq	%rbp
 	.cfi_adjust_cfa_offset 8
 	.cfi_offset %rbp, -24
 	movq	%rsp, %rbp
 	.cfi_def_cfa_register %rbp
 	# In 64-bit mode the new stack frame size is passed in r10
         # and the argument size is passed in r11.
 	addq	$BACKOFF,%r10		# Ask for backoff bytes.
 	pushq	%r10			# Save new frame size.
 	# In 64-bit mode the registers %rdi, %rsi, %rdx, %rcx, %r8,
 	# and %r9 may be used for parameters.  We also preserve %rax
 	# which the caller may use to hold %r10.
 	pushq	%rax
 	pushq	%rdi
 	pushq	%rsi
 	pushq	%rdx
 	pushq	%rcx
 	pushq	%r8
 	pushq	%r9
 	pushq	%r11
 	# We entered morestack with the stack pointer aligned to a
 	# 16-byte boundary (the call to morestack's caller used 8
 	# bytes, and the call to morestack used 8 bytes).  We have now
 	# pushed 10 registers, so we are still aligned to a 16-byte
 	# boundary.
 	call	__morestack_block_signals
 	leaq	-8(%rbp),%rdi		# Address of new frame size.
 	leaq	24(%rbp),%rsi		# The caller's parameters.
 	popq	%rdx			# The size of the parameters.
 	subq	$8,%rsp			# Align stack.
 	call	__generic_morestack
 	movq	-8(%rbp),%r10		# Reload modified frame size
 	movq	%rax,%rsp		# Switch to the new stack.
 	subq	%r10,%rax		# The end of the stack space.
 	addq	$BACKOFF,%rax		# Back off 1024 bytes.
 .LEHB0:
 	# FIXME: The offset must match
 	# TARGET_THREAD_SPLIT_STACK_OFFSET in
 	# gcc/config/i386/linux64.h.
 	# Macro to save the new stack boundary.
 #ifdef __LP64__
 #define X86_64_SAVE_NEW_STACK_BOUNDARY(reg)	movq	%r##reg,%fs:0x70
 #else
 #define X86_64_SAVE_NEW_STACK_BOUNDARY(reg)	movl	%e##reg,%fs:0x40
 #endif
 	X86_64_SAVE_NEW_STACK_BOUNDARY (ax)
 	call	__morestack_unblock_signals
 	movq	-24(%rbp),%rdi		# Restore registers.
 	movq	-32(%rbp),%rsi
 	movq	-40(%rbp),%rdx
 	movq	-48(%rbp),%rcx
 	movq	-56(%rbp),%r8
 	movq	-64(%rbp),%r9
 	movq	8(%rbp),%r10		# Increment the return address
 	incq	%r10			# to skip the ret instruction;
 					# see above.
 	movq	-16(%rbp),%rax		# Restore caller's %rax.
 	call	*%r10			# Call our caller!
 	# The caller will return here, as predicted.
 	# Save the registers which may hold a return value.  We
 	# assume that __generic_releasestack does not touch any
 	# floating point or vector registers.
 	pushq	%rax
 	pushq	%rdx
 	call	__morestack_block_signals
 	pushq	$0			# For alignment.
 	pushq	$0			# Where the available space is returned.
 	leaq	0(%rsp),%rdi		# Pass its address.
 	call	__generic_releasestack
 	subq	0(%rsp),%rax		# Subtract available space.
 	addq	$BACKOFF,%rax		# Back off 1024 bytes.
 .LEHE0:
 	X86_64_SAVE_NEW_STACK_BOUNDARY (ax)
 	addq	$16,%rsp		# Remove values from stack.
 	# We need to restore the old stack pointer, which is in %rbp,
 	# before we unblock signals.  We also need to restore %rax and
 	# %rdx after we unblock signals but before we return.  Do this
 	# by moving %rax and %rdx from the current stack to the old
 	# stack.
 	popq	%rdx			# Pop return value from current stack.
 	popq	%rax
 	movq	%rbp,%rsp		# Restore stack pointer.
 	# Now (%rsp & 16) == 8.
 	subq	$8,%rsp			# For alignment.
 	pushq	%rax			# Push return value on old stack.
 	pushq	%rdx
 	call	__morestack_unblock_signals
 	popq	%rdx			# Restore return value.
 	popq	%rax
 	addq	$8,%rsp
 	.cfi_remember_state
 	popq	%rbp
 	.cfi_restore %rbp
 	.cfi_def_cfa %rsp, 16
 	ret				# Return to caller, which will
 					# immediately return.
 # This is the cleanup code called by the stack unwinder when unwinding
 # through the code between .LEHB0 and .LEHE0 above.
 .L1:
 	.cfi_restore_state
 	subq	$16,%rsp		# Maintain 16 byte alignment.
 	movq	%rax,(%rsp)		# Save exception header.
 	movq	%rbp,%rdi		# Stack pointer after resume.
 	call	__generic_findstack
 	movq	%rbp,%rcx		# Get the stack pointer.
 	subq	%rax,%rcx		# Subtract available space.
 	addq	$BACKOFF,%rcx		# Back off 1024 bytes.
 	X86_64_SAVE_NEW_STACK_BOUNDARY (cx)
 	movq	(%rsp),%rdi		# Restore exception data for call.
 #ifdef __PIC__
 	call	_Unwind_Resume@PLT	# Resume unwinding.
 #else
 	call	_Unwind_Resume		# Resume unwinding.
 #endif
 #endif /* defined(__x86_64__) */
 	.cfi_endproc
 #ifdef __ELF__
 	.size	__morestack, . - __morestack
 #endif
 #if !defined(__x86_64__) && defined(__PIC__)
 # Output the thunk to get PC into bx, since we use it above.
 	.section	.text.__x86.get_pc_thunk.bx,"axG",@progbits,__x86.get_pc_thunk.bx,comdat
 	.globl	__x86.get_pc_thunk.bx
 	.hidden	__x86.get_pc_thunk.bx
 #ifdef __ELF__
 	.type	__x86.get_pc_thunk.bx, @function
 #endif
 __x86.get_pc_thunk.bx:
 	.cfi_startproc
 	movl	(%esp), %ebx
 	ret
 	.cfi_endproc
 #ifdef __ELF__
 	.size	__x86.get_pc_thunk.bx, . - __x86.get_pc_thunk.bx
 #endif
 #endif
 # The exception table.  This tells the personality routine to execute
 # the exception handler.
 	.section	.gcc_except_table,"a",@progbits
 	.align	4
 .LLSDA1:
 	.byte	0xff	# @LPStart format (omit)
 	.byte	0xff	# @TType format (omit)
 	.byte	0x1	# call-site format (uleb128)
 	.uleb128 .LLSDACSE1-.LLSDACSB1	# Call-site table length
 .LLSDACSB1:
 	.uleb128 .LEHB0-.LFB1	# region 0 start
 	.uleb128 .LEHE0-.LEHB0	# length
 	.uleb128 .L1-.LFB1	# landing pad
 	.uleb128 0		# action
 .LLSDACSE1:
 	.global __gcc_personality_v0
 #ifdef __PIC__
 	# Build a position independent reference to the basic
         # personality function.
 	.hidden DW.ref.__gcc_personality_v0
 	.weak   DW.ref.__gcc_personality_v0
 	.section .data.DW.ref.__gcc_personality_v0,"awG",@progbits,DW.ref.__gcc_personality_v0,comdat
 	.type	DW.ref.__gcc_personality_v0, @object
 DW.ref.__gcc_personality_v0:
 #ifndef __LP64__
 	.align 4
 	.size	DW.ref.__gcc_personality_v0, 4
 	.long	__gcc_personality_v0
 #else
 	.align 8
 	.size	DW.ref.__gcc_personality_v0, 8
 	.quad	__gcc_personality_v0
 #endif
 #endif
 #if defined __x86_64__ && defined __LP64__
 # This entry point is used for the large model.  With this entry point
 # the upper 32 bits of %r10 hold the argument size and the lower 32
 # bits hold the new stack frame size.  There doesn't seem to be a way
 # to know in the assembler code that we are assembling for the large
 # model, and there doesn't seem to be a large model multilib anyhow.
 # If one is developed, then the non-PIC code is probably OK since we
 # will probably be close to the morestack code, but the PIC code
 # almost certainly needs to be changed.  FIXME.
 	.text
 	.global	__morestack_large_model
 	.hidden	__morestack_large_model
 #ifdef __ELF__
 	.type	__morestack_large_model,@function
 #endif
 __morestack_large_model:
 	.cfi_startproc
 	movq	%r10, %r11
 	andl	$0xffffffff, %r10d
 	sarq	$32, %r11
 	jmp	__morestack
 	.cfi_endproc
 #ifdef __ELF__
        .size	__morestack_large_model, . - __morestack_large_model
 #endif
 #endif /* __x86_64__ && __LP64__ */
 # Initialize the stack test value when the program starts or when a
 # new thread starts.  We don't know how large the main stack is, so we
 # guess conservatively.  We might be able to use getrlimit here.
 	.text
 	.global	__stack_split_initialize
 	.hidden	__stack_split_initialize
 #ifdef __ELF__
 	.type	__stack_split_initialize, @function
 #endif
 __stack_split_initialize:
 #ifndef __x86_64__
 	leal	-16000(%esp),%eax	# We should have at least 16K.
 	movl	%eax,%gs:0x30
 	pushl	$16000
 	pushl	%esp
 #ifdef __PIC__
 	call	__generic_morestack_set_initial_sp@PLT
 #else
 	call	__generic_morestack_set_initial_sp
 #endif
 	addl	$8,%esp
 	ret
 #else /* defined(__x86_64__) */
 	leaq	-16000(%rsp),%rax	# We should have at least 16K.
 	X86_64_SAVE_NEW_STACK_BOUNDARY (ax)
 	movq	%rsp,%rdi
 	movq	$16000,%rsi
 #ifdef __PIC__
 	call	__generic_morestack_set_initial_sp@PLT
 #else
 	call	__generic_morestack_set_initial_sp
 #endif
 	ret
 #endif /* defined(__x86_64__) */
 #ifdef __ELF__
 	.size	__stack_split_initialize, . - __stack_split_initialize
 #endif
 # Routines to get and set the guard, for __splitstack_getcontext,
 # __splitstack_setcontext, and __splitstack_makecontext.
 # void *__morestack_get_guard (void) returns the current stack guard.
 	.text
 	.global	__morestack_get_guard
 	.hidden	__morestack_get_guard
 #ifdef __ELF__
 	.type	__morestack_get_guard,@function
 #endif
 __morestack_get_guard:
 #ifndef __x86_64__
 	movl	%gs:0x30,%eax
 #else
 #ifdef __LP64__
 	movq	%fs:0x70,%rax
 #else
 	movl	%fs:0x40,%eax
 #endif
 #endif
 	ret
 #ifdef __ELF__
 	.size	__morestack_get_guard, . - __morestack_get_guard
 #endif
 # void __morestack_set_guard (void *) sets the stack guard.
 	.global	__morestack_set_guard
 	.hidden	__morestack_set_guard
 #ifdef __ELF__
 	.type	__morestack_set_guard,@function
 #endif
 __morestack_set_guard:
 #ifndef __x86_64__
 	movl	4(%esp),%eax
 	movl	%eax,%gs:0x30
 #else
 	X86_64_SAVE_NEW_STACK_BOUNDARY (di)
 #endif
 	ret
 #ifdef __ELF__
 	.size	__morestack_set_guard, . - __morestack_set_guard
 #endif
 # void *__morestack_make_guard (void *, size_t) returns the stack
 # guard value for a stack.
 	.global	__morestack_make_guard
 	.hidden	__morestack_make_guard
 #ifdef __ELF__
 	.type	__morestack_make_guard,@function
 #endif
 __morestack_make_guard:
 #ifndef __x86_64__
 	movl	4(%esp),%eax
 	subl	8(%esp),%eax
 	addl	$BACKOFF,%eax
 #else
 	subq	%rsi,%rdi
 	addq	$BACKOFF,%rdi
 	movq	%rdi,%rax
 #endif
 	ret
 #ifdef __ELF__
 	.size	__morestack_make_guard, . - __morestack_make_guard
 #endif
 # Make __stack_split_initialize a high priority constructor.  FIXME:
 # This is ELF specific.
 	.section	.ctors.65535,"aw",@progbits
 #ifndef __LP64__
 	.align	4
 	.long	__stack_split_initialize
 	.long	__morestack_load_mmap
 #else
 	.align	8
 	.quad	__stack_split_initialize
 	.quad	__morestack_load_mmap
 #endif
-#ifdef __ELF__
+#if defined(__ELF__) && defined(__linux__)
 	.section	.note.GNU-stack,"",@progbits
 	.section	.note.GNU-split-stack,"",@progbits
 	.section	.note.GNU-no-split-stack,"",@progbits
 #endif

 @@ -1,112 +1,112 @@
 /* Copyright (C) 2009-2013 Free Software Foundation, Inc.
    Contributed by Richard Henderson <rth@redhat.com>.
    This file is part of the GNU Transactional Memory Library (libitm).
    Libitm is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    Libitm is distributed in the hope that it will be useful, but WITHOUT ANY
    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
    more details.
    Under Section 7 of GPL version 3, you are granted additional
    permissions described in the GCC Runtime Library Exception, version
 .1, as published by the Free Software Foundation.
    You should have received a copy of the GNU General Public License and
    a copy of the GCC Runtime Library Exception along with this program;
    see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
    <http://www.gnu.org/licenses/>.  */
 	.text
 	.align 4
 	.globl	_ITM_beginTransaction
 	.ent	_ITM_beginTransaction
 #define FRAME	144
 _ITM_beginTransaction:
 	ldgp	$29, 0($27)
 	subq	$30, FRAME, $30
 	.frame	$30, FRAME, $26, 0
 	.mask	0x04000000, 0
 	stq	$26, 0($30)
 	.prologue 1
 	stq	$9, 8($30)
 	stq	$10, 16($30)
 	addq	$30, FRAME, $0
 	stq	$11, 24($30)
 	stq	$12, 32($30)
 	stq	$13, 40($30)
 	stq	$14, 48($30)
 	stq	$15, 56($30)
 	stq	$0, 64($30)
 	stt	$f2, 72($30)
 	stt	$f3, 80($30)
 	stt	$f4, 88($30)
 	stt	$f5, 96($30)
 	stt	$f6, 104($30)
 	stt	$f7, 112($30)
 	stt	$f8, 120($30)
 	stt	$f9, 128($30)
 	mov	$30, $17
 #ifdef __PIC__
 	unop
 	bsr	$26, GTM_begin_transaction !samegp
 #else
 	jsr	$26, GTM_begin_transaction
 	ldgp	$29, 0($26)
 #endif
 	ldq	$26, 0($30)
 	addq	$30, FRAME, $30
 	ret
 .end _ITM_beginTransaction
 	.align 4
 	.globl	GTM_longjmp
 #ifdef __ELF__
 	.hidden	GTM_longjmp
 #endif
 	.ent	GTM_longjmp
 GTM_longjmp:
 	.prologue 0
 	ldq	$26, 0($17)
 	ldq	$9, 8($17)
 	ldq	$10, 16($17)
 	ldq	$11, 24($17)
 	ldq	$12, 32($17)
 	ldq	$13, 40($17)
 	ldq	$14, 48($17)
 	ldq	$15, 56($17)
 	ldq	$1, 64($17)
 	ldt	$f2, 72($17)
 	ldt	$f3, 80($17)
 	ldt	$f4, 88($17)
 	ldt	$f5, 96($17)
 	ldt	$f6, 104($17)
 	ldt	$f7, 112($17)
 	ldt	$f8, 120($17)
 	ldt	$f9, 128($17)
 	mov	$16, $0
 	mov	$1, $30
 	ret
 .end GTM_longjmp
-#ifdef __linux__
+#if defined(__ELF__) && defined(__linux__)
 .section .note.GNU-stack, "", @progbits
 #endif

 @@ -1,164 +1,164 @@
 /* Copyright (C) 2011-2013 Free Software Foundation, Inc.
    Contributed by Richard Henderson <rth@redhat.com>.
    This file is part of the GNU Transactional Memory Library (libitm).
    Libitm is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    Libitm is distributed in the hope that it will be useful, but WITHOUT ANY
    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
    more details.
    Under Section 7 of GPL version 3, you are granted additional
    permissions described in the GCC Runtime Library Exception, version
 .1, as published by the Free Software Foundation.
    You should have received a copy of the GNU General Public License and
    a copy of the GCC Runtime Library Exception along with this program;
    see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
    <http://www.gnu.org/licenses/>.  */
 #include "hwcap.h"
 #include "asmcfi.h"
 	.syntax	unified
 #if defined(__thumb2__)
 # define PC_OFS 4
         .thumb
         .thumb_func
 #else
 # define PC_OFS 8
 #endif
 #if defined (__thumb2__) && defined(__ARM_ARCH_6T2__)
 # define HAVE_MOVT
 	.arch	armv6t2
 #elif defined (__ARM_ARCH_7A__)
 # define HAVE_MOVT
 	.arch	armv7-a
 #elif defined (__ARM_ARCH_7R__)
 # define HAVE_MOVT
 	.arch	armv7-r
 #elif defined (__ARM_ARCH_7M__)
 # define HAVE_MOVT
 	.arch	armv7-m
 #endif
 #if defined(HAVE_MOVT) && defined(PIC)
 .macro ldaddr reg, addr
 	movw	\reg, #:lower16:(\addr - (98f + PC_OFS))
 	movt	\reg, #:upper16:(\addr - (98f + PC_OFS))
 :	add	\reg, \reg, pc
 .endm
 #elif defined(HAVE_MOVT)
 .macro ldaddr reg, addr
 	movw	\reg, #:lower16:\addr
 	movt	\reg, #:upper16:\addr
 .endm
 #elif defined(PIC)
 .macro ldaddr reg, addr
 	ldr	\reg, 99f
 :	add	\reg, \reg, pc
 .subsection 1
 	.align	2
 :	.word	\addr - (98b + PC_OFS)
 .subsection 0
 .endm
 #else
 .macro ldaddr reg, addr
 	ldr	\reg, =\addr
 .endm
 #endif
 	.text
 	.align	2
 	.global	_ITM_beginTransaction
 	.type	_ITM_beginTransaction, %function
 _ITM_beginTransaction:
 	.fnstart
 	cfi_startproc
 	mov	ip, sp
 	push	{ r4-r11, ip, lr }
 	.save	{ lr }
 	.pad	#(9*4)
 	cfi_adjust_cfa_offset(40)
 	cfi_rel_offset(lr, 36)
 	sub	sp, sp, #(14*8)
 	.pad	#(14*8)
 	cfi_adjust_cfa_offset(14*8)
 	ldaddr	r2, GTM_hwcap
 	ldr	r2, [r2]
 	/* Store the VFP registers.  Don't use VFP instructions directly
 	   because this code is used in non-VFP multilibs.  */
 	tst	r2, #HWCAP_ARM_VFP
 	beq	1f
 	stc	p11, cr8, [sp], {16}	/* vstm sp, {d8-d15} */
 :
 	/* Save the call-preserved iWMMXt registers.  */
 	tst	r2, #HWCAP_ARM_IWMMXT
 	beq	1f
 	stcl	p1, cr10, [sp, #64]	/* wstrd wr10, [sp, #64] */
 	stcl	p1, cr11, [sp, #72]
 	stcl	p1, cr12, [sp, #80]
 	stcl	p1, cr13, [sp, #88]
 	stcl	p1, cr14, [sp, #96]
 	stcl	p1, cr15, [sp, #104]
 :
 	/* Invoke GTM_begin_transaction with the struct we just built.  */
 	mov	r1, sp
 	bl	GTM_begin_transaction
 	/* Return; we don't need to restore any of the call-saved regs.  */
 	add     sp, sp, #(14*8 + 9*4)
 	cfi_adjust_cfa_offset(-(14*8 + 9*4))
 	pop	{ pc }
 	.fnend
 	cfi_endproc
 	.size	_ITM_beginTransaction, . - _ITM_beginTransaction
 	.align	2
 	.global	GTM_longjmp
 	.hidden	GTM_longjmp
 	.type	GTM_longjmp, %function
 GTM_longjmp:
 	cfi_startproc
 	ldaddr	r2, GTM_hwcap
 	ldr	r2, [r2]
 	tst	r2, #HWCAP_ARM_VFP
 	beq	1f
 	ldc	p11, cr8, [r1], {16}	/* vldmia r1, {d8-d15} */
 :
 	tst	r2, #HWCAP_ARM_IWMMXT
 	beq	1f
 	ldcl	p1, cr10, [r1, #64]	/* wldrd wr10, [r1, #64] */
 	ldcl	p1, cr11, [r1, #72]
 	ldcl	p1, cr12, [r1, #80]
 	ldcl	p1, cr13, [r1, #88]
 	ldcl	p1, cr14, [r1, #96]
 	ldcl	p1, cr15, [r1, #104]
 :
 	add	r1, r1, #(14*8)		/* Skip both VFP and iWMMXt blocks */
 #ifdef __thumb2__
 	ldm	r1, { r4-r11, ip, lr }
 	cfi_def_cfa(ip, 0)
 	mov	sp, ip
 	bx	lr
 #else
 	ldm	r1, { r4-r11, sp, pc }
 #endif
 	cfi_endproc
 	.size	GTM_longjmp, . - GTM_longjmp
-#ifdef __linux__
+#if defined(__ELF__) && defined(__linux__)
 .section .note.GNU-stack, "", %progbits
 #endif

 @@ -1,433 +1,433 @@
 /* Copyright (C) 2012-2013 Free Software Foundation, Inc.
    Contributed by Richard Henderson <rth@redhat.com>.
    This file is part of the GNU Transactional Memory Library (libitm).
    Libitm is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    Libitm is distributed in the hope that it will be useful, but WITHOUT ANY
    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
    more details.
    Under Section 7 of GPL version 3, you are granted additional
    permissions described in the GCC Runtime Library Exception, version
 .1, as published by the Free Software Foundation.
    You should have received a copy of the GNU General Public License and
    a copy of the GCC Runtime Library Exception along with this program;
    see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
    <http://www.gnu.org/licenses/>.  */
 	.text
 #include "asmcfi.h"
 #if defined(__powerpc64__) && _CALL_ELF == 2
 .macro FUNC name
         .globl  \name
         .type   \name, @function
 \name:
 :	addis 2,12,(.TOC.-0b)@ha
 	addi 2,2,(.TOC.-0b)@l
 	.localentry \name, . - \name
 .endm
 .macro END name
 	.size	\name, . - \name
 .endm
 .macro HIDDEN name
 	.hidden	\name
 .endm
 .macro CALL name
 	bl	\name
 	nop
 .endm
 #elif defined(__powerpc64__) && defined(__ELF__)
 .macro FUNC name
         .globl  \name, .\name
         .section ".opd","aw"
         .align  3
 \name:
         .quad   .\name, .TOC.@tocbase, 0
         .size   \name, 24
         .type   .\name, @function
         .text
 .\name:
 .endm
 .macro END name
 	.size	.\name, . - .\name
 .endm
 .macro HIDDEN name
 	.hidden	\name, .\name
 .endm
 .macro CALL name
 	bl	\name
 	nop
 .endm
 #elif defined(__ELF__)
 .macro FUNC name
 	.globl	\name
 	.type	\name, @function
 \name:
 .endm
 .macro END name
 	.size	\name, . - \name
 .endm
 .macro HIDDEN name
 	.hidden	\name
 .endm
 .macro CALL name
 	bl	\name
 .endm
 #elif defined(_CALL_DARWIN)
 .macro FUNC name
 	.globl	_$0
 _$0:
 .endmacro
 .macro END name
 .endmacro
 .macro HIDDEN name
 	.private_extern _$0
 .endmacro
 .macro CALL name
 	bl	_$0
 .endmacro
 # ifdef __ppc64__
 	.machine ppc64
 # else
 	.machine ppc7400
 # endif
 #else
 #error "unsupported system"
 #endif
 /* Parameterize the naming of registers.  */
 #if defined(__ELF__)
 # define r(N)	%r##N
 # define f(N)	%f##N
 # define v(N)	%v##N
 #elif defined(__MACH__)
 # define r(N)	r##N
 # define f(N)	f##N
 # define v(N)	v##N
 #else
 # define r(N)	N
 # define f(N)	N
 # define v(N)	N
 #endif
 /* Parameterize the code for 32-bit vs 64-bit.  */
 #if defined(__powerpc64__) || defined(__ppc64__)
 #define ldreg	ld
 #define	streg	std
 #define	stregu	stdu
 #define WS	8
 #else
 #define ldreg	lwz
 #define streg	stw
 #define stregu	stwu
 #define WS	4
 #endif
 /* Parameterize the code for call frame constants.  */
 #if defined(_CALL_AIXDESC)
 # define BASE		6*WS
 # define LR_SAVE	2*WS
 #elif _CALL_ELF == 2
 # define BASE		6*WS
 # define LR_SAVE	2*WS
 #elif defined(_CALL_SYSV)
 # define BASE		2*WS
 # define LR_SAVE	1*WS
 #elif defined(_CALL_DARWIN)
 # define BASE		(6*WS + 2*WS)
 # define LR_SAVE	2*WS
 #else
 # error "unsupported system"
 #endif
 #if defined(__ALTIVEC__) || defined(__VSX__)
 # define OFS_VR		0
 # define OFS_VSCR	12*16
 # define OFS_VR_END	OFS_VSCR + 8
 #else
 # define OFS_VR_END	0
 #endif
 #ifndef _SOFT_FLOAT
 # define OFS_FR		OFS_VR_END
 # define OFS_FPSCR	OFS_FR + 18*8
 # define OFS_FR_END	OFS_FPSCR + 8
 #else
 # define OFS_FR_END	OFS_VR_END
 #endif
 #define OFS_GR		OFS_FR_END
 #define OFS_CFA		OFS_GR + 18*WS
 #define OFS_LR		OFS_CFA + WS
 #define OFS_TOC		OFS_LR + WS
 #define OFS_CR		OFS_TOC + WS
 #define OFS_END		(((OFS_CR + WS + 15) / 16) * 16)
 #define FRAME		(((BASE + OFS_END + 15) / 16) * 16)
 #define VRSAVE		256
 	.align	4
 FUNC _ITM_beginTransaction
 	cfi_startproc
 	mflr	r(0)
 	mfcr	r(5)
 	addi	r(4), r(1), -OFS_END
 	mr	r(6), r(1)
 	streg	r(0), LR_SAVE(r(1))
 	stregu	r(1), -FRAME(r(1))
 	cfi_def_cfa_offset(FRAME)
 	cfi_offset(65, LR_SAVE)
 	streg	r(6),  OFS_CFA(r(4))
 	streg	r(0),   OFS_LR(r(4))
 #ifdef _CALL_DARWIN
 	streg	r(13),  OFS_TOC(r(4))
 #else
 	streg	r(2),   OFS_TOC(r(4))
 #endif
 	streg	r(5),   OFS_CR(r(4))
 	streg	r(14),  0*WS+OFS_GR(r(4))
 	streg	r(15),  1*WS+OFS_GR(r(4))
 	streg	r(16),  2*WS+OFS_GR(r(4))
 	streg	r(17),  3*WS+OFS_GR(r(4))
 	streg	r(18),  4*WS+OFS_GR(r(4))
 	streg	r(19),  5*WS+OFS_GR(r(4))
 	streg	r(20),  6*WS+OFS_GR(r(4))
 	streg	r(21),  7*WS+OFS_GR(r(4))
 	streg	r(22),  8*WS+OFS_GR(r(4))
 	streg	r(23),  9*WS+OFS_GR(r(4))
 	streg	r(24), 10*WS+OFS_GR(r(4))
 	streg	r(25), 11*WS+OFS_GR(r(4))
 	streg	r(26), 12*WS+OFS_GR(r(4))
 	streg	r(27), 13*WS+OFS_GR(r(4))
 	streg	r(28), 14*WS+OFS_GR(r(4))
 	streg	r(29), 15*WS+OFS_GR(r(4))
 	streg	r(30), 16*WS+OFS_GR(r(4))
 	streg	r(31), 17*WS+OFS_GR(r(4))
 #ifndef _SOFT_FLOAT
 	/* ??? Determine when FPRs not present.  */
 	/* ??? Test r(3) for pr_hasNoFloatUpdate and skip the fp save.
 	   This is not yet set by the compiler.  */
 	mffs	f(0)
 	stfd	f(14),  0+OFS_FR(r(4))
 	stfd	f(15),  8+OFS_FR(r(4))
 	stfd	f(16), 16+OFS_FR(r(4))
 	stfd	f(17), 24+OFS_FR(r(4))
 	stfd	f(18), 32+OFS_FR(r(4))
 	stfd	f(19), 40+OFS_FR(r(4))
 	stfd	f(20), 48+OFS_FR(r(4))
 	stfd	f(21), 56+OFS_FR(r(4))
 	stfd	f(22), 64+OFS_FR(r(4))
 	stfd	f(23), 72+OFS_FR(r(4))
 	stfd	f(24), 80+OFS_FR(r(4))
 	stfd	f(25), 88+OFS_FR(r(4))
 	stfd	f(26), 96+OFS_FR(r(4))
 	stfd	f(27),104+OFS_FR(r(4))
 	stfd	f(28),112+OFS_FR(r(4))
 	stfd	f(29),120+OFS_FR(r(4))
 	stfd	f(30),128+OFS_FR(r(4))
 	stfd	f(31),136+OFS_FR(r(4))
 	stfd	f(0), OFS_FPSCR(r(4))
 #endif
 #if defined(__ALTIVEC__)
 	/* ??? Determine when VRs not present.  */
 	/* ??? Test r(3) for pr_hasNoVectorUpdate and skip the vr save.
 	   This is not yet set by the compiler.  */
 	addi	r(5), r(4), OFS_VR
 	addi	r(6), r(4), OFS_VR+16
 	mfspr	r(0), VRSAVE
 	stvx	v(20), 0, r(5)
 	addi	r(5), r(5), 32
 	stvx	v(21), 0, r(6)
 	addi	r(6), r(6), 32
 	stvx	v(22), 0, r(5)
 	addi	r(5), r(5), 32
 	stvx	v(23), 0, r(6)
 	addi	r(6), r(6), 32
 	stvx	v(25), 0, r(5)
 	addi	r(5), r(5), 32
 	stvx	v(26), 0, r(6)
 	addi	r(6), r(6), 32
 	stvx	v(26), 0, r(5)
 	addi	r(5), r(5), 32
 	stvx	v(27), 0, r(6)
 	addi	r(6), r(6), 32
 	stvx	v(28), 0, r(5)
 	addi	r(5), r(5), 32
 	stvx	v(29), 0, r(6)
 	addi	r(6), r(6), 32
 	stvx	v(30), 0, r(5)
 	stvx	v(31), 0, r(6)
 	streg	r(0), OFS_VSCR(r(4))
 #endif
 	CALL	GTM_begin_transaction
 	ldreg	r(0), LR_SAVE+FRAME(r(1))
 	mtlr	r(0)
 	addi	r(1), r(1), FRAME
 	cfi_def_cfa_offset(0)
 	cfi_restore(65)
 	blr
 	cfi_endproc
 END _ITM_beginTransaction
 	.align 4
 	HIDDEN	GTM_longjmp
 FUNC GTM_longjmp
 	cfi_startproc
 #if defined(__ALTIVEC__) || defined(__VSX__)
 	/* ??? Determine when VRs not present.  */
 	/* ??? Test r(5) for pr_hasNoVectorUpdate and skip the vr restore.
 	   This is not yet set by the compiler.  */
 	addi	r(6), r(4), OFS_VR
 	addi	r(7), r(4), OFS_VR+16
 	ldreg	r(0), OFS_VSCR(r(4))
 	cfi_undefined(v(20))
 	cfi_undefined(v(21))
 	cfi_undefined(v(22))
 	cfi_undefined(v(23))
 	cfi_undefined(v(24))
 	cfi_undefined(v(25))
 	cfi_undefined(v(26))
 	cfi_undefined(v(27))
 	cfi_undefined(v(28))
 	cfi_undefined(v(29))
 	cfi_undefined(v(30))
 	cfi_undefined(v(31))
 	lvx	v(20), 0, r(6)
 	addi	r(6), r(6), 32
 	lvx	v(21), 0, r(7)
 	addi	r(7), r(7), 32
 	lvx	v(22), 0, r(6)
 	addi	r(6), r(6), 32
 	lvx	v(23), 0, r(7)
 	addi	r(7), r(7), 32
 	lvx	v(24), 0, r(6)
 	addi	r(6), r(6), 32
 	lvx	v(25), 0, r(7)
 	addi	r(7), r(7), 32
 	lvx	v(26), 0, r(6)
 	addi	r(6), r(6), 32
 	lvx	v(27), 0, r(7)
 	addi	r(7), r(7), 32
 	lvx	v(28), 0, r(6)
 	addi	r(6), r(6), 32
 	lvx	v(29), 0, r(7)
 	addi	r(7), r(7), 32
 	lvx	v(30), 0, r(6)
 	lvx	v(31), 0, r(7)
 	mtspr	VRSAVE, r(0)
 #endif
 #ifndef _SOFT_FLOAT
 	/* ??? Determine when FPRs not present.  */
 	/* ??? Test r(5) for pr_hasNoFloatUpdate and skip the fp load.
 	   This is not yet set by the compiler.  */
 	lfd	f(0), OFS_FPSCR(r(4))
 	cfi_undefined(f(14))
 	cfi_undefined(f(15))
 	cfi_undefined(f(16))
 	cfi_undefined(f(17))
 	cfi_undefined(f(18))
 	cfi_undefined(f(19))
 	cfi_undefined(f(20))
 	cfi_undefined(f(21))
 	cfi_undefined(f(22))
 	cfi_undefined(f(23))
 	cfi_undefined(f(24))
 	cfi_undefined(f(25))
 	cfi_undefined(f(26))
 	cfi_undefined(f(27))
 	cfi_undefined(f(28))
 	cfi_undefined(f(29))
 	cfi_undefined(f(30))
 	cfi_undefined(f(31))
 	lfd	f(14),  0+OFS_FR(r(4))
 	lfd	f(15),  8+OFS_FR(r(4))
 	lfd	f(16), 16+OFS_FR(r(4))
 	lfd	f(17), 24+OFS_FR(r(4))
 	lfd	f(18), 32+OFS_FR(r(4))
 	lfd	f(19), 40+OFS_FR(r(4))
 	lfd	f(20), 48+OFS_FR(r(4))
 	lfd	f(21), 56+OFS_FR(r(4))
 	lfd	f(22), 64+OFS_FR(r(4))
 	lfd	f(23), 72+OFS_FR(r(4))
 	lfd	f(24), 80+OFS_FR(r(4))
 	lfd	f(25), 88+OFS_FR(r(4))
 	lfd	f(26), 96+OFS_FR(r(4))
 	lfd	f(27),104+OFS_FR(r(4))
 	lfd	f(28),112+OFS_FR(r(4))
 	lfd	f(29),120+OFS_FR(r(4))
 	lfd	f(30),128+OFS_FR(r(4))
 	lfd	f(31),136+OFS_FR(r(4))
 	mtfsf	0xff, f(0)
 #endif
 	ldreg	r(6),   OFS_CFA(r(4))
 	ldreg	r(0),   OFS_LR(r(4))
 #ifdef _CALL_DARWIN
 	ldreg	r(13),  OFS_TOC(r(4))
 #else
 	ldreg	r(2),   OFS_TOC(r(4))
 #endif
 	ldreg	r(7),   OFS_CR(r(4))
 	/* At the instant we restore the LR, the only coherent view of
 	   the world we have is into the new stack frame.  Define the
 	   CFA in terms of the not-yet-restored stack pointer.  This will
 	   last until the end of the function.  */
 	mtlr	r(0)
 	cfi_def_cfa(r(6), 0)
 	cfi_undefined(r(14))
 	cfi_undefined(r(15))
 	cfi_undefined(r(16))
 	cfi_undefined(r(17))
 	cfi_undefined(r(18))
 	cfi_undefined(r(19))
 	cfi_undefined(r(20))
 	cfi_undefined(r(21))
 	cfi_undefined(r(22))
 	cfi_undefined(r(23))
 	cfi_undefined(r(24))
 	cfi_undefined(r(25))
 	cfi_undefined(r(26))
 	cfi_undefined(r(27))
 	cfi_undefined(r(28))
 	cfi_undefined(r(29))
 	cfi_undefined(r(30))
 	cfi_undefined(r(31))
 	mtcr	r(7)
 	ldreg	r(14),  0*WS+OFS_GR(r(4))
 	ldreg	r(15),  1*WS+OFS_GR(r(4))
 	ldreg	r(16),  2*WS+OFS_GR(r(4))
 	ldreg	r(17),  3*WS+OFS_GR(r(4))
 	ldreg	r(18),  4*WS+OFS_GR(r(4))
 	ldreg	r(19),  5*WS+OFS_GR(r(4))
 	ldreg	r(20),  6*WS+OFS_GR(r(4))
 	ldreg	r(21),  7*WS+OFS_GR(r(4))
 	ldreg	r(22),  8*WS+OFS_GR(r(4))
 	ldreg	r(23),  9*WS+OFS_GR(r(4))
 	ldreg	r(24), 10*WS+OFS_GR(r(4))
 	ldreg	r(25), 11*WS+OFS_GR(r(4))
 	ldreg	r(26), 12*WS+OFS_GR(r(4))
 	ldreg	r(27), 13*WS+OFS_GR(r(4))
 	ldreg	r(28), 14*WS+OFS_GR(r(4))
 	ldreg	r(29), 15*WS+OFS_GR(r(4))
 	ldreg	r(30), 16*WS+OFS_GR(r(4))
 	ldreg	r(31), 17*WS+OFS_GR(r(4))
 	mr	r(1), r(6)
 	blr
 	cfi_endproc
 END GTM_longjmp
-#ifdef __linux__
+#if defined(__ELF__) && defined(__linux__)
 .section .note.GNU-stack, "", @progbits
 #endif

 @@ -1,108 +1,110 @@
 /* Copyright (C) 2013 Free Software Foundation, Inc.
    Contributed by Andreas Krebbel <krebbel@linux.vnet.ibm.com>
    This file is part of the GNU Transactional Memory Library (libitm).
    Libitm is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    Libitm is distributed in the hope that it will be useful, but WITHOUT ANY
    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
    more details.
    Under Section 7 of GPL version 3, you are granted additional
    permissions described in the GCC Runtime Library Exception, version
 .1, as published by the Free Software Foundation.
    You should have received a copy of the GNU General Public License and
    a copy of the GCC Runtime Library Exception along with this program;
    see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
    <http://www.gnu.org/licenses/>.  */
 #include "asmcfi.h"
 .text
 	.align 4
 .globl	_ITM_beginTransaction
 	.type _ITM_beginTransaction, @function
 	/* _ITM_beginTransaction (int props); props -> r2 */
 _ITM_beginTransaction:
 	cfi_startproc
 #ifdef __s390x__
 	lgr	%r3,%r15	/* backup stack pointer */
 	aghi	%r15,-304	/* jump buffer (144) + reg save area (160) */
 	cfi_adjust_cfa_offset(304)
 	stmg	%r6,%r14,160(%r15)
 	stg	%r3,72+160(%r15) /* store the old stack pointer */
 	std	%f8,80+160(%r15)
 	std	%f9,88+160(%r15)
 	std	%f10,96+160(%r15)
 	std	%f11,104+160(%r15)
 	std	%f12,112+160(%r15)
 	std	%f13,120+160(%r15)
 	std	%f14,128+160(%r15)
 	std	%f15,136+160(%r15)
 	la	%r3,160(%r15)	/* second argument to GTM_begin_transaction */
 	brasl	%r14,GTM_begin_transaction
 	lg	%r1,64+160(%r15)
 	aghi	%r15,304
 	cfi_adjust_cfa_offset(-304)
 	br	%r1
 #else
 	lr	%r3,%r15	/* backup stack pointer */
 	ahi	%r15,-152	/* jump buffer (56) + reg save area (96) */
 	cfi_adjust_cfa_offset(152)
 	stm	%r6,%r14,96(%r15)
 	st	%r3,36+96(%r15)	/* store the old stack pointer */
 	std	%f4,40+96(%r15)
 	std	%f6,48+96(%r15)
 	la	%r3,96(%r15)	/* second argument to GTM_begin_transaction */
 	/* begin_transaction (uint32_t prop, const gtm_jmpbuf *jb) */
 	brasl	%r14,GTM_begin_transaction /* requires mzarch */
 	l	%r1,32+96(%r15)
 	ahi	%r15,152
 	cfi_adjust_cfa_offset(-152)
 	br	%r1
 #endif
 	cfi_endproc
 	.size _ITM_beginTransaction, .-_ITM_beginTransaction
 	.align 4
 .globl	GTM_longjmp
 	.type GTM_longjmp, @function
 	.hidden GTM_longjmp
 	/* uint32_t GTM_longjmp (uint32_t, const gtm_jmpbuf *, uint32_t) */
 GTM_longjmp:
 	/* First parameter becomes the return value of
 	   _ITM_beginTransaction (r2).
 	   Third parameter is ignored for now.  */
 	cfi_startproc
 #ifdef __s390x__
 	ld	%f8,80(%r3)
 	ld	%f9,88(%r3)
 	ld	%f10,96(%r3)
 	ld	%f11,104(%r3)
 	ld	%f12,112(%r3)
 	ld	%f13,120(%r3)
 	ld	%f14,128(%r3)
 	ld	%f15,136(%r3)
 	lmg	%r6,%r15,0(%r3)
 	br	%r14
 #else
 	ld	%f4,40(%r3)
 	ld	%f6,48(%r3)
 	lm	%r6,%r15,0(%r3)
 	br	%r14
 #endif
 	cfi_endproc
 	.size GTM_longjmp, .-GTM_longjmp
 #if defined(__ELF__) && defined(__linux__)
 	.section .note.GNU-stack, "", @progbits
 #endif

 @@ -1,122 +1,122 @@
 /* Copyright (C) 2011-2013 Free Software Foundation, Inc.
    This file is part of the GNU Transactional Memory Library (libitm).
    Libitm is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    Libitm is distributed in the hope that it will be useful, but WITHOUT ANY
    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
    more details.
    Under Section 7 of GPL version 3, you are granted additional
    permissions described in the GCC Runtime Library Exception, version
 .1, as published by the Free Software Foundation.
    You should have received a copy of the GNU General Public License and
    a copy of the GCC Runtime Library Exception along with this program;
    see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
    <http://www.gnu.org/licenses/>.  */
 #include "asmcfi.h"
 	.text
 	.align	2
 	.global	_ITM_beginTransaction
 	.type	_ITM_beginTransaction, %function
 _ITM_beginTransaction:
 	cfi_startproc
 	mov	r15, r1
 #ifdef __SH_FPU_ANY__
 	fmov.s	fr15, @-r15
 	fmov.s	fr14, @-r15
 	fmov.s	fr13, @-r15
 	fmov.s	fr12, @-r15
 	sts.l	fpscr, @-r15
 #endif /* __SH_FPU_ANY__ */
 	stc.l	gbr, @-r15
 	sts.l	pr, @-r15
 	mov.l	r1, @-r15
 	mov.l	r14, @-r15
 	mov.l	r13, @-r15
 	mov.l	r12, @-r15
 	mov.l	r11, @-r15
 	mov.l	r10, @-r15
 	mov.l	r9, @-r15
 	mov.l	r8, @-r15
 #ifdef __SH_FPU_ANY__
 	cfi_def_cfa_offset (4*15)
 #else
 	cfi_def_cfa_offset (4*10)
 #endif
 #if defined HAVE_ATTRIBUTE_VISIBILITY || !defined __PIC__
 	mov.l	.Lbegin, r1
 	jsr	@r1
 	 mov	r15, r5
 #else
 	mova	.Lgot, r0
 	mov.l	.Lgot, r12
 	add	r0, r12
 	mov.l	.Lbegin, r1
 	bsrf	r1
 	 mov	r15, r5
 .Lbegin0:
 	mov.l	@(4*4,r15), r12
 #endif
 	mov.l	@(8*4,r15), r1
 	lds	r1, pr
 #ifdef __SH_FPU_ANY__
 	add	#(15*4), r15
 #else
 	add	#(10*5), r15
 #endif
 	cfi_def_cfa_offset (0)
 	rts
 	 nop
 	cfi_endproc
         .align  2
 .Lgot:
 	.long	_GLOBAL_OFFSET_TABLE_
 .Lbegin:
 #if defined HAVE_ATTRIBUTE_VISIBILITY || !defined __PIC__
 	.long	GTM_begin_transaction
 #else
 	.long	GTM_begin_transaction@PLT-(.Lbegin0-.)
 #endif
 	.size	_ITM_beginTransaction, . - _ITM_beginTransaction
 	.global	GTM_longjmp
 	.hidden	GTM_longjmp
 	.type	GTM_longjmp, %function
 GTM_longjmp:
 	mov.l	@r5+, r8
 	mov.l	@r5+, r9
 	mov.l	@r5+, r10
 	mov.l	@r5+, r11
 	mov.l	@r5+, r12
 	mov.l	@r5+, r13
 	mov.l	@r5+, r14
 	mov.l	@r5+, r15
 	lds.l	@r5+, pr
 	ldc.l	@r5+, gbr
 #ifdef __SH_FPU_ANY__
 	lds.l	@r5+, fpscr
 	fmov.s	@r5+, fr12
 	fmov.s	@r5+, fr13
 	fmov.s	@r5+, fr14
 	fmov.s	@r5+, fr15
 #endif
 	rts
 	 mov	r4, r0
 	.size	GTM_longjmp, . - GTM_longjmp
-#ifdef __linux__
+#if defined(__ELF__) && defined(__linux__)
 .section .note.GNU-stack, "", %progbits
 #endif

 @@ -1,97 +1,97 @@
 /* Copyright (C) 2012-2013 Free Software Foundation, Inc.
    This file is part of the GNU Transactional Memory Library (libitm).
    Libitm is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    Libitm is distributed in the hope that it will be useful, but WITHOUT ANY
    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
    more details.
    Under Section 7 of GPL version 3, you are granted additional
    permissions described in the GCC Runtime Library Exception, version
 .1, as published by the Free Software Foundation.
    You should have received a copy of the GNU General Public License and
    a copy of the GCC Runtime Library Exception along with this program;
    see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
    <http://www.gnu.org/licenses/>.  */
 #include "asmcfi.h"
 #ifdef __arch64__
 # define WORD_SIZE 8
 # define MIN_FRAME_SIZE 176
 # define STACK_BIAS 2047
 # define load  ldx
 # define store stx
 #else
 # define WORD_SIZE 4
 # define MIN_FRAME_SIZE 96
 # define STACK_BIAS 0
 # define load  ld
 # define store st
 #endif
 /* Fields of the JmpBuf structure.  */
 #define JB_CFA 0
 #define JB_PC  1
 #define OFFSET(FIELD) ((FIELD) * WORD_SIZE)
 /* The frame size must be a multiple of the double-word size.  */
 #define FRAME_SIZE (MIN_FRAME_SIZE + 2 * WORD_SIZE)
 #define JB_OFFSET  (STACK_BIAS + MIN_FRAME_SIZE)
 	.text
 	.align 4
 	.globl	_ITM_beginTransaction
 	.type	_ITM_beginTransaction, #function
 	.proc	016
 _ITM_beginTransaction:
 	cfi_startproc
 	add	%sp, STACK_BIAS, %g1
 	sub	%sp, FRAME_SIZE, %sp
 	cfi_def_cfa_offset(STACK_BIAS + FRAME_SIZE)
 	store	%g1, [%sp + JB_OFFSET + OFFSET (JB_CFA)]
 	store	%o7, [%sp + JB_OFFSET + OFFSET (JB_PC)]
 	/* ??? This triggers an internal error in GDB.  */
 	cfi_offset(%o7, -WORD_SIZE)
 	call	GTM_begin_transaction
 	 add	%sp, JB_OFFSET, %o1
 	load	[%sp + JB_OFFSET + OFFSET (JB_PC)], %o7
 	jmp	%o7+8
 	 add	%sp, FRAME_SIZE, %sp
 	cfi_def_cfa_offset(STACK_BIAS)
 	cfi_endproc
 	.size _ITM_beginTransaction, . - _ITM_beginTransaction
 	.align 4
 	.globl	GTM_longjmp
 #ifdef HAVE_ATTRIBUTE_VISIBILITY
 	.hidden	GTM_longjmp
 #endif
 	.type	GTM_longjmp, #function
 	.proc	016
 GTM_longjmp:
 	cfi_startproc
 	flushw
 #if STACK_BIAS
 	load	[%o1 + OFFSET (JB_CFA)], %g1
 	sub	%g1, STACK_BIAS, %fp
 #else
 	load	[%o1 + OFFSET (JB_CFA)], %fp
 #endif
 	cfi_def_cfa(%fp, STACK_BIAS)
 	load	[%o1 + OFFSET (JB_PC)], %o7
 	jmp	%o7+8
 	 restore %g0, %o0, %o0
 	cfi_endproc
 	.size GTM_longjmp, . - GTM_longjmp
-#ifdef __linux__
+#if defined(__ELF__) && defined(__linux__)
 	.section .note.GNU-stack, "", @progbits
 #endif

 @@ -1,147 +1,147 @@
 /* Copyright (C) 2008-2013 Free Software Foundation, Inc.
    Contributed by Richard Henderson <rth@redhat.com>.
    This file is part of the GNU Transactional Memory Library (libitm).
    Libitm is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    Libitm is distributed in the hope that it will be useful, but WITHOUT ANY
    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
    more details.
    Under Section 7 of GPL version 3, you are granted additional
    permissions described in the GCC Runtime Library Exception, version
 .1, as published by the Free Software Foundation.
    You should have received a copy of the GNU General Public License and
    a copy of the GCC Runtime Library Exception along with this program;
    see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
    <http://www.gnu.org/licenses/>.  */
 #include "asmcfi.h"
 #define CONCAT1(a, b) CONCAT2(a, b)
 #define CONCAT2(a, b) a ## b
 #ifdef __USER_LABEL_PREFIX__
 #  define SYM(x) CONCAT1 (__USER_LABEL_PREFIX__, x)
 #else
 #  define SYM(x) x
 #endif
 #ifdef __ELF__
 #  define TYPE(x) .type SYM(x), @function
 #  define SIZE(x) .size SYM(x), . - SYM(x)
 #  ifdef HAVE_ATTRIBUTE_VISIBILITY
 #    define HIDDEN(x) .hidden SYM(x)
 #  else
 #    define HIDDEN(x)
 #  endif
 #else
 #  define TYPE(x)
 #  define SIZE(x)
 #  ifdef __MACH__
 #    define HIDDEN(x) .private_extern SYM(x)
 #  else
 #    define HIDDEN(x)
 #  endif
 #endif
 	.text
 	.align 4
 	.globl	SYM(_ITM_beginTransaction)
 SYM(_ITM_beginTransaction):
 	cfi_startproc
 #ifdef __x86_64__
 	leaq	8(%rsp), %rax
 	subq	$56, %rsp
 	cfi_def_cfa_offset(64)
 	movq	%rax, (%rsp)
 	movq	%rbx, 8(%rsp)
 	movq	%rbp, 16(%rsp)
 	movq	%r12, 24(%rsp)
 	movq	%r13, 32(%rsp)
 	movq	%r14, 40(%rsp)
 	movq	%r15, 48(%rsp)
 	movq	%rsp, %rsi
 	call	SYM(GTM_begin_transaction)
 	addq	$56, %rsp
 	cfi_def_cfa_offset(8)
 #else
 	leal	4(%esp), %ecx
 	movl	4(%esp), %eax
 	subl	$28, %esp
 	cfi_def_cfa_offset(32)
 	movl	%ecx, 8(%esp)
 	movl	%ebx, 12(%esp)
 	movl	%esi, 16(%esp)
 	movl	%edi, 20(%esp)
 	movl	%ebp, 24(%esp)
 	leal	8(%esp), %edx
 #if defined HAVE_ATTRIBUTE_VISIBILITY || !defined __PIC__
 	call	SYM(GTM_begin_transaction)
 #elif defined __ELF__
 	call	1f
 :	popl	%ebx
 	addl	$_GLOBAL_OFFSET_TABLE_+[.-1b], %ebx
 	call	SYM(GTM_begin_transaction)@PLT
 	movl	12(%esp), %ebx
 #else
 # error "Unsupported PIC sequence"
 #endif
 	addl	$28, %esp
 	cfi_def_cfa_offset(4)
 #endif
 	ret
 	cfi_endproc
 	TYPE(_ITM_beginTransaction)
 	SIZE(_ITM_beginTransaction)
 	.align 4
 	.globl	SYM(GTM_longjmp)
 SYM(GTM_longjmp):
 	cfi_startproc
 #ifdef __x86_64__
 	movq	(%rsi), %rcx
 	movq	8(%rsi), %rbx
 	movq	16(%rsi), %rbp
 	movq	24(%rsi), %r12
 	movq	32(%rsi), %r13
 	movq	40(%rsi), %r14
 	movq	48(%rsi), %r15
 	movl	%edi, %eax
 	cfi_def_cfa(%rsi, 0)
 	cfi_offset(%rip, 56)
 	cfi_register(%rsp, %rcx)
 	movq	%rcx, %rsp
 	jmp	*56(%rsi)
 #else
 	movl	(%edx), %ecx
 	movl	4(%edx), %ebx
 	movl	8(%edx), %esi
 	movl	12(%edx), %edi
 	movl	16(%edx), %ebp
 	cfi_def_cfa(%edx, 0)
 	cfi_offset(%eip, 20)
 	cfi_register(%esp, %ecx)
 	movl	%ecx, %esp
 	jmp	*20(%edx)
 #endif
 	cfi_endproc
 	TYPE(GTM_longjmp)
 	HIDDEN(GTM_longjmp)
 	SIZE(GTM_longjmp)
-#ifdef __linux__
+#if defined(__ELF__) && defined(__linux__)
 .section .note.GNU-stack, "", @progbits
 #endif

 @@ -1,172 +1,172 @@
 .section .text
 .globl __tsan_trace_switch_thunk
 __tsan_trace_switch_thunk:
   .cfi_startproc
   # Save scratch registers.
   push %rax
   .cfi_adjust_cfa_offset 8
   .cfi_rel_offset %rax, 0
   push %rcx
   .cfi_adjust_cfa_offset 8
   .cfi_rel_offset %rcx, 0
   push %rdx
   .cfi_adjust_cfa_offset 8
   .cfi_rel_offset %rdx, 0
   push %rsi
   .cfi_adjust_cfa_offset 8
   .cfi_rel_offset %rsi, 0
   push %rdi
   .cfi_adjust_cfa_offset 8
   .cfi_rel_offset %rdi, 0
   push %r8
   .cfi_adjust_cfa_offset 8
   .cfi_rel_offset %r8, 0
   push %r9
   .cfi_adjust_cfa_offset 8
   .cfi_rel_offset %r9, 0
   push %r10
   .cfi_adjust_cfa_offset 8
   .cfi_rel_offset %r10, 0
   push %r11
   .cfi_adjust_cfa_offset 8
   .cfi_rel_offset %r11, 0
   # Align stack frame.
   push %rbx  # non-scratch
   .cfi_adjust_cfa_offset 8
   .cfi_rel_offset %rbx, 0
   mov %rsp, %rbx  # save current rsp
   .cfi_def_cfa_register %rbx
   shr $4, %rsp  # clear 4 lsb, align to 16
   shl $4, %rsp
 #ifdef __PIC__
   call __tsan_trace_switch@PLT
 #else
   call __tsan_trace_switch
 #endif
   # Unalign stack frame back.
   mov %rbx, %rsp  # restore the original rsp
   .cfi_def_cfa_register %rsp
   pop %rbx
   .cfi_adjust_cfa_offset -8
   # Restore scratch registers.
   pop %r11
   .cfi_adjust_cfa_offset -8
   pop %r10
   .cfi_adjust_cfa_offset -8
   pop %r9
   .cfi_adjust_cfa_offset -8
   pop %r8
   .cfi_adjust_cfa_offset -8
   pop %rdi
   .cfi_adjust_cfa_offset -8
   pop %rsi
   .cfi_adjust_cfa_offset -8
   pop %rdx
   .cfi_adjust_cfa_offset -8
   pop %rcx
   .cfi_adjust_cfa_offset -8
   pop %rax
   .cfi_adjust_cfa_offset -8
   .cfi_restore %rax
   .cfi_restore %rbx
   .cfi_restore %rcx
   .cfi_restore %rdx
   .cfi_restore %rsi
   .cfi_restore %rdi
   .cfi_restore %r8
   .cfi_restore %r9
   .cfi_restore %r10
   .cfi_restore %r11
   ret
   .cfi_endproc
 .globl __tsan_report_race_thunk
 __tsan_report_race_thunk:
   .cfi_startproc
   # Save scratch registers.
   push %rax
   .cfi_adjust_cfa_offset 8
   .cfi_rel_offset %rax, 0
   push %rcx
   .cfi_adjust_cfa_offset 8
   .cfi_rel_offset %rcx, 0
   push %rdx
   .cfi_adjust_cfa_offset 8
   .cfi_rel_offset %rdx, 0
   push %rsi
   .cfi_adjust_cfa_offset 8
   .cfi_rel_offset %rsi, 0
   push %rdi
   .cfi_adjust_cfa_offset 8
   .cfi_rel_offset %rdi, 0
   push %r8
   .cfi_adjust_cfa_offset 8
   .cfi_rel_offset %r8, 0
   push %r9
   .cfi_adjust_cfa_offset 8
   .cfi_rel_offset %r9, 0
   push %r10
   .cfi_adjust_cfa_offset 8
   .cfi_rel_offset %r10, 0
   push %r11
   .cfi_adjust_cfa_offset 8
   .cfi_rel_offset %r11, 0
   # Align stack frame.
   push %rbx  # non-scratch
   .cfi_adjust_cfa_offset 8
   .cfi_rel_offset %rbx, 0
   mov %rsp, %rbx  # save current rsp
   .cfi_def_cfa_register %rbx
   shr $4, %rsp  # clear 4 lsb, align to 16
   shl $4, %rsp
 #ifdef __PIC__
   call __tsan_report_race@PLT
 #else
   call __tsan_report_race
 #endif
   # Unalign stack frame back.
   mov %rbx, %rsp  # restore the original rsp
   .cfi_def_cfa_register %rsp
   pop %rbx
   .cfi_adjust_cfa_offset -8
   # Restore scratch registers.
   pop %r11
   .cfi_adjust_cfa_offset -8
   pop %r10
   .cfi_adjust_cfa_offset -8
   pop %r9
   .cfi_adjust_cfa_offset -8
   pop %r8
   .cfi_adjust_cfa_offset -8
   pop %rdi
   .cfi_adjust_cfa_offset -8
   pop %rsi
   .cfi_adjust_cfa_offset -8
   pop %rdx
   .cfi_adjust_cfa_offset -8
   pop %rcx
   .cfi_adjust_cfa_offset -8
   pop %rax
   .cfi_adjust_cfa_offset -8
   .cfi_restore %rax
   .cfi_restore %rbx
   .cfi_restore %rcx
   .cfi_restore %rdx
   .cfi_restore %rsi
   .cfi_restore %rdi
   .cfi_restore %r8
   .cfi_restore %r9
   .cfi_restore %r10
   .cfi_restore %r11
   ret
   .cfi_endproc
-#ifdef __linux__
+#if defined(__ELF__) && defined(__linux__)
 /* We do not need executable stack.  */
 .section        .note.GNU-stack,"",@progbits
 #endif