| /*************************************************************************** |
| * |
| * x86_64/atomic.s |
| * |
| * $Id$ |
| * |
| *************************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed |
| * with this work for additional information regarding copyright |
| * ownership. The ASF licenses this file to you under the Apache |
| * License, Version 2.0 (the "License"); you may not use this file |
| * except in compliance with the License. You may obtain a copy of |
| * the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or |
| * implied. See the License for the specific language governing |
| * permissions and limitations under the License. |
| * |
| * Copyright 2005-2006 Rogue Wave Software. |
| * |
| **************************************************************************/ |
| |
| #if defined (__MACH__) |
| // Mac OS X Mach-O assembler: no .type, power of two alignment |
| # define ALIGN_DIR .align 4 |
| # define TYPE_DIR(ignore,ignore2) |
| #else |
| # define ALIGN_DIR .align 16 |
| # define TYPE_DIR(sym,attr) .type sym, attr |
| #endif // __MACH__ |
| |
| .text |
| ALIGN_DIR |
| |
| /*************************************************************************** |
| * extern "C" int8_t __rw_atomic_xchg8 (int8_t *x, int8_t y); |
| * |
| * Atomically assigns the 8-bit value y to *x and returns |
| * the original (before assignment) 8-bit value of *x. |
| **************************************************************************/ |
| |
| .globl __rw_atomic_xchg8 |
| TYPE_DIR (__rw_atomic_xchg8, @function) |
| __rw_atomic_xchg8: /* ; int8_t (int8_t *x, int8_t y) */ |
| movq %rdi, %rcx /* ; %rcx = x */ |
| movb %sil, %al /* ; %al = y */ |
| xchgb %al, (%rcx) /* ; %al <-> (%rcx) */ |
| ret |
| |
| |
| /*************************************************************************** |
| * extern "C" int16_t __rw_atomic_xchg16 (int16_t *x, int16_t y); |
| * |
| * Atomically assigns the 16-bit value y to *x and returns |
| * the original (before assignment) 16-bit value of *x. |
| **************************************************************************/ |
| |
| .globl __rw_atomic_xchg16 |
| TYPE_DIR (__rw_atomic_xchg16, @function) |
| __rw_atomic_xchg16: /* ; int16_t (int16_t *x, int16_t y) */ |
| movq %rdi, %rcx /* ; %rcx = x */ |
| movw %si, %ax /* ; %ax = y */ |
| xchgw %ax, (%rcx) /* ; %ax <-> (%rcx) */ |
| ret |
| |
| |
| /*************************************************************************** |
| * extern "C" int32_t __rw_atomic_xchg32 (int32_t *x, int32_t y); |
| * |
| * Atomically assigns the 32-bit value y to *x and returns |
| * the original (before assignment) 32-bit value of *x. |
| **************************************************************************/ |
| |
| .globl __rw_atomic_xchg32 |
| TYPE_DIR (__rw_atomic_xchg32, @function) |
| __rw_atomic_xchg32: /* ; int32_t (int32_t *x, int32_t y) */ |
| movq %rdi, %rcx /* ; %rcx = x */ |
| movl %esi, %eax /* ; %eax = y */ |
| xchgl %eax, (%rcx) /* ; %eax <-> (%rcx) */ |
| ret |
| |
| |
| /*************************************************************************** |
| * extern "C" int32_t __rw_atomic_xchg64 (int64_t *x, int64_t y); |
| * |
| * Atomically assigns the 64-bit value y to *x and returns |
| * the original (before assignment) 64-bit value of *x. |
| **************************************************************************/ |
| |
| .globl __rw_atomic_xchg64 |
| TYPE_DIR (__rw_atomic_xchg64, @function) |
| __rw_atomic_xchg64: /* ; int64_t (int64_t *x, int64_t y) */ |
| movq %rdi, %rcx /* ; %rcx = x */ |
| movq %rsi, %rax /* ; %rax = y */ |
| xchgq %rax, (%rcx) /* ; %rax <-> (%rcx) */ |
| ret |
| |
| |
| /*************************************************************************** |
| * extern "C" int8_t __rw_atomic_add8 (int8_t *x, int8_t y); |
| * |
| * Atomically increments the 8-bit value *x by y and returns |
| * the new (after increment) 8-bit value of *x. |
| **************************************************************************/ |
| |
| .globl __rw_atomic_add8 |
| TYPE_DIR (__rw_atomic_add8, @function) |
| __rw_atomic_add8: /* ; int8_t (int8_t *dst, int8_t inc) */ |
| movq %rdi, %rcx /* ; %rcx = dst */ |
| movl %esi, %eax /* ; %eax = inc */ |
| movl %eax, %edx /* ; */ |
| |
| lock /* ; lock the bus */ |
| xaddb %al, (%rcx) /* ; tmp = *dst */ |
| /* ; dst += inc */ |
| /* ; %al = tmp */ |
| addl %edx, %eax /* ; return %al + inc */ |
| ret |
| |
| |
| /*************************************************************************** |
| * extern "C" int16_t __rw_atomic_add16 (int16_t *x, int16_t y); |
| * |
| * Atomically increments the 16-bit value *x by y and returns |
| * the new (after increment) 16-bit value of *x. |
| **************************************************************************/ |
| |
| .globl __rw_atomic_add16 |
| TYPE_DIR (__rw_atomic_add16, @function) |
| __rw_atomic_add16: /* ; int16_t (int16_t *dst, int16_t inc) */ |
| movq %rdi, %rcx /* ; %rcx = dst */ |
| movw %si, %ax /* ; %ax = inc */ |
| movw %ax, %dx /* ; */ |
| |
| lock /* ; lock the bus */ |
| xaddw %ax, (%rcx) /* ; tmp = *dst */ |
| /* ; dst += inc */ |
| /* ; %ax = tmp */ |
| |
| addw %dx, %ax /* ; return %ax + inc */ |
| ret |
| |
| |
| /*************************************************************************** |
| * extern "C" int32_t __rw_atomic_add32 (int32_t *x, int32_t y); |
| * |
| * Atomically increments the 32-bit value *x by y and returns |
| * the new (after increment) 32-bit value of *x. |
| **************************************************************************/ |
| |
| .globl __rw_atomic_add32 |
| TYPE_DIR (__rw_atomic_add32, @function) |
| __rw_atomic_add32: /* ; int32_t (int32_t *dst, int32_t inc) */ |
| movq %rdi, %rcx /* ; %rcx = dst */ |
| movl %esi, %edx /* ; %edx = inc */ |
| movl %edx, %eax /* ; */ |
| |
| lock /* ; lock the bus */ |
| xaddl %eax, (%rcx) /* ; tmp = *dst */ |
| /* ; dst += inc */ |
| /* ; %eax = tmp */ |
| |
| addl %edx, %eax /* ; return %eax + inc */ |
| ret |
| |
| |
| /*************************************************************************** |
| * extern "C" int64_t __rw_atomic_add64 (int64_t *x, int64_t y); |
| * |
| * Atomically increments the 32-bit value *x by y and returns |
| * the new (after increment) 32-bit value of *x. |
| **************************************************************************/ |
| |
| .globl __rw_atomic_add64 |
| TYPE_DIR (__rw_atomic_add64, @function) |
| __rw_atomic_add64: /* ; int64_t (int64_t *dst, int64_t inc) */ |
| movq %rdi, %rcx /* ; %rcx = dst */ |
| movq %rsi, %rdx /* ; %edx = inc */ |
| movq %rdx, %rax /* ; */ |
| |
| lock /* ; lock the bus */ |
| xaddq %rax, (%rcx) /* ; tmp = *dst */ |
| /* ; dst += inc */ |
| /* ; %rax = tmp */ |
| |
| addq %rdx, %rax /* ; return %rax + inc */ |
| ret |
