| /* |
| * CDDL HEADER START |
| * |
| * The contents of this file are subject to the terms of the |
| * Common Development and Distribution License (the "License"). |
| * You may not use this file except in compliance with the License. |
| * |
| * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE |
| * or http://www.opensolaris.org/os/licensing. |
| * See the License for the specific language governing permissions |
| * and limitations under the License. |
| * |
| * When distributing Covered Code, include this CDDL HEADER in each |
| * file and include the License file at usr/src/OPENSOLARIS.LICENSE. |
| * If applicable, add the following below this CDDL HEADER, with the |
| * fields enclosed by brackets "[]" replaced with your own identifying |
| * information: Portions Copyright [yyyy] [name of copyright owner] |
| * |
| * CDDL HEADER END |
| */ |
| /* |
| * Copyright 2007 Sun Microsystems, Inc. All rights reserved. |
| * Use is subject to license terms. |
| */ |
| |
| .ident "%Z%%M% %I% %E% SMI" |
| |
| .file "%M%" |
| |
| #define _ASM |
| #include <ia32/sys/asm_linkage.h> |
| |
| ENTRY(atomic_inc_8) |
| ALTENTRY(atomic_inc_uchar) |
| movl 4(%esp), %eax |
| lock |
| incb (%eax) |
| ret |
| SET_SIZE(atomic_inc_uchar) |
| SET_SIZE(atomic_inc_8) |
| |
| ENTRY(atomic_inc_16) |
| ALTENTRY(atomic_inc_ushort) |
| movl 4(%esp), %eax |
| lock |
| incw (%eax) |
| ret |
| SET_SIZE(atomic_inc_ushort) |
| SET_SIZE(atomic_inc_16) |
| |
| ENTRY(atomic_inc_32) |
| ALTENTRY(atomic_inc_uint) |
| ALTENTRY(atomic_inc_ulong) |
| movl 4(%esp), %eax |
| lock |
| incl (%eax) |
| ret |
| SET_SIZE(atomic_inc_ulong) |
| SET_SIZE(atomic_inc_uint) |
| SET_SIZE(atomic_inc_32) |
| |
| ENTRY(atomic_inc_8_nv) |
| ALTENTRY(atomic_inc_uchar_nv) |
| movl 4(%esp), %edx |
| movb (%edx), %al |
| 1: |
| leal 1(%eax), %ecx |
| lock |
| cmpxchgb %cl, (%edx) |
| jne 1b |
| movzbl %cl, %eax |
| ret |
| SET_SIZE(atomic_inc_uchar_nv) |
| SET_SIZE(atomic_inc_8_nv) |
| |
| ENTRY(atomic_inc_16_nv) |
| ALTENTRY(atomic_inc_ushort_nv) |
| movl 4(%esp), %edx |
| movw (%edx), %ax |
| 1: |
| leal 1(%eax), %ecx |
| lock |
| cmpxchgw %cx, (%edx) |
| jne 1b |
| movzwl %cx, %eax |
| ret |
| SET_SIZE(atomic_inc_ushort_nv) |
| SET_SIZE(atomic_inc_16_nv) |
| |
| ENTRY(atomic_inc_32_nv) |
| ALTENTRY(atomic_inc_uint_nv) |
| ALTENTRY(atomic_inc_ulong_nv) |
| movl 4(%esp), %edx |
| movl (%edx), %eax |
| 1: |
| leal 1(%eax), %ecx |
| lock |
| cmpxchgl %ecx, (%edx) |
| jne 1b |
| movl %ecx, %eax |
| ret |
| SET_SIZE(atomic_inc_ulong_nv) |
| SET_SIZE(atomic_inc_uint_nv) |
| SET_SIZE(atomic_inc_32_nv) |
| |
| /* |
| * NOTE: If atomic_inc_64 and atomic_inc_64_nv are ever |
| * separated, you need to also edit the libc i386 platform |
| * specific mapfile and remove the NODYNSORT attribute |
| * from atomic_inc_64_nv. |
| */ |
| ENTRY(atomic_inc_64) |
| ALTENTRY(atomic_inc_64_nv) |
| pushl %edi |
| pushl %ebx |
| movl 12(%esp), %edi |
| movl (%edi), %eax |
| movl 4(%edi), %edx |
| 1: |
| xorl %ebx, %ebx |
| xorl %ecx, %ecx |
| incl %ebx |
| addl %eax, %ebx |
| adcl %edx, %ecx |
| lock |
| cmpxchg8b (%edi) |
| jne 1b |
| movl %ebx, %eax |
| movl %ecx, %edx |
| popl %ebx |
| popl %edi |
| ret |
| SET_SIZE(atomic_inc_64_nv) |
| SET_SIZE(atomic_inc_64) |
| |
| ENTRY(atomic_dec_8) |
| ALTENTRY(atomic_dec_uchar) |
| movl 4(%esp), %eax |
| lock |
| decb (%eax) |
| ret |
| SET_SIZE(atomic_dec_uchar) |
| SET_SIZE(atomic_dec_8) |
| |
| ENTRY(atomic_dec_16) |
| ALTENTRY(atomic_dec_ushort) |
| movl 4(%esp), %eax |
| lock |
| decw (%eax) |
| ret |
| SET_SIZE(atomic_dec_ushort) |
| SET_SIZE(atomic_dec_16) |
| |
| ENTRY(atomic_dec_32) |
| ALTENTRY(atomic_dec_uint) |
| ALTENTRY(atomic_dec_ulong) |
| movl 4(%esp), %eax |
| lock |
| decl (%eax) |
| ret |
| SET_SIZE(atomic_dec_ulong) |
| SET_SIZE(atomic_dec_uint) |
| SET_SIZE(atomic_dec_32) |
| |
| ENTRY(atomic_dec_8_nv) |
| ALTENTRY(atomic_dec_uchar_nv) |
| movl 4(%esp), %edx |
| movb (%edx), %al |
| 1: |
| leal -1(%eax), %ecx |
| lock |
| cmpxchgb %cl, (%edx) |
| jne 1b |
| movzbl %cl, %eax |
| ret |
| SET_SIZE(atomic_dec_uchar_nv) |
| SET_SIZE(atomic_dec_8_nv) |
| |
| ENTRY(atomic_dec_16_nv) |
| ALTENTRY(atomic_dec_ushort_nv) |
| movl 4(%esp), %edx |
| movw (%edx), %ax |
| 1: |
| leal -1(%eax), %ecx |
| lock |
| cmpxchgw %cx, (%edx) |
| jne 1b |
| movzwl %cx, %eax |
| ret |
| SET_SIZE(atomic_dec_ushort_nv) |
| SET_SIZE(atomic_dec_16_nv) |
| |
| ENTRY(atomic_dec_32_nv) |
| ALTENTRY(atomic_dec_uint_nv) |
| ALTENTRY(atomic_dec_ulong_nv) |
| movl 4(%esp), %edx |
| movl (%edx), %eax |
| 1: |
| leal -1(%eax), %ecx |
| lock |
| cmpxchgl %ecx, (%edx) |
| jne 1b |
| movl %ecx, %eax |
| ret |
| SET_SIZE(atomic_dec_ulong_nv) |
| SET_SIZE(atomic_dec_uint_nv) |
| SET_SIZE(atomic_dec_32_nv) |
| |
| /* |
| * NOTE: If atomic_dec_64 and atomic_dec_64_nv are ever |
| * separated, it is important to edit the libc i386 platform |
| * specific mapfile and remove the NODYNSORT attribute |
| * from atomic_dec_64_nv. |
| */ |
| ENTRY(atomic_dec_64) |
| ALTENTRY(atomic_dec_64_nv) |
| pushl %edi |
| pushl %ebx |
| movl 12(%esp), %edi |
| movl (%edi), %eax |
| movl 4(%edi), %edx |
| 1: |
| xorl %ebx, %ebx |
| xorl %ecx, %ecx |
| not %ecx |
| not %ebx |
| addl %eax, %ebx |
| adcl %edx, %ecx |
| lock |
| cmpxchg8b (%edi) |
| jne 1b |
| movl %ebx, %eax |
| movl %ecx, %edx |
| popl %ebx |
| popl %edi |
| ret |
| SET_SIZE(atomic_dec_64_nv) |
| SET_SIZE(atomic_dec_64) |
| |
| ENTRY(atomic_add_8) |
| ALTENTRY(atomic_add_char) |
| movl 4(%esp), %eax |
| movl 8(%esp), %ecx |
| lock |
| addb %cl, (%eax) |
| ret |
| SET_SIZE(atomic_add_char) |
| SET_SIZE(atomic_add_8) |
| |
| ENTRY(atomic_add_16) |
| ALTENTRY(atomic_add_short) |
| movl 4(%esp), %eax |
| movl 8(%esp), %ecx |
| lock |
| addw %cx, (%eax) |
| ret |
| SET_SIZE(atomic_add_short) |
| SET_SIZE(atomic_add_16) |
| |
| ENTRY(atomic_add_32) |
| ALTENTRY(atomic_add_int) |
| ALTENTRY(atomic_add_ptr) |
| ALTENTRY(atomic_add_long) |
| movl 4(%esp), %eax |
| movl 8(%esp), %ecx |
| lock |
| addl %ecx, (%eax) |
| ret |
| SET_SIZE(atomic_add_long) |
| SET_SIZE(atomic_add_ptr) |
| SET_SIZE(atomic_add_int) |
| SET_SIZE(atomic_add_32) |
| |
| ENTRY(atomic_sub_8) |
| ALTENTRY(atomic_sub_char) |
| movl 4(%esp), %eax |
| movl 8(%esp), %ecx |
| lock |
| subb %cl, (%eax) |
| ret |
| SET_SIZE(atomic_sub_char) |
| SET_SIZE(atomic_sub_8) |
| |
| ENTRY(atomic_sub_16) |
| ALTENTRY(atomic_sub_short) |
| movl 4(%esp), %eax |
| movl 8(%esp), %ecx |
| lock |
| subw %cx, (%eax) |
| ret |
| SET_SIZE(atomic_sub_short) |
| SET_SIZE(atomic_sub_16) |
| |
| ENTRY(atomic_sub_32) |
| ALTENTRY(atomic_sub_int) |
| ALTENTRY(atomic_sub_ptr) |
| ALTENTRY(atomic_sub_long) |
| movl 4(%esp), %eax |
| movl 8(%esp), %ecx |
| lock |
| subl %ecx, (%eax) |
| ret |
| SET_SIZE(atomic_sub_long) |
| SET_SIZE(atomic_sub_ptr) |
| SET_SIZE(atomic_sub_int) |
| SET_SIZE(atomic_sub_32) |
| |
| ENTRY(atomic_or_8) |
| ALTENTRY(atomic_or_uchar) |
| movl 4(%esp), %eax |
| movb 8(%esp), %cl |
| lock |
| orb %cl, (%eax) |
| ret |
| SET_SIZE(atomic_or_uchar) |
| SET_SIZE(atomic_or_8) |
| |
| ENTRY(atomic_or_16) |
| ALTENTRY(atomic_or_ushort) |
| movl 4(%esp), %eax |
| movw 8(%esp), %cx |
| lock |
| orw %cx, (%eax) |
| ret |
| SET_SIZE(atomic_or_ushort) |
| SET_SIZE(atomic_or_16) |
| |
| ENTRY(atomic_or_32) |
| ALTENTRY(atomic_or_uint) |
| ALTENTRY(atomic_or_ulong) |
| movl 4(%esp), %eax |
| movl 8(%esp), %ecx |
| lock |
| orl %ecx, (%eax) |
| ret |
| SET_SIZE(atomic_or_ulong) |
| SET_SIZE(atomic_or_uint) |
| SET_SIZE(atomic_or_32) |
| |
| ENTRY(atomic_and_8) |
| ALTENTRY(atomic_and_uchar) |
| movl 4(%esp), %eax |
| movb 8(%esp), %cl |
| lock |
| andb %cl, (%eax) |
| ret |
| SET_SIZE(atomic_and_uchar) |
| SET_SIZE(atomic_and_8) |
| |
| ENTRY(atomic_and_16) |
| ALTENTRY(atomic_and_ushort) |
| movl 4(%esp), %eax |
| movw 8(%esp), %cx |
| lock |
| andw %cx, (%eax) |
| ret |
| SET_SIZE(atomic_and_ushort) |
| SET_SIZE(atomic_and_16) |
| |
| ENTRY(atomic_and_32) |
| ALTENTRY(atomic_and_uint) |
| ALTENTRY(atomic_and_ulong) |
| movl 4(%esp), %eax |
| movl 8(%esp), %ecx |
| lock |
| andl %ecx, (%eax) |
| ret |
| SET_SIZE(atomic_and_ulong) |
| SET_SIZE(atomic_and_uint) |
| SET_SIZE(atomic_and_32) |
| |
| ENTRY(atomic_add_8_nv) |
| ALTENTRY(atomic_add_char_nv) |
| movl 4(%esp), %edx |
| movb (%edx), %al |
| 1: |
| movl 8(%esp), %ecx |
| addb %al, %cl |
| lock |
| cmpxchgb %cl, (%edx) |
| jne 1b |
| movzbl %cl, %eax |
| ret |
| SET_SIZE(atomic_add_char_nv) |
| SET_SIZE(atomic_add_8_nv) |
| |
| ENTRY(atomic_add_16_nv) |
| ALTENTRY(atomic_add_short_nv) |
| movl 4(%esp), %edx |
| movw (%edx), %ax |
| 1: |
| movl 8(%esp), %ecx |
| addw %ax, %cx |
| lock |
| cmpxchgw %cx, (%edx) |
| jne 1b |
| movzwl %cx, %eax |
| ret |
| SET_SIZE(atomic_add_short_nv) |
| SET_SIZE(atomic_add_16_nv) |
| |
| ENTRY(atomic_add_32_nv) |
| ALTENTRY(atomic_add_int_nv) |
| ALTENTRY(atomic_add_ptr_nv) |
| ALTENTRY(atomic_add_long_nv) |
| movl 4(%esp), %edx |
| movl (%edx), %eax |
| 1: |
| movl 8(%esp), %ecx |
| addl %eax, %ecx |
| lock |
| cmpxchgl %ecx, (%edx) |
| jne 1b |
| movl %ecx, %eax |
| ret |
| SET_SIZE(atomic_add_long_nv) |
| SET_SIZE(atomic_add_ptr_nv) |
| SET_SIZE(atomic_add_int_nv) |
| SET_SIZE(atomic_add_32_nv) |
| |
| ENTRY(atomic_sub_8_nv) |
| ALTENTRY(atomic_sub_char_nv) |
| movl 4(%esp), %edx |
| movb (%edx), %al |
| 1: |
| movl 8(%esp), %ecx |
| subb %al, %cl |
| lock |
| cmpxchgb %cl, (%edx) |
| jne 1b |
| movzbl %cl, %eax |
| ret |
| SET_SIZE(atomic_sub_char_nv) |
| SET_SIZE(atomic_sub_8_nv) |
| |
| ENTRY(atomic_sub_16_nv) |
| ALTENTRY(atomic_sub_short_nv) |
| movl 4(%esp), %edx |
| movw (%edx), %ax |
| 1: |
| movl 8(%esp), %ecx |
| subw %ax, %cx |
| lock |
| cmpxchgw %cx, (%edx) |
| jne 1b |
| movzwl %cx, %eax |
| ret |
| SET_SIZE(atomic_sub_short_nv) |
| SET_SIZE(atomic_sub_16_nv) |
| |
| ENTRY(atomic_sub_32_nv) |
| ALTENTRY(atomic_sub_int_nv) |
| ALTENTRY(atomic_sub_ptr_nv) |
| ALTENTRY(atomic_sub_long_nv) |
| movl 4(%esp), %edx |
| movl (%edx), %eax |
| 1: |
| movl 8(%esp), %ecx |
| subl %eax, %ecx |
| lock |
| cmpxchgl %ecx, (%edx) |
| jne 1b |
| movl %ecx, %eax |
| ret |
| SET_SIZE(atomic_sub_long_nv) |
| SET_SIZE(atomic_sub_ptr_nv) |
| SET_SIZE(atomic_sub_int_nv) |
| SET_SIZE(atomic_sub_32_nv) |
| |
| /* |
| * NOTE: If atomic_add_64 and atomic_add_64_nv are ever |
| * separated, it is important to edit the libc i386 platform |
| * specific mapfile and remove the NODYNSORT attribute |
| * from atomic_add_64_nv. |
| */ |
| ENTRY(atomic_add_64) |
| ALTENTRY(atomic_add_64_nv) |
| pushl %edi |
| pushl %ebx |
| movl 12(%esp), %edi |
| movl (%edi), %eax |
| movl 4(%edi), %edx |
| 1: |
| movl 16(%esp), %ebx |
| movl 20(%esp), %ecx |
| addl %eax, %ebx |
| adcl %edx, %ecx |
| lock |
| cmpxchg8b (%edi) |
| jne 1b |
| movl %ebx, %eax |
| movl %ecx, %edx |
| popl %ebx |
| popl %edi |
| ret |
| SET_SIZE(atomic_add_64_nv) |
| SET_SIZE(atomic_add_64) |
| |
| ENTRY(atomic_sub_64) |
| ALTENTRY(atomic_sub_64_nv) |
| pushl %edi |
| pushl %ebx |
| movl 12(%esp), %edi |
| movl (%edi), %eax |
| movl 4(%edi), %edx |
| 1: |
| movl 16(%esp), %ebx |
| movl 20(%esp), %ecx |
| subl %eax, %ebx |
| sbbl %edx, %ecx |
| lock |
| cmpxchg8b (%edi) |
| jne 1b |
| movl %ebx, %eax |
| movl %ecx, %edx |
| popl %ebx |
| popl %edi |
| ret |
| SET_SIZE(atomic_sub_64_nv) |
| SET_SIZE(atomic_sub_64) |
| |
| ENTRY(atomic_or_8_nv) |
| ALTENTRY(atomic_or_uchar_nv) |
| movl 4(%esp), %edx |
| movb (%edx), %al |
| 1: |
| movl 8(%esp), %ecx |
| orb %al, %cl |
| lock |
| cmpxchgb %cl, (%edx) |
| jne 1b |
| movzbl %cl, %eax |
| ret |
| SET_SIZE(atomic_or_uchar_nv) |
| SET_SIZE(atomic_or_8_nv) |
| |
| ENTRY(atomic_or_16_nv) |
| ALTENTRY(atomic_or_ushort_nv) |
| movl 4(%esp), %edx |
| movw (%edx), %ax |
| 1: |
| movl 8(%esp), %ecx |
| orw %ax, %cx |
| lock |
| cmpxchgw %cx, (%edx) |
| jne 1b |
| movzwl %cx, %eax |
| ret |
| SET_SIZE(atomic_or_ushort_nv) |
| SET_SIZE(atomic_or_16_nv) |
| |
| ENTRY(atomic_or_32_nv) |
| ALTENTRY(atomic_or_uint_nv) |
| ALTENTRY(atomic_or_ulong_nv) |
| movl 4(%esp), %edx |
| movl (%edx), %eax |
| 1: |
| movl 8(%esp), %ecx |
| orl %eax, %ecx |
| lock |
| cmpxchgl %ecx, (%edx) |
| jne 1b |
| movl %ecx, %eax |
| ret |
| SET_SIZE(atomic_or_ulong_nv) |
| SET_SIZE(atomic_or_uint_nv) |
| SET_SIZE(atomic_or_32_nv) |
| |
| /* |
| * NOTE: If atomic_or_64 and atomic_or_64_nv are ever |
| * separated, it is important to edit the libc i386 platform |
| * specific mapfile and remove the NODYNSORT attribute |
| * from atomic_or_64_nv. |
| */ |
| ENTRY(atomic_or_64) |
| ALTENTRY(atomic_or_64_nv) |
| pushl %edi |
| pushl %ebx |
| movl 12(%esp), %edi |
| movl (%edi), %eax |
| movl 4(%edi), %edx |
| 1: |
| movl 16(%esp), %ebx |
| movl 20(%esp), %ecx |
| orl %eax, %ebx |
| orl %edx, %ecx |
| lock |
| cmpxchg8b (%edi) |
| jne 1b |
| movl %ebx, %eax |
| movl %ecx, %edx |
| popl %ebx |
| popl %edi |
| ret |
| SET_SIZE(atomic_or_64_nv) |
| SET_SIZE(atomic_or_64) |
| |
| ENTRY(atomic_and_8_nv) |
| ALTENTRY(atomic_and_uchar_nv) |
| movl 4(%esp), %edx |
| movb (%edx), %al |
| 1: |
| movl 8(%esp), %ecx |
| andb %al, %cl |
| lock |
| cmpxchgb %cl, (%edx) |
| jne 1b |
| movzbl %cl, %eax |
| ret |
| SET_SIZE(atomic_and_uchar_nv) |
| SET_SIZE(atomic_and_8_nv) |
| |
| ENTRY(atomic_and_16_nv) |
| ALTENTRY(atomic_and_ushort_nv) |
| movl 4(%esp), %edx |
| movw (%edx), %ax |
| 1: |
| movl 8(%esp), %ecx |
| andw %ax, %cx |
| lock |
| cmpxchgw %cx, (%edx) |
| jne 1b |
| movzwl %cx, %eax |
| ret |
| SET_SIZE(atomic_and_ushort_nv) |
| SET_SIZE(atomic_and_16_nv) |
| |
| ENTRY(atomic_and_32_nv) |
| ALTENTRY(atomic_and_uint_nv) |
| ALTENTRY(atomic_and_ulong_nv) |
| movl 4(%esp), %edx |
| movl (%edx), %eax |
| 1: |
| movl 8(%esp), %ecx |
| andl %eax, %ecx |
| lock |
| cmpxchgl %ecx, (%edx) |
| jne 1b |
| movl %ecx, %eax |
| ret |
| SET_SIZE(atomic_and_ulong_nv) |
| SET_SIZE(atomic_and_uint_nv) |
| SET_SIZE(atomic_and_32_nv) |
| |
| /* |
| * NOTE: If atomic_and_64 and atomic_and_64_nv are ever |
| * separated, it is important to edit the libc i386 platform |
| * specific mapfile and remove the NODYNSORT attribute |
| * from atomic_and_64_nv. |
| */ |
| ENTRY(atomic_and_64) |
| ALTENTRY(atomic_and_64_nv) |
| pushl %edi |
| pushl %ebx |
| movl 12(%esp), %edi |
| movl (%edi), %eax |
| movl 4(%edi), %edx |
| 1: |
| movl 16(%esp), %ebx |
| movl 20(%esp), %ecx |
| andl %eax, %ebx |
| andl %edx, %ecx |
| lock |
| cmpxchg8b (%edi) |
| jne 1b |
| movl %ebx, %eax |
| movl %ecx, %edx |
| popl %ebx |
| popl %edi |
| ret |
| SET_SIZE(atomic_and_64_nv) |
| SET_SIZE(atomic_and_64) |
| |
| ENTRY(atomic_cas_8) |
| ALTENTRY(atomic_cas_uchar) |
| movl 4(%esp), %edx |
| movzbl 8(%esp), %eax |
| movb 12(%esp), %cl |
| lock |
| cmpxchgb %cl, (%edx) |
| ret |
| SET_SIZE(atomic_cas_uchar) |
| SET_SIZE(atomic_cas_8) |
| |
| ENTRY(atomic_cas_16) |
| ALTENTRY(atomic_cas_ushort) |
| movl 4(%esp), %edx |
| movzwl 8(%esp), %eax |
| movw 12(%esp), %cx |
| lock |
| cmpxchgw %cx, (%edx) |
| ret |
| SET_SIZE(atomic_cas_ushort) |
| SET_SIZE(atomic_cas_16) |
| |
| ENTRY(atomic_cas_32) |
| ALTENTRY(atomic_cas_uint) |
| ALTENTRY(atomic_cas_ulong) |
| ALTENTRY(atomic_cas_ptr) |
| movl 4(%esp), %edx |
| movl 8(%esp), %eax |
| movl 12(%esp), %ecx |
| lock |
| cmpxchgl %ecx, (%edx) |
| ret |
| SET_SIZE(atomic_cas_ptr) |
| SET_SIZE(atomic_cas_ulong) |
| SET_SIZE(atomic_cas_uint) |
| SET_SIZE(atomic_cas_32) |
| |
| ENTRY(atomic_cas_64) |
| pushl %ebx |
| pushl %esi |
| movl 12(%esp), %esi |
| movl 16(%esp), %eax |
| movl 20(%esp), %edx |
| movl 24(%esp), %ebx |
| movl 28(%esp), %ecx |
| lock |
| cmpxchg8b (%esi) |
| popl %esi |
| popl %ebx |
| ret |
| SET_SIZE(atomic_cas_64) |
| |
| ENTRY(atomic_swap_8) |
| ALTENTRY(atomic_swap_uchar) |
| movl 4(%esp), %edx |
| movzbl 8(%esp), %eax |
| lock |
| xchgb %al, (%edx) |
| ret |
| SET_SIZE(atomic_swap_uchar) |
| SET_SIZE(atomic_swap_8) |
| |
| ENTRY(atomic_swap_16) |
| ALTENTRY(atomic_swap_ushort) |
| movl 4(%esp), %edx |
| movzwl 8(%esp), %eax |
| lock |
| xchgw %ax, (%edx) |
| ret |
| SET_SIZE(atomic_swap_ushort) |
| SET_SIZE(atomic_swap_16) |
| |
| ENTRY(atomic_swap_32) |
| ALTENTRY(atomic_swap_uint) |
| ALTENTRY(atomic_swap_ptr) |
| ALTENTRY(atomic_swap_ulong) |
| movl 4(%esp), %edx |
| movl 8(%esp), %eax |
| lock |
| xchgl %eax, (%edx) |
| ret |
| SET_SIZE(atomic_swap_ulong) |
| SET_SIZE(atomic_swap_ptr) |
| SET_SIZE(atomic_swap_uint) |
| SET_SIZE(atomic_swap_32) |
| |
| ENTRY(atomic_swap_64) |
| pushl %esi |
| pushl %ebx |
| movl 12(%esp), %esi |
| movl 16(%esp), %ebx |
| movl 20(%esp), %ecx |
| movl (%esi), %eax |
| movl 4(%esi), %edx |
| 1: |
| lock |
| cmpxchg8b (%esi) |
| jne 1b |
| popl %ebx |
| popl %esi |
| ret |
| SET_SIZE(atomic_swap_64) |
| |
| ENTRY(atomic_set_long_excl) |
| movl 4(%esp), %edx |
| movl 8(%esp), %ecx |
| xorl %eax, %eax |
| lock |
| btsl %ecx, (%edx) |
| jnc 1f |
| decl %eax |
| 1: |
| ret |
| SET_SIZE(atomic_set_long_excl) |
| |
| ENTRY(atomic_clear_long_excl) |
| movl 4(%esp), %edx |
| movl 8(%esp), %ecx |
| xorl %eax, %eax |
| lock |
| btrl %ecx, (%edx) |
| jc 1f |
| decl %eax |
| 1: |
| ret |
| SET_SIZE(atomic_clear_long_excl) |
| |
| /* |
| * NOTE: membar_enter, membar_exit, membar_producer, and |
| * membar_consumer are all identical routines. We define them |
| * separately, instead of using ALTENTRY definitions to alias them |
| * together, so that DTrace and debuggers will see a unique address |
| * for them, allowing more accurate tracing. |
| */ |
| |
| |
| ENTRY(membar_enter) |
| lock |
| xorl $0, (%esp) |
| ret |
| SET_SIZE(membar_enter) |
| |
| ENTRY(membar_exit) |
| lock |
| xorl $0, (%esp) |
| ret |
| SET_SIZE(membar_exit) |
| |
| ENTRY(membar_producer) |
| lock |
| xorl $0, (%esp) |
| ret |
| SET_SIZE(membar_producer) |
| |
| ENTRY(membar_consumer) |
| lock |
| xorl $0, (%esp) |
| ret |
| SET_SIZE(membar_consumer) |
| |
| #ifdef __ELF__ |
| .section .note.GNU-stack,"",%progbits |
| #endif |
