From 57cce54a338d140fcd1b96f9365f007bc4d5ce00ddafc8ad934fe7e6c042ea59 Mon Sep 17 00:00:00 2001 From: "Dr. Werner Fink" Date: Sat, 18 May 2013 22:07:04 +0000 Subject: [PATCH 1/3] Accepting request 176069 from home:Andreas_Schwab:Factory - aarch64-support.patch: aarch64 support for gc from upstream - libatomic_ops-aarch64.patch: aarch64 support for libatomic_ops from upstream add-aarch64-support branch OBS-URL: https://build.opensuse.org/request/show/176069 OBS-URL: https://build.opensuse.org/package/show/devel:libraries:c_c++/gc?expand=0&rev=25 --- aarch64-support.patch | 69 ++ gc.changes | 7 + gc.spec | 4 + libatomic_ops-aarch64.patch | 1374 +++++++++++++++++++++++++++++++++++ 4 files changed, 1454 insertions(+) create mode 100644 aarch64-support.patch create mode 100644 libatomic_ops-aarch64.patch diff --git a/aarch64-support.patch b/aarch64-support.patch new file mode 100644 index 0000000..626f46e --- /dev/null +++ b/aarch64-support.patch @@ -0,0 +1,69 @@ +Index: gc-7.2/include/private/gcconfig.h +=================================================================== +--- gc-7.2.orig/include/private/gcconfig.h ++++ gc-7.2/include/private/gcconfig.h +@@ -70,6 +70,13 @@ + # define I386 + # define mach_type_known + # endif ++# if defined(__aarch64__) ++# define AARCH64 ++# if !defined(LINUX) ++# define NOSYS ++# define mach_type_known ++# endif ++# endif + # if defined(__arm) || defined(__arm__) || defined(__thumb__) + # define ARM32 + # if !defined(LINUX) && !defined(NETBSD) && !defined(OPENBSD) \ +@@ -250,6 +257,10 @@ + # define IA64 + # define mach_type_known + # endif ++# if defined(LINUX) && defined(__aarch64__) ++# define AARCH64 ++# define mach_type_known ++# endif + # if defined(LINUX) && (defined(__arm) || defined(__arm__)) + # define ARM32 + # define mach_type_known +@@ -537,6 +548,7 @@ + /* running Amdahl UTS4 */ + /* S390 ==> 390-like machine */ + /* running LINUX */ ++ /* AARCH64 ==> ARM AArch64 */ + /* ARM32 ==> Intel StrongARM */ + /* IA64 ==> Intel IPF */ + /* (e.g. Itanium) */ +@@ -1899,6 +1911,31 @@ + # endif + # endif + ++# ifdef AARCH64 ++# define CPP_WORDSZ 64 ++# define MACH_TYPE "AARCH64" ++# define ALIGNMENT 8 ++# ifndef HBLKSIZE ++# define HBLKSIZE 4096 ++# endif ++# ifdef LINUX ++# define OS_TYPE "LINUX" ++# define LINUX_STACKBOTTOM ++# define DYNAMIC_LOADING ++ extern int __data_start[]; ++# define DATASTART ((ptr_t)__data_start) ++ extern char _end[]; ++# define DATAEND ((ptr_t)(&_end)) ++# endif ++# ifdef NOSYS ++ /* __data_start is usually defined in the target linker script. */ ++ extern int __data_start[]; ++# define DATASTART ((ptr_t)__data_start) ++ extern void *__stack_base__; ++# define STACKBOTTOM ((ptr_t)__stack_base__) ++# endif ++# endif ++ + # ifdef ARM32 + # define CPP_WORDSZ 32 + # define MACH_TYPE "ARM32" diff --git a/gc.changes b/gc.changes index 5522490..a48a193 100644 --- a/gc.changes +++ b/gc.changes @@ -1,3 +1,10 @@ +------------------------------------------------------------------- +Sat May 18 08:10:09 UTC 2013 - schwab@suse.de + +- aarch64-support.patch: aarch64 support for gc from upstream +- libatomic_ops-aarch64.patch: aarch64 support for libatomic_ops from + upstream add-aarch64-support branch + ------------------------------------------------------------------- Mon Mar 25 14:50:51 UTC 2013 - dmueller@suse.com diff --git a/gc.spec b/gc.spec index 31f77d3..e5e4c3e 100644 --- a/gc.spec +++ b/gc.spec @@ -25,6 +25,8 @@ Summary: A garbage collector for C and C++ License: BSD-3-Clause Group: Development/Libraries/C and C++ Source: http://www.hpl.hp.com/personal/Hans_Boehm/gc/gc_source/%{name}-%{src_ver}.tar.gz +Patch1: aarch64-support.patch +Patch2: libatomic_ops-aarch64.patch BuildRoot: %{_tmppath}/%{name}-%{version}-build BuildRequires: autoconf >= 2.64 BuildRequires: gcc-c++ @@ -87,6 +89,8 @@ that involves minimum overhead across a variety of architectures. %prep %setup -q -n %{name}-7.2 +%patch1 -p1 +%patch2 %build # refresh auto*/libtool to purge rpaths diff --git a/libatomic_ops-aarch64.patch b/libatomic_ops-aarch64.patch new file mode 100644 index 0000000..a3db085 --- /dev/null +++ b/libatomic_ops-aarch64.patch @@ -0,0 +1,1374 @@ +Index: libatomic_ops/src/atomic_ops.h +=================================================================== +--- libatomic_ops/src/atomic_ops.h.orig ++++ libatomic_ops/src/atomic_ops.h +@@ -244,6 +244,10 @@ + || defined(__powerpc64__) || defined(__ppc64__) + # include "atomic_ops/sysdeps/gcc/powerpc.h" + # endif /* __powerpc__ */ ++# if defined(__aarch64__) ++# include "atomic_ops/sysdeps/gcc/aarch64.h" ++# define AO_CAN_EMUL_CAS ++# endif /* __aarch64__ */ + # if defined(__arm__) && !defined(AO_USE_PTHREAD_DEFS) + # include "atomic_ops/sysdeps/gcc/arm.h" + # define AO_CAN_EMUL_CAS +Index: libatomic_ops/src/atomic_ops/sysdeps/Makefile.am +=================================================================== +--- libatomic_ops/src/atomic_ops/sysdeps/Makefile.am.orig ++++ libatomic_ops/src/atomic_ops/sysdeps/Makefile.am +@@ -30,6 +30,7 @@ nobase_sysdep_HEADERS= generic_pthread.h + gcc/hexagon.h gcc/hppa.h gcc/ia64.h gcc/m68k.h \ + gcc/mips.h gcc/powerpc.h gcc/s390.h \ + gcc/sh.h gcc/sparc.h gcc/x86.h gcc/x86_64.h \ ++ gcc/aarch64.h gcc/generic.h + \ + hpc/hppa.h hpc/ia64.h \ + \ +Index: libatomic_ops/src/atomic_ops/sysdeps/gcc/aarch64.h +=================================================================== +--- /dev/null ++++ libatomic_ops/src/atomic_ops/sysdeps/gcc/aarch64.h +@@ -0,0 +1,176 @@ ++/* ++ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. ++ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. ++ * Copyright (c) 1999-2003 by Hewlett-Packard Company. All rights reserved. ++ * ++ * ++ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED ++ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. ++ * ++ * Permission is hereby granted to use or copy this program ++ * for any purpose, provided the above notices are retained on all copies. ++ * Permission to modify the code and to distribute modified code is granted, ++ * provided the above notices are retained, and a notice that the code was ++ * modified is included with the above copyright notice. ++ * ++ */ ++ ++#include "../test_and_set_t_is_ao_t.h" ++ ++#include "../standard_ao_double_t.h" ++ ++#ifndef AO_UNIPROCESSOR ++ AO_INLINE void ++ AO_nop_write(void) ++ { ++ __asm__ __volatile__("dmb st" : : : "memory"); ++ } ++# define AO_HAVE_nop_write ++#endif ++ ++/* TODO: Adjust version check on fixing double-wide AO support in GCC. */ ++#if __GNUC__ == 4 ++ ++ AO_INLINE AO_double_t ++ AO_double_load(const volatile AO_double_t *addr) ++ { ++ AO_double_t result; ++ int status; ++ ++ /* Note that STXP cannot be discarded because LD[A]XP is not */ ++ /* single-copy atomic (unlike LDREXD for 32-bit ARM). */ ++ do { ++ __asm__ __volatile__("//AO_double_load\n" ++ " ldxp %0, %1, %3\n" ++ " stxp %w2, %0, %1, %3" ++ : "=&r" (result.AO_val1), "=&r" (result.AO_val2), "=&r" (status) ++ : "Q" (*addr)); ++ } while (AO_EXPECT_FALSE(status)); ++ return result; ++ } ++# define AO_HAVE_double_load ++ ++ AO_INLINE AO_double_t ++ AO_double_load_acquire(const volatile AO_double_t *addr) ++ { ++ AO_double_t result; ++ int status; ++ ++ do { ++ __asm__ __volatile__("//AO_double_load_acquire\n" ++ " ldaxp %0, %1, %3\n" ++ " stxp %w2, %0, %1, %3" ++ : "=&r" (result.AO_val1), "=&r" (result.AO_val2), "=&r" (status) ++ : "Q" (*addr)); ++ } while (AO_EXPECT_FALSE(status)); ++ return result; ++ } ++# define AO_HAVE_double_load_acquire ++ ++ AO_INLINE void ++ AO_double_store(volatile AO_double_t *addr, AO_double_t value) ++ { ++ AO_double_t old_val; ++ int status; ++ ++ do { ++ __asm__ __volatile__("//AO_double_store\n" ++ " ldxp %0, %1, %3\n" ++ " stxp %w2, %4, %5, %3" ++ : "=&r" (old_val.AO_val1), "=&r" (old_val.AO_val2), "=&r" (status), ++ "=Q" (*addr) ++ : "r" (value.AO_val1), "r" (value.AO_val2)); ++ /* Compared to the arm.h implementation, the 'cc' (flags) are not */ ++ /* clobbered because A64 has no concept of conditional execution. */ ++ } while (AO_EXPECT_FALSE(status)); ++ } ++# define AO_HAVE_double_store ++ ++ AO_INLINE void ++ AO_double_store_release(volatile AO_double_t *addr, AO_double_t value) ++ { ++ AO_double_t old_val; ++ int status; ++ ++ do { ++ __asm__ __volatile__("//AO_double_store_release\n" ++ " ldxp %0, %1, %3\n" ++ " stlxp %w2, %4, %5, %3" ++ : "=&r" (old_val.AO_val1), "=&r" (old_val.AO_val2), "=&r" (status), ++ "=Q" (*addr) ++ : "r" (value.AO_val1), "r" (value.AO_val2)); ++ } while (AO_EXPECT_FALSE(status)); ++ } ++# define AO_HAVE_double_store_release ++ ++ AO_INLINE int ++ AO_double_compare_and_swap(volatile AO_double_t *addr, ++ AO_double_t old_val, AO_double_t new_val) ++ { ++ AO_double_t tmp; ++ int result = 1; ++ ++ do { ++ __asm__ __volatile__("//AO_double_compare_and_swap\n" ++ " ldxp %0, %1, %2\n" ++ : "=&r" (tmp.AO_val1), "=&r" (tmp.AO_val2) ++ : "Q" (*addr)); ++ if (tmp.AO_val1 != old_val.AO_val1 || tmp.AO_val2 != old_val.AO_val2) ++ break; ++ __asm__ __volatile__( ++ " stxp %w0, %2, %3, %1\n" ++ : "=&r" (result), "=Q" (*addr) ++ : "r" (new_val.AO_val1), "r" (new_val.AO_val2)); ++ } while (AO_EXPECT_FALSE(result)); ++ return !result; ++ } ++# define AO_HAVE_double_compare_and_swap ++ ++ AO_INLINE int ++ AO_double_compare_and_swap_acquire(volatile AO_double_t *addr, ++ AO_double_t old_val, AO_double_t new_val) ++ { ++ AO_double_t tmp; ++ int result = 1; ++ ++ do { ++ __asm__ __volatile__("//AO_double_compare_and_swap_acquire\n" ++ " ldaxp %0, %1, %2\n" ++ : "=&r" (tmp.AO_val1), "=&r" (tmp.AO_val2) ++ : "Q" (*addr)); ++ if (tmp.AO_val1 != old_val.AO_val1 || tmp.AO_val2 != old_val.AO_val2) ++ break; ++ __asm__ __volatile__( ++ " stxp %w0, %2, %3, %1\n" ++ : "=&r" (result), "=Q" (*addr) ++ : "r" (new_val.AO_val1), "r" (new_val.AO_val2)); ++ } while (AO_EXPECT_FALSE(result)); ++ return !result; ++ } ++# define AO_HAVE_double_compare_and_swap_acquire ++ ++ AO_INLINE int ++ AO_double_compare_and_swap_release(volatile AO_double_t *addr, ++ AO_double_t old_val, AO_double_t new_val) ++ { ++ AO_double_t tmp; ++ int result = 1; ++ ++ do { ++ __asm__ __volatile__("//AO_double_compare_and_swap_release\n" ++ " ldxp %0, %1, %2\n" ++ : "=&r" (tmp.AO_val1), "=&r" (tmp.AO_val2) ++ : "Q" (*addr)); ++ if (tmp.AO_val1 != old_val.AO_val1 || tmp.AO_val2 != old_val.AO_val2) ++ break; ++ __asm__ __volatile__( ++ " stlxp %w0, %2, %3, %1\n" ++ : "=&r" (result), "=Q" (*addr) ++ : "r" (new_val.AO_val1), "r" (new_val.AO_val2)); ++ } while (AO_EXPECT_FALSE(result)); ++ return !result; ++ } ++# define AO_HAVE_double_compare_and_swap_release ++#endif ++ ++#include "generic.h" +Index: libatomic_ops/src/atomic_ops/sysdeps/gcc/generic-arithm.h +=================================================================== +--- /dev/null ++++ libatomic_ops/src/atomic_ops/sysdeps/gcc/generic-arithm.h +@@ -0,0 +1,704 @@ ++/* ++ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. ++ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. ++ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. ++ * ++ * ++ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED ++ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. ++ * ++ * Permission is hereby granted to use or copy this program ++ * for any purpose, provided the above notices are retained on all copies. ++ * Permission to modify the code and to distribute modified code is granted, ++ * provided the above notices are retained, and a notice that the code was ++ * modified is included with the above copyright notice. ++ * ++ */ ++ ++AO_INLINE unsigned/**/char ++AO_char_fetch_and_add(volatile unsigned/**/char *addr, unsigned/**/char incr) ++{ ++ return __atomic_fetch_add(addr, incr, __ATOMIC_RELAXED); ++} ++#define AO_HAVE_char_fetch_and_add ++ ++AO_INLINE void ++AO_char_and(volatile unsigned/**/char *addr, unsigned/**/char value) ++{ ++ (void)__atomic_and_fetch(addr, value, __ATOMIC_RELAXED); ++} ++#define AO_HAVE_char_and ++ ++AO_INLINE void ++AO_char_or(volatile unsigned/**/char *addr, unsigned/**/char value) ++{ ++ (void)__atomic_or_fetch(addr, value, __ATOMIC_RELAXED); ++} ++#define AO_HAVE_char_or ++ ++AO_INLINE void ++AO_char_xor(volatile unsigned/**/char *addr, unsigned/**/char value) ++{ ++ (void)__atomic_xor_fetch(addr, value, __ATOMIC_RELAXED); ++} ++#define AO_HAVE_char_xor ++/* ++ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. ++ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. ++ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. ++ * ++ * ++ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED ++ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. ++ * ++ * Permission is hereby granted to use or copy this program ++ * for any purpose, provided the above notices are retained on all copies. ++ * Permission to modify the code and to distribute modified code is granted, ++ * provided the above notices are retained, and a notice that the code was ++ * modified is included with the above copyright notice. ++ * ++ */ ++ ++AO_INLINE unsigned/**/short ++AO_short_fetch_and_add(volatile unsigned/**/short *addr, unsigned/**/short incr) ++{ ++ return __atomic_fetch_add(addr, incr, __ATOMIC_RELAXED); ++} ++#define AO_HAVE_short_fetch_and_add ++ ++AO_INLINE void ++AO_short_and(volatile unsigned/**/short *addr, unsigned/**/short value) ++{ ++ (void)__atomic_and_fetch(addr, value, __ATOMIC_RELAXED); ++} ++#define AO_HAVE_short_and ++ ++AO_INLINE void ++AO_short_or(volatile unsigned/**/short *addr, unsigned/**/short value) ++{ ++ (void)__atomic_or_fetch(addr, value, __ATOMIC_RELAXED); ++} ++#define AO_HAVE_short_or ++ ++AO_INLINE void ++AO_short_xor(volatile unsigned/**/short *addr, unsigned/**/short value) ++{ ++ (void)__atomic_xor_fetch(addr, value, __ATOMIC_RELAXED); ++} ++#define AO_HAVE_short_xor ++/* ++ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. ++ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. ++ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. ++ * ++ * ++ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED ++ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. ++ * ++ * Permission is hereby granted to use or copy this program ++ * for any purpose, provided the above notices are retained on all copies. ++ * Permission to modify the code and to distribute modified code is granted, ++ * provided the above notices are retained, and a notice that the code was ++ * modified is included with the above copyright notice. ++ * ++ */ ++ ++AO_INLINE unsigned ++AO_int_fetch_and_add(volatile unsigned *addr, unsigned incr) ++{ ++ return __atomic_fetch_add(addr, incr, __ATOMIC_RELAXED); ++} ++#define AO_HAVE_int_fetch_and_add ++ ++AO_INLINE void ++AO_int_and(volatile unsigned *addr, unsigned value) ++{ ++ (void)__atomic_and_fetch(addr, value, __ATOMIC_RELAXED); ++} ++#define AO_HAVE_int_and ++ ++AO_INLINE void ++AO_int_or(volatile unsigned *addr, unsigned value) ++{ ++ (void)__atomic_or_fetch(addr, value, __ATOMIC_RELAXED); ++} ++#define AO_HAVE_int_or ++ ++AO_INLINE void ++AO_int_xor(volatile unsigned *addr, unsigned value) ++{ ++ (void)__atomic_xor_fetch(addr, value, __ATOMIC_RELAXED); ++} ++#define AO_HAVE_int_xor ++/* ++ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. ++ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. ++ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. ++ * ++ * ++ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED ++ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. ++ * ++ * Permission is hereby granted to use or copy this program ++ * for any purpose, provided the above notices are retained on all copies. ++ * Permission to modify the code and to distribute modified code is granted, ++ * provided the above notices are retained, and a notice that the code was ++ * modified is included with the above copyright notice. ++ * ++ */ ++ ++AO_INLINE AO_t ++AO_fetch_and_add(volatile AO_t *addr, AO_t incr) ++{ ++ return __atomic_fetch_add(addr, incr, __ATOMIC_RELAXED); ++} ++#define AO_HAVE_fetch_and_add ++ ++AO_INLINE void ++AO_and(volatile AO_t *addr, AO_t value) ++{ ++ (void)__atomic_and_fetch(addr, value, __ATOMIC_RELAXED); ++} ++#define AO_HAVE_and ++ ++AO_INLINE void ++AO_or(volatile AO_t *addr, AO_t value) ++{ ++ (void)__atomic_or_fetch(addr, value, __ATOMIC_RELAXED); ++} ++#define AO_HAVE_or ++ ++AO_INLINE void ++AO_xor(volatile AO_t *addr, AO_t value) ++{ ++ (void)__atomic_xor_fetch(addr, value, __ATOMIC_RELAXED); ++} ++#define AO_HAVE_xor ++/* ++ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. ++ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. ++ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. ++ * ++ * ++ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED ++ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. ++ * ++ * Permission is hereby granted to use or copy this program ++ * for any purpose, provided the above notices are retained on all copies. ++ * Permission to modify the code and to distribute modified code is granted, ++ * provided the above notices are retained, and a notice that the code was ++ * modified is included with the above copyright notice. ++ * ++ */ ++ ++AO_INLINE unsigned/**/char ++AO_char_fetch_and_add_acquire(volatile unsigned/**/char *addr, unsigned/**/char incr) ++{ ++ return __atomic_fetch_add(addr, incr, __ATOMIC_ACQUIRE); ++} ++#define AO_HAVE_char_fetch_and_add_acquire ++ ++AO_INLINE void ++AO_char_and_acquire(volatile unsigned/**/char *addr, unsigned/**/char value) ++{ ++ (void)__atomic_and_fetch(addr, value, __ATOMIC_ACQUIRE); ++} ++#define AO_HAVE_char_and_acquire ++ ++AO_INLINE void ++AO_char_or_acquire(volatile unsigned/**/char *addr, unsigned/**/char value) ++{ ++ (void)__atomic_or_fetch(addr, value, __ATOMIC_ACQUIRE); ++} ++#define AO_HAVE_char_or_acquire ++ ++AO_INLINE void ++AO_char_xor_acquire(volatile unsigned/**/char *addr, unsigned/**/char value) ++{ ++ (void)__atomic_xor_fetch(addr, value, __ATOMIC_ACQUIRE); ++} ++#define AO_HAVE_char_xor_acquire ++/* ++ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. ++ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. ++ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. ++ * ++ * ++ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED ++ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. ++ * ++ * Permission is hereby granted to use or copy this program ++ * for any purpose, provided the above notices are retained on all copies. ++ * Permission to modify the code and to distribute modified code is granted, ++ * provided the above notices are retained, and a notice that the code was ++ * modified is included with the above copyright notice. ++ * ++ */ ++ ++AO_INLINE unsigned/**/short ++AO_short_fetch_and_add_acquire(volatile unsigned/**/short *addr, unsigned/**/short incr) ++{ ++ return __atomic_fetch_add(addr, incr, __ATOMIC_ACQUIRE); ++} ++#define AO_HAVE_short_fetch_and_add_acquire ++ ++AO_INLINE void ++AO_short_and_acquire(volatile unsigned/**/short *addr, unsigned/**/short value) ++{ ++ (void)__atomic_and_fetch(addr, value, __ATOMIC_ACQUIRE); ++} ++#define AO_HAVE_short_and_acquire ++ ++AO_INLINE void ++AO_short_or_acquire(volatile unsigned/**/short *addr, unsigned/**/short value) ++{ ++ (void)__atomic_or_fetch(addr, value, __ATOMIC_ACQUIRE); ++} ++#define AO_HAVE_short_or_acquire ++ ++AO_INLINE void ++AO_short_xor_acquire(volatile unsigned/**/short *addr, unsigned/**/short value) ++{ ++ (void)__atomic_xor_fetch(addr, value, __ATOMIC_ACQUIRE); ++} ++#define AO_HAVE_short_xor_acquire ++/* ++ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. ++ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. ++ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. ++ * ++ * ++ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED ++ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. ++ * ++ * Permission is hereby granted to use or copy this program ++ * for any purpose, provided the above notices are retained on all copies. ++ * Permission to modify the code and to distribute modified code is granted, ++ * provided the above notices are retained, and a notice that the code was ++ * modified is included with the above copyright notice. ++ * ++ */ ++ ++AO_INLINE unsigned ++AO_int_fetch_and_add_acquire(volatile unsigned *addr, unsigned incr) ++{ ++ return __atomic_fetch_add(addr, incr, __ATOMIC_ACQUIRE); ++} ++#define AO_HAVE_int_fetch_and_add_acquire ++ ++AO_INLINE void ++AO_int_and_acquire(volatile unsigned *addr, unsigned value) ++{ ++ (void)__atomic_and_fetch(addr, value, __ATOMIC_ACQUIRE); ++} ++#define AO_HAVE_int_and_acquire ++ ++AO_INLINE void ++AO_int_or_acquire(volatile unsigned *addr, unsigned value) ++{ ++ (void)__atomic_or_fetch(addr, value, __ATOMIC_ACQUIRE); ++} ++#define AO_HAVE_int_or_acquire ++ ++AO_INLINE void ++AO_int_xor_acquire(volatile unsigned *addr, unsigned value) ++{ ++ (void)__atomic_xor_fetch(addr, value, __ATOMIC_ACQUIRE); ++} ++#define AO_HAVE_int_xor_acquire ++/* ++ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. ++ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. ++ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. ++ * ++ * ++ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED ++ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. ++ * ++ * Permission is hereby granted to use or copy this program ++ * for any purpose, provided the above notices are retained on all copies. ++ * Permission to modify the code and to distribute modified code is granted, ++ * provided the above notices are retained, and a notice that the code was ++ * modified is included with the above copyright notice. ++ * ++ */ ++ ++AO_INLINE AO_t ++AO_fetch_and_add_acquire(volatile AO_t *addr, AO_t incr) ++{ ++ return __atomic_fetch_add(addr, incr, __ATOMIC_ACQUIRE); ++} ++#define AO_HAVE_fetch_and_add_acquire ++ ++AO_INLINE void ++AO_and_acquire(volatile AO_t *addr, AO_t value) ++{ ++ (void)__atomic_and_fetch(addr, value, __ATOMIC_ACQUIRE); ++} ++#define AO_HAVE_and_acquire ++ ++AO_INLINE void ++AO_or_acquire(volatile AO_t *addr, AO_t value) ++{ ++ (void)__atomic_or_fetch(addr, value, __ATOMIC_ACQUIRE); ++} ++#define AO_HAVE_or_acquire ++ ++AO_INLINE void ++AO_xor_acquire(volatile AO_t *addr, AO_t value) ++{ ++ (void)__atomic_xor_fetch(addr, value, __ATOMIC_ACQUIRE); ++} ++#define AO_HAVE_xor_acquire ++/* ++ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. ++ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. ++ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. ++ * ++ * ++ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED ++ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. ++ * ++ * Permission is hereby granted to use or copy this program ++ * for any purpose, provided the above notices are retained on all copies. ++ * Permission to modify the code and to distribute modified code is granted, ++ * provided the above notices are retained, and a notice that the code was ++ * modified is included with the above copyright notice. ++ * ++ */ ++ ++AO_INLINE unsigned/**/char ++AO_char_fetch_and_add_release(volatile unsigned/**/char *addr, unsigned/**/char incr) ++{ ++ return __atomic_fetch_add(addr, incr, __ATOMIC_RELEASE); ++} ++#define AO_HAVE_char_fetch_and_add_release ++ ++AO_INLINE void ++AO_char_and_release(volatile unsigned/**/char *addr, unsigned/**/char value) ++{ ++ (void)__atomic_and_fetch(addr, value, __ATOMIC_RELEASE); ++} ++#define AO_HAVE_char_and_release ++ ++AO_INLINE void ++AO_char_or_release(volatile unsigned/**/char *addr, unsigned/**/char value) ++{ ++ (void)__atomic_or_fetch(addr, value, __ATOMIC_RELEASE); ++} ++#define AO_HAVE_char_or_release ++ ++AO_INLINE void ++AO_char_xor_release(volatile unsigned/**/char *addr, unsigned/**/char value) ++{ ++ (void)__atomic_xor_fetch(addr, value, __ATOMIC_RELEASE); ++} ++#define AO_HAVE_char_xor_release ++/* ++ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. ++ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. ++ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. ++ * ++ * ++ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED ++ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. ++ * ++ * Permission is hereby granted to use or copy this program ++ * for any purpose, provided the above notices are retained on all copies. ++ * Permission to modify the code and to distribute modified code is granted, ++ * provided the above notices are retained, and a notice that the code was ++ * modified is included with the above copyright notice. ++ * ++ */ ++ ++AO_INLINE unsigned/**/short ++AO_short_fetch_and_add_release(volatile unsigned/**/short *addr, unsigned/**/short incr) ++{ ++ return __atomic_fetch_add(addr, incr, __ATOMIC_RELEASE); ++} ++#define AO_HAVE_short_fetch_and_add_release ++ ++AO_INLINE void ++AO_short_and_release(volatile unsigned/**/short *addr, unsigned/**/short value) ++{ ++ (void)__atomic_and_fetch(addr, value, __ATOMIC_RELEASE); ++} ++#define AO_HAVE_short_and_release ++ ++AO_INLINE void ++AO_short_or_release(volatile unsigned/**/short *addr, unsigned/**/short value) ++{ ++ (void)__atomic_or_fetch(addr, value, __ATOMIC_RELEASE); ++} ++#define AO_HAVE_short_or_release ++ ++AO_INLINE void ++AO_short_xor_release(volatile unsigned/**/short *addr, unsigned/**/short value) ++{ ++ (void)__atomic_xor_fetch(addr, value, __ATOMIC_RELEASE); ++} ++#define AO_HAVE_short_xor_release ++/* ++ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. ++ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. ++ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. ++ * ++ * ++ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED ++ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. ++ * ++ * Permission is hereby granted to use or copy this program ++ * for any purpose, provided the above notices are retained on all copies. ++ * Permission to modify the code and to distribute modified code is granted, ++ * provided the above notices are retained, and a notice that the code was ++ * modified is included with the above copyright notice. ++ * ++ */ ++ ++AO_INLINE unsigned ++AO_int_fetch_and_add_release(volatile unsigned *addr, unsigned incr) ++{ ++ return __atomic_fetch_add(addr, incr, __ATOMIC_RELEASE); ++} ++#define AO_HAVE_int_fetch_and_add_release ++ ++AO_INLINE void ++AO_int_and_release(volatile unsigned *addr, unsigned value) ++{ ++ (void)__atomic_and_fetch(addr, value, __ATOMIC_RELEASE); ++} ++#define AO_HAVE_int_and_release ++ ++AO_INLINE void ++AO_int_or_release(volatile unsigned *addr, unsigned value) ++{ ++ (void)__atomic_or_fetch(addr, value, __ATOMIC_RELEASE); ++} ++#define AO_HAVE_int_or_release ++ ++AO_INLINE void ++AO_int_xor_release(volatile unsigned *addr, unsigned value) ++{ ++ (void)__atomic_xor_fetch(addr, value, __ATOMIC_RELEASE); ++} ++#define AO_HAVE_int_xor_release ++/* ++ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. ++ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. ++ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. ++ * ++ * ++ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED ++ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. ++ * ++ * Permission is hereby granted to use or copy this program ++ * for any purpose, provided the above notices are retained on all copies. ++ * Permission to modify the code and to distribute modified code is granted, ++ * provided the above notices are retained, and a notice that the code was ++ * modified is included with the above copyright notice. ++ * ++ */ ++ ++AO_INLINE AO_t ++AO_fetch_and_add_release(volatile AO_t *addr, AO_t incr) ++{ ++ return __atomic_fetch_add(addr, incr, __ATOMIC_RELEASE); ++} ++#define AO_HAVE_fetch_and_add_release ++ ++AO_INLINE void ++AO_and_release(volatile AO_t *addr, AO_t value) ++{ ++ (void)__atomic_and_fetch(addr, value, __ATOMIC_RELEASE); ++} ++#define AO_HAVE_and_release ++ ++AO_INLINE void ++AO_or_release(volatile AO_t *addr, AO_t value) ++{ ++ (void)__atomic_or_fetch(addr, value, __ATOMIC_RELEASE); ++} ++#define AO_HAVE_or_release ++ ++AO_INLINE void ++AO_xor_release(volatile AO_t *addr, AO_t value) ++{ ++ (void)__atomic_xor_fetch(addr, value, __ATOMIC_RELEASE); ++} ++#define AO_HAVE_xor_release ++/* ++ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. ++ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. ++ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. ++ * ++ * ++ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED ++ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. ++ * ++ * Permission is hereby granted to use or copy this program ++ * for any purpose, provided the above notices are retained on all copies. ++ * Permission to modify the code and to distribute modified code is granted, ++ * provided the above notices are retained, and a notice that the code was ++ * modified is included with the above copyright notice. ++ * ++ */ ++ ++AO_INLINE unsigned/**/char ++AO_char_fetch_and_add_full(volatile unsigned/**/char *addr, unsigned/**/char incr) ++{ ++ return __atomic_fetch_add(addr, incr, __ATOMIC_SEQ_CST); ++} ++#define AO_HAVE_char_fetch_and_add_full ++ ++AO_INLINE void ++AO_char_and_full(volatile unsigned/**/char *addr, unsigned/**/char value) ++{ ++ (void)__atomic_and_fetch(addr, value, __ATOMIC_SEQ_CST); ++} ++#define AO_HAVE_char_and_full ++ ++AO_INLINE void ++AO_char_or_full(volatile unsigned/**/char *addr, unsigned/**/char value) ++{ ++ (void)__atomic_or_fetch(addr, value, __ATOMIC_SEQ_CST); ++} ++#define AO_HAVE_char_or_full ++ ++AO_INLINE void ++AO_char_xor_full(volatile unsigned/**/char *addr, unsigned/**/char value) ++{ ++ (void)__atomic_xor_fetch(addr, value, __ATOMIC_SEQ_CST); ++} ++#define AO_HAVE_char_xor_full ++/* ++ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. ++ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. ++ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. ++ * ++ * ++ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED ++ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. ++ * ++ * Permission is hereby granted to use or copy this program ++ * for any purpose, provided the above notices are retained on all copies. ++ * Permission to modify the code and to distribute modified code is granted, ++ * provided the above notices are retained, and a notice that the code was ++ * modified is included with the above copyright notice. ++ * ++ */ ++ ++AO_INLINE unsigned/**/short ++AO_short_fetch_and_add_full(volatile unsigned/**/short *addr, unsigned/**/short incr) ++{ ++ return __atomic_fetch_add(addr, incr, __ATOMIC_SEQ_CST); ++} ++#define AO_HAVE_short_fetch_and_add_full ++ ++AO_INLINE void ++AO_short_and_full(volatile unsigned/**/short *addr, unsigned/**/short value) ++{ ++ (void)__atomic_and_fetch(addr, value, __ATOMIC_SEQ_CST); ++} ++#define AO_HAVE_short_and_full ++ ++AO_INLINE void ++AO_short_or_full(volatile unsigned/**/short *addr, unsigned/**/short value) ++{ ++ (void)__atomic_or_fetch(addr, value, __ATOMIC_SEQ_CST); ++} ++#define AO_HAVE_short_or_full ++ ++AO_INLINE void ++AO_short_xor_full(volatile unsigned/**/short *addr, unsigned/**/short value) ++{ ++ (void)__atomic_xor_fetch(addr, value, __ATOMIC_SEQ_CST); ++} ++#define AO_HAVE_short_xor_full ++/* ++ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. ++ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. ++ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. ++ * ++ * ++ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED ++ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. ++ * ++ * Permission is hereby granted to use or copy this program ++ * for any purpose, provided the above notices are retained on all copies. ++ * Permission to modify the code and to distribute modified code is granted, ++ * provided the above notices are retained, and a notice that the code was ++ * modified is included with the above copyright notice. ++ * ++ */ ++ ++AO_INLINE unsigned ++AO_int_fetch_and_add_full(volatile unsigned *addr, unsigned incr) ++{ ++ return __atomic_fetch_add(addr, incr, __ATOMIC_SEQ_CST); ++} ++#define AO_HAVE_int_fetch_and_add_full ++ ++AO_INLINE void ++AO_int_and_full(volatile unsigned *addr, unsigned value) ++{ ++ (void)__atomic_and_fetch(addr, value, __ATOMIC_SEQ_CST); ++} ++#define AO_HAVE_int_and_full ++ ++AO_INLINE void ++AO_int_or_full(volatile unsigned *addr, unsigned value) ++{ ++ (void)__atomic_or_fetch(addr, value, __ATOMIC_SEQ_CST); ++} ++#define AO_HAVE_int_or_full ++ ++AO_INLINE void ++AO_int_xor_full(volatile unsigned *addr, unsigned value) ++{ ++ (void)__atomic_xor_fetch(addr, value, __ATOMIC_SEQ_CST); ++} ++#define AO_HAVE_int_xor_full ++/* ++ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. ++ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. ++ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. ++ * ++ * ++ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED ++ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. ++ * ++ * Permission is hereby granted to use or copy this program ++ * for any purpose, provided the above notices are retained on all copies. ++ * Permission to modify the code and to distribute modified code is granted, ++ * provided the above notices are retained, and a notice that the code was ++ * modified is included with the above copyright notice. ++ * ++ */ ++ ++AO_INLINE AO_t ++AO_fetch_and_add_full(volatile AO_t *addr, AO_t incr) ++{ ++ return __atomic_fetch_add(addr, incr, __ATOMIC_SEQ_CST); ++} ++#define AO_HAVE_fetch_and_add_full ++ ++AO_INLINE void ++AO_and_full(volatile AO_t *addr, AO_t value) ++{ ++ (void)__atomic_and_fetch(addr, value, __ATOMIC_SEQ_CST); ++} ++#define AO_HAVE_and_full ++ ++AO_INLINE void ++AO_or_full(volatile AO_t *addr, AO_t value) ++{ ++ (void)__atomic_or_fetch(addr, value, __ATOMIC_SEQ_CST); ++} ++#define AO_HAVE_or_full ++ ++AO_INLINE void ++AO_xor_full(volatile AO_t *addr, AO_t value) ++{ ++ (void)__atomic_xor_fetch(addr, value, __ATOMIC_SEQ_CST); ++} ++#define AO_HAVE_xor_full +Index: libatomic_ops/src/atomic_ops/sysdeps/gcc/generic-small.h +=================================================================== +--- /dev/null ++++ libatomic_ops/src/atomic_ops/sysdeps/gcc/generic-small.h +@@ -0,0 +1,280 @@ ++/* ++ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. ++ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. ++ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. ++ * ++ * ++ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED ++ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. ++ * ++ * Permission is hereby granted to use or copy this program ++ * for any purpose, provided the above notices are retained on all copies. ++ * Permission to modify the code and to distribute modified code is granted, ++ * provided the above notices are retained, and a notice that the code was ++ * modified is included with the above copyright notice. ++ * ++ */ ++ ++AO_INLINE unsigned/**/char ++AO_char_load(const volatile unsigned/**/char *addr) ++{ ++ return __atomic_load_n(addr, __ATOMIC_RELAXED); ++} ++#define AO_HAVE_char_load ++ ++AO_INLINE unsigned/**/char ++AO_char_load_acquire(const volatile unsigned/**/char *addr) ++{ ++ return __atomic_load_n(addr, __ATOMIC_ACQUIRE); ++} ++#define AO_HAVE_char_load_acquire ++ ++/* char_load_full is generalized using load and nop_full, so that */ ++/* char_load_read is defined using load and nop_read. */ ++/* char_store_full definition is omitted similar to load_full reason. */ ++ ++AO_INLINE void ++AO_char_store(volatile unsigned/**/char *addr, unsigned/**/char value) ++{ ++ __atomic_store_n(addr, value, __ATOMIC_RELAXED); ++} ++#define AO_HAVE_char_store ++ ++AO_INLINE void ++AO_char_store_release(volatile unsigned/**/char *addr, unsigned/**/char value) ++{ ++ __atomic_store_n(addr, value, __ATOMIC_RELEASE); ++} ++#define AO_HAVE_char_store_release ++ ++AO_INLINE unsigned/**/char ++AO_char_fetch_compare_and_swap(volatile unsigned/**/char *addr, ++ unsigned/**/char old_val, unsigned/**/char new_val) ++{ ++ return __sync_val_compare_and_swap(addr, old_val, new_val ++ /* empty protection list */); ++} ++#define AO_HAVE_char_fetch_compare_and_swap ++ ++/* TODO: Add CAS _acquire/release/full primitives. */ ++ ++#ifndef AO_GENERALIZE_ASM_BOOL_CAS ++ AO_INLINE int ++ AO_char_compare_and_swap(volatile unsigned/**/char *addr, ++ unsigned/**/char old_val, unsigned/**/char new_val) ++ { ++ return __sync_bool_compare_and_swap(addr, old_val, new_val ++ /* empty protection list */); ++ } ++# define AO_HAVE_char_compare_and_swap ++#endif /* !AO_GENERALIZE_ASM_BOOL_CAS */ ++/* ++ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. ++ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. ++ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. ++ * ++ * ++ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED ++ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. ++ * ++ * Permission is hereby granted to use or copy this program ++ * for any purpose, provided the above notices are retained on all copies. ++ * Permission to modify the code and to distribute modified code is granted, ++ * provided the above notices are retained, and a notice that the code was ++ * modified is included with the above copyright notice. ++ * ++ */ ++ ++AO_INLINE unsigned/**/short ++AO_short_load(const volatile unsigned/**/short *addr) ++{ ++ return __atomic_load_n(addr, __ATOMIC_RELAXED); ++} ++#define AO_HAVE_short_load ++ ++AO_INLINE unsigned/**/short ++AO_short_load_acquire(const volatile unsigned/**/short *addr) ++{ ++ return __atomic_load_n(addr, __ATOMIC_ACQUIRE); ++} ++#define AO_HAVE_short_load_acquire ++ ++/* short_load_full is generalized using load and nop_full, so that */ ++/* short_load_read is defined using load and nop_read. */ ++/* short_store_full definition is omitted similar to load_full reason. */ ++ ++AO_INLINE void ++AO_short_store(volatile unsigned/**/short *addr, unsigned/**/short value) ++{ ++ __atomic_store_n(addr, value, __ATOMIC_RELAXED); ++} ++#define AO_HAVE_short_store ++ ++AO_INLINE void ++AO_short_store_release(volatile unsigned/**/short *addr, unsigned/**/short value) ++{ ++ __atomic_store_n(addr, value, __ATOMIC_RELEASE); ++} ++#define AO_HAVE_short_store_release ++ ++AO_INLINE unsigned/**/short ++AO_short_fetch_compare_and_swap(volatile unsigned/**/short *addr, ++ unsigned/**/short old_val, unsigned/**/short new_val) ++{ ++ return __sync_val_compare_and_swap(addr, old_val, new_val ++ /* empty protection list */); ++} ++#define AO_HAVE_short_fetch_compare_and_swap ++ ++/* TODO: Add CAS _acquire/release/full primitives. */ ++ ++#ifndef AO_GENERALIZE_ASM_BOOL_CAS ++ AO_INLINE int ++ AO_short_compare_and_swap(volatile unsigned/**/short *addr, ++ unsigned/**/short old_val, unsigned/**/short new_val) ++ { ++ return __sync_bool_compare_and_swap(addr, old_val, new_val ++ /* empty protection list */); ++ } ++# define AO_HAVE_short_compare_and_swap ++#endif /* !AO_GENERALIZE_ASM_BOOL_CAS */ ++/* ++ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. ++ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. ++ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. ++ * ++ * ++ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED ++ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. ++ * ++ * Permission is hereby granted to use or copy this program ++ * for any purpose, provided the above notices are retained on all copies. ++ * Permission to modify the code and to distribute modified code is granted, ++ * provided the above notices are retained, and a notice that the code was ++ * modified is included with the above copyright notice. ++ * ++ */ ++ ++AO_INLINE unsigned ++AO_int_load(const volatile unsigned *addr) ++{ ++ return __atomic_load_n(addr, __ATOMIC_RELAXED); ++} ++#define AO_HAVE_int_load ++ ++AO_INLINE unsigned ++AO_int_load_acquire(const volatile unsigned *addr) ++{ ++ return __atomic_load_n(addr, __ATOMIC_ACQUIRE); ++} ++#define AO_HAVE_int_load_acquire ++ ++/* int_load_full is generalized using load and nop_full, so that */ ++/* int_load_read is defined using load and nop_read. */ ++/* int_store_full definition is omitted similar to load_full reason. */ ++ ++AO_INLINE void ++AO_int_store(volatile unsigned *addr, unsigned value) ++{ ++ __atomic_store_n(addr, value, __ATOMIC_RELAXED); ++} ++#define AO_HAVE_int_store ++ ++AO_INLINE void ++AO_int_store_release(volatile unsigned *addr, unsigned value) ++{ ++ __atomic_store_n(addr, value, __ATOMIC_RELEASE); ++} ++#define AO_HAVE_int_store_release ++ ++AO_INLINE unsigned ++AO_int_fetch_compare_and_swap(volatile unsigned *addr, ++ unsigned old_val, unsigned new_val) ++{ ++ return __sync_val_compare_and_swap(addr, old_val, new_val ++ /* empty protection list */); ++} ++#define AO_HAVE_int_fetch_compare_and_swap ++ ++/* TODO: Add CAS _acquire/release/full primitives. */ ++ ++#ifndef AO_GENERALIZE_ASM_BOOL_CAS ++ AO_INLINE int ++ AO_int_compare_and_swap(volatile unsigned *addr, ++ unsigned old_val, unsigned new_val) ++ { ++ return __sync_bool_compare_and_swap(addr, old_val, new_val ++ /* empty protection list */); ++ } ++# define AO_HAVE_int_compare_and_swap ++#endif /* !AO_GENERALIZE_ASM_BOOL_CAS */ ++/* ++ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. ++ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. ++ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. ++ * ++ * ++ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED ++ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. ++ * ++ * Permission is hereby granted to use or copy this program ++ * for any purpose, provided the above notices are retained on all copies. ++ * Permission to modify the code and to distribute modified code is granted, ++ * provided the above notices are retained, and a notice that the code was ++ * modified is included with the above copyright notice. ++ * ++ */ ++ ++AO_INLINE AO_t ++AO_load(const volatile AO_t *addr) ++{ ++ return __atomic_load_n(addr, __ATOMIC_RELAXED); ++} ++#define AO_HAVE_load ++ ++AO_INLINE AO_t ++AO_load_acquire(const volatile AO_t *addr) ++{ ++ return __atomic_load_n(addr, __ATOMIC_ACQUIRE); ++} ++#define AO_HAVE_load_acquire ++ ++/* load_full is generalized using load and nop_full, so that */ ++/* load_read is defined using load and nop_read. */ ++/* store_full definition is omitted similar to load_full reason. */ ++ ++AO_INLINE void ++AO_store(volatile AO_t *addr, AO_t value) ++{ ++ __atomic_store_n(addr, value, __ATOMIC_RELAXED); ++} ++#define AO_HAVE_store ++ ++AO_INLINE void ++AO_store_release(volatile AO_t *addr, AO_t value) ++{ ++ __atomic_store_n(addr, value, __ATOMIC_RELEASE); ++} ++#define AO_HAVE_store_release ++ ++AO_INLINE AO_t ++AO_fetch_compare_and_swap(volatile AO_t *addr, ++ AO_t old_val, AO_t new_val) ++{ ++ return __sync_val_compare_and_swap(addr, old_val, new_val ++ /* empty protection list */); ++} ++#define AO_HAVE_fetch_compare_and_swap ++ ++/* TODO: Add CAS _acquire/release/full primitives. */ ++ ++#ifndef AO_GENERALIZE_ASM_BOOL_CAS ++ AO_INLINE int ++ AO_compare_and_swap(volatile AO_t *addr, ++ AO_t old_val, AO_t new_val) ++ { ++ return __sync_bool_compare_and_swap(addr, old_val, new_val ++ /* empty protection list */); ++ } ++# define AO_HAVE_compare_and_swap ++#endif /* !AO_GENERALIZE_ASM_BOOL_CAS */ +Index: libatomic_ops/src/atomic_ops/sysdeps/gcc/generic.h +=================================================================== +--- /dev/null ++++ libatomic_ops/src/atomic_ops/sysdeps/gcc/generic.h +@@ -0,0 +1,154 @@ ++/* ++ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. ++ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. ++ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. ++ * ++ * ++ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED ++ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. ++ * ++ * Permission is hereby granted to use or copy this program ++ * for any purpose, provided the above notices are retained on all copies. ++ * Permission to modify the code and to distribute modified code is granted, ++ * provided the above notices are retained, and a notice that the code was ++ * modified is included with the above copyright notice. ++ * ++ */ ++ ++/* The following implementation assumes GCC 4.7 or later. */ ++/* For the details, see GNU Manual, chapter 6.52 (Built-in functions */ ++/* for memory model aware atomic operations). */ ++ ++/* TODO: Include this file for other targets if gcc 4.7+ */ ++ ++#ifdef AO_UNIPROCESSOR ++ /* If only a single processor (core) is used, AO_UNIPROCESSOR could */ ++ /* be defined by the client to avoid unnecessary memory barrier. */ ++ AO_INLINE void ++ AO_nop_full(void) ++ { ++ AO_compiler_barrier(); ++ } ++# define AO_HAVE_nop_full ++ ++#else ++ AO_INLINE void ++ AO_nop_read(void) ++ { ++ __atomic_thread_fence(__ATOMIC_ACQUIRE); ++ } ++# define AO_HAVE_nop_read ++ ++# ifndef AO_HAVE_nop_write ++ AO_INLINE void ++ AO_nop_write(void) ++ { ++ __atomic_thread_fence(__ATOMIC_RELEASE); ++ } ++# define AO_HAVE_nop_write ++# endif ++ ++ AO_INLINE void ++ AO_nop_full(void) ++ { ++ /* __sync_synchronize() could be used instead. */ ++ __atomic_thread_fence(__ATOMIC_SEQ_CST); ++ } ++# define AO_HAVE_nop_full ++#endif /* !AO_UNIPROCESSOR */ ++ ++#include "generic-small.h" ++ ++#ifndef AO_PREFER_GENERALIZED ++# include "generic-arithm.h" ++ ++ AO_INLINE AO_TS_VAL_t ++ AO_test_and_set(volatile AO_TS_t *addr) ++ { ++ return (AO_TS_VAL_t)__atomic_test_and_set(addr, __ATOMIC_RELAXED); ++ } ++# define AO_HAVE_test_and_set ++ ++ AO_INLINE AO_TS_VAL_t ++ AO_test_and_set_acquire(volatile AO_TS_t *addr) ++ { ++ return (AO_TS_VAL_t)__atomic_test_and_set(addr, __ATOMIC_ACQUIRE); ++ } ++# define AO_HAVE_test_and_set_acquire ++ ++ AO_INLINE AO_TS_VAL_t ++ AO_test_and_set_release(volatile AO_TS_t *addr) ++ { ++ return (AO_TS_VAL_t)__atomic_test_and_set(addr, __ATOMIC_RELEASE); ++ } ++# define AO_HAVE_test_and_set_release ++ ++ AO_INLINE AO_TS_VAL_t ++ AO_test_and_set_full(volatile AO_TS_t *addr) ++ { ++ return (AO_TS_VAL_t)__atomic_test_and_set(addr, __ATOMIC_SEQ_CST); ++ } ++# define AO_HAVE_test_and_set_full ++#endif /* !AO_PREFER_GENERALIZED */ ++ ++#ifdef AO_HAVE_DOUBLE_PTR_STORAGE ++ ++# ifndef AO_HAVE_double_load ++ AO_INLINE AO_double_t ++ AO_double_load(const volatile AO_double_t *addr) ++ { ++ AO_double_t result; ++ ++ result.AO_whole = __atomic_load_n(&addr->AO_whole, __ATOMIC_RELAXED); ++ return result; ++ } ++# define AO_HAVE_double_load ++# endif ++ ++# ifndef AO_HAVE_double_load_acquire ++ AO_INLINE AO_double_t ++ AO_double_load_acquire(const volatile AO_double_t *addr) ++ { ++ AO_double_t result; ++ ++ result.AO_whole = __atomic_load_n(&addr->AO_whole, __ATOMIC_ACQUIRE); ++ return result; ++ } ++# define AO_HAVE_double_load_acquire ++# endif ++ ++# ifndef AO_HAVE_double_store ++ AO_INLINE void ++ AO_double_store(volatile AO_double_t *addr, AO_double_t value) ++ { ++ __atomic_store_n(&addr->AO_whole, value.AO_whole, __ATOMIC_RELAXED); ++ } ++# define AO_HAVE_double_store ++# endif ++ ++# ifndef AO_HAVE_double_store_release ++ AO_INLINE void ++ AO_double_store_release(volatile AO_double_t *addr, AO_double_t value) ++ { ++ __atomic_store_n(&addr->AO_whole, value.AO_whole, __ATOMIC_RELEASE); ++ } ++# define AO_HAVE_double_store_release ++# endif ++ ++# ifndef AO_HAVE_double_compare_and_swap ++ AO_INLINE int ++ AO_double_compare_and_swap(volatile AO_double_t *addr, ++ AO_double_t old_val, AO_double_t new_val) ++ { ++ return (int)__atomic_compare_exchange_n(&addr->AO_whole, ++ &old_val.AO_whole /* p_expected */, ++ new_val.AO_whole /* desired */, ++ 0 /* is_weak: false */, ++ __ATOMIC_RELAXED /* success */, ++ __ATOMIC_RELAXED /* failure */); ++ } ++# define AO_HAVE_double_compare_and_swap ++# endif ++ ++ /* TODO: Add double CAS _acquire/release/full primitives. */ ++#endif /* AO_HAVE_DOUBLE_PTR_STORAGE */ +Index: libatomic_ops/src/atomic_ops/sysdeps/standard_ao_double_t.h +=================================================================== +--- libatomic_ops/src/atomic_ops/sysdeps/standard_ao_double_t.h.orig ++++ libatomic_ops/src/atomic_ops/sysdeps/standard_ao_double_t.h +@@ -11,6 +11,8 @@ + typedef __m128 double_ptr_storage; + #elif defined(_WIN32) && !defined(__GNUC__) + typedef unsigned __int64 double_ptr_storage; ++#elif defined(__aarch64__) ++ typedef unsigned __int128 double_ptr_storage; + #else + typedef unsigned long long double_ptr_storage; + #endif From 7b748db8a3667257f1f2381b37b21e7e0c222fdb3aeb21f958a7a3564f5a1920 Mon Sep 17 00:00:00 2001 From: "Dr. Werner Fink" Date: Sun, 26 May 2013 09:37:56 +0000 Subject: [PATCH 2/3] Accepting request 176570 from home:Andreas_Schwab:Factory - libatomic_ops-aarch64.patch: update makefile to install missing headers, don't use AO_EXPECT_FALSE. OBS-URL: https://build.opensuse.org/request/show/176570 OBS-URL: https://build.opensuse.org/package/show/devel:libraries:c_c++/gc?expand=0&rev=26 --- gc.changes | 6 ++++++ libatomic_ops-aarch64.patch | 19 ++++++++++--------- 2 files changed, 16 insertions(+), 9 deletions(-) diff --git a/gc.changes b/gc.changes index a48a193..903116f 100644 --- a/gc.changes +++ b/gc.changes @@ -1,3 +1,9 @@ +------------------------------------------------------------------- +Sat May 25 19:16:48 UTC 2013 - root@localhost + +- libatomic_ops-aarch64.patch: update makefile to install missing headers, + don't use AO_EXPECT_FALSE. + ------------------------------------------------------------------- Sat May 18 08:10:09 UTC 2013 - schwab@suse.de diff --git a/libatomic_ops-aarch64.patch b/libatomic_ops-aarch64.patch index a3db085..308ac0b 100644 --- a/libatomic_ops-aarch64.patch +++ b/libatomic_ops-aarch64.patch @@ -17,11 +17,12 @@ Index: libatomic_ops/src/atomic_ops/sysdeps/Makefile.am =================================================================== --- libatomic_ops/src/atomic_ops/sysdeps/Makefile.am.orig +++ libatomic_ops/src/atomic_ops/sysdeps/Makefile.am -@@ -30,6 +30,7 @@ nobase_sysdep_HEADERS= generic_pthread.h +@@ -30,6 +30,8 @@ nobase_sysdep_HEADERS= generic_pthread.h gcc/hexagon.h gcc/hppa.h gcc/ia64.h gcc/m68k.h \ gcc/mips.h gcc/powerpc.h gcc/s390.h \ gcc/sh.h gcc/sparc.h gcc/x86.h gcc/x86_64.h \ -+ gcc/aarch64.h gcc/generic.h ++ gcc/aarch64.h gcc/generic.h \ ++ gcc/generic-small.h gcc/generic-arithm.h \ \ hpc/hppa.h hpc/ia64.h \ \ @@ -77,7 +78,7 @@ Index: libatomic_ops/src/atomic_ops/sysdeps/gcc/aarch64.h + " stxp %w2, %0, %1, %3" + : "=&r" (result.AO_val1), "=&r" (result.AO_val2), "=&r" (status) + : "Q" (*addr)); -+ } while (AO_EXPECT_FALSE(status)); ++ } while (status); + return result; + } +# define AO_HAVE_double_load @@ -94,7 +95,7 @@ Index: libatomic_ops/src/atomic_ops/sysdeps/gcc/aarch64.h + " stxp %w2, %0, %1, %3" + : "=&r" (result.AO_val1), "=&r" (result.AO_val2), "=&r" (status) + : "Q" (*addr)); -+ } while (AO_EXPECT_FALSE(status)); ++ } while (status); + return result; + } +# define AO_HAVE_double_load_acquire @@ -114,7 +115,7 @@ Index: libatomic_ops/src/atomic_ops/sysdeps/gcc/aarch64.h + : "r" (value.AO_val1), "r" (value.AO_val2)); + /* Compared to the arm.h implementation, the 'cc' (flags) are not */ + /* clobbered because A64 has no concept of conditional execution. */ -+ } while (AO_EXPECT_FALSE(status)); ++ } while (status); + } +# define AO_HAVE_double_store + @@ -131,7 +132,7 @@ Index: libatomic_ops/src/atomic_ops/sysdeps/gcc/aarch64.h + : "=&r" (old_val.AO_val1), "=&r" (old_val.AO_val2), "=&r" (status), + "=Q" (*addr) + : "r" (value.AO_val1), "r" (value.AO_val2)); -+ } while (AO_EXPECT_FALSE(status)); ++ } while (status); + } +# define AO_HAVE_double_store_release + @@ -153,7 +154,7 @@ Index: libatomic_ops/src/atomic_ops/sysdeps/gcc/aarch64.h + " stxp %w0, %2, %3, %1\n" + : "=&r" (result), "=Q" (*addr) + : "r" (new_val.AO_val1), "r" (new_val.AO_val2)); -+ } while (AO_EXPECT_FALSE(result)); ++ } while (result); + return !result; + } +# define AO_HAVE_double_compare_and_swap @@ -176,7 +177,7 @@ Index: libatomic_ops/src/atomic_ops/sysdeps/gcc/aarch64.h + " stxp %w0, %2, %3, %1\n" + : "=&r" (result), "=Q" (*addr) + : "r" (new_val.AO_val1), "r" (new_val.AO_val2)); -+ } while (AO_EXPECT_FALSE(result)); ++ } while (result); + return !result; + } +# define AO_HAVE_double_compare_and_swap_acquire @@ -199,7 +200,7 @@ Index: libatomic_ops/src/atomic_ops/sysdeps/gcc/aarch64.h + " stlxp %w0, %2, %3, %1\n" + : "=&r" (result), "=Q" (*addr) + : "r" (new_val.AO_val1), "r" (new_val.AO_val2)); -+ } while (AO_EXPECT_FALSE(result)); ++ } while (result); + return !result; + } +# define AO_HAVE_double_compare_and_swap_release From 38cf4ad225f19be9a67a7ed222c3b5d50918dacb3a3dc5999f8d4a6f58a68cde Mon Sep 17 00:00:00 2001 From: "Dr. Werner Fink" Date: Mon, 27 May 2013 07:35:17 +0000 Subject: [PATCH 3/3] Accepting request 176614 from home:jengelh:branches:devel:libraries:c_c++ Make use of external libatomic_ops -- openSUSE has it in a separate source package OBS-URL: https://build.opensuse.org/request/show/176614 OBS-URL: https://build.opensuse.org/package/show/devel:libraries:c_c++/gc?expand=0&rev=27 --- gc.changes | 9 + gc.spec | 66 +- libatomic_ops-aarch64.patch | 1375 ----------------------------------- 3 files changed, 26 insertions(+), 1424 deletions(-) delete mode 100644 libatomic_ops-aarch64.patch diff --git a/gc.changes b/gc.changes index 903116f..bd51013 100644 --- a/gc.changes +++ b/gc.changes @@ -1,3 +1,12 @@ +------------------------------------------------------------------- +Sun May 26 20:09:26 UTC 2013 - jengelh@inai.de + +- Make use of external libatomic_ops -- + openSUSE has it in a separate source package +- Fix version: 7.2d is not a prerelease, so there is no need to + call it 7.1* +- More portable make install call; more robust file list + ------------------------------------------------------------------- Sat May 25 19:16:48 UTC 2013 - root@localhost diff --git a/gc.spec b/gc.spec index e5e4c3e..2c63817 100644 --- a/gc.spec +++ b/gc.spec @@ -17,21 +17,21 @@ Name: gc -Version: 7.1.9.6 +Version: 7.2d Release: 0 -%define src_ver 7.2d Url: http://www.hpl.hp.com/personal/Hans_Boehm/gc/ Summary: A garbage collector for C and C++ License: BSD-3-Clause Group: Development/Libraries/C and C++ -Source: http://www.hpl.hp.com/personal/Hans_Boehm/gc/gc_source/%{name}-%{src_ver}.tar.gz + +Source: http://www.hpl.hp.com/personal/Hans_Boehm/gc/gc_source/%name-%version.tar.gz Patch1: aarch64-support.patch -Patch2: libatomic_ops-aarch64.patch BuildRoot: %{_tmppath}/%{name}-%{version}-build BuildRequires: autoconf >= 2.64 BuildRequires: gcc-c++ BuildRequires: libtool BuildRequires: pkg-config +BuildRequires: pkgconfig(atomic_ops) %description The Boehm-Demers-Weiser conservative garbage collector can be used as a @@ -73,24 +73,9 @@ deallocating memory that is no longer useful. The collector automatically recycles memory when it determines that it can no longer be otherwise accessed. -%package -n libatomic_ops-devel -Summary: Atomic memory update operations -Group: Development/Libraries/C and C++ -Provides: libatomic_ops-static = %{version}-%{release} -Obsoletes: libatomic-ops-devel <= 1.2 -Provides: libatomic-ops-devel = %{version} - -%description -n libatomic_ops-devel -Provides implementations for atomic memory update operations on a -number of architectures. This allows direct use of these in reasonably -portable code. Unlike earlier similar packages, this one explicitly -considers memory barrier semantics, and allows the construction of code -that involves minimum overhead across a variety of architectures. - %prep %setup -q -n %{name}-7.2 %patch1 -p1 -%patch2 %build # refresh auto*/libtool to purge rpaths @@ -107,25 +92,18 @@ CPPFLAGS="-DUSE_GET_STACKBASE_FOR_MAIN"; export CPPFLAGS --enable-large-config \ --enable-threads=posix \ --enable-parallel-mark \ - --with-libatomic-ops=no + --with-libatomic-ops=yes +# --with-libatomic-ops=yes means to use the system library make %{?_smp_mflags} -make %{?_smp_mflags} -C libatomic_ops %install - -%makeinstall -%makeinstall -C libatomic_ops - -rm -rf $RPM_BUILD_ROOT/usr/share/gc # docs -rm -rf %{buildroot}%{_datadir}/libatomic_ops/{COPYING,*.txt} -rm -f %{buildroot}%{_libdir}/*.la +make install DESTDIR="%buildroot" +rm -Rf "%buildroot/%_datadir/gc" "%buildroot/%_libdir"/*.la %check -%if ! 0%{?qemu_user_space_build} +%if !0%{?qemu_user_space_build} make check -# fails on i586 -make check -C libatomic_ops ||: %endif %post -n libgc1 -p /sbin/ldconfig @@ -135,27 +113,17 @@ make check -C libatomic_ops ||: %files -n libgc1 %defattr(-, root, root) %doc README.QUICK doc/README.* -%{_libdir}/lib*.so.* +%_libdir/libcord.so.1* +%_libdir/libgc*.so.1* %files devel %defattr(-, root, root) %doc doc/[a-z]* -%{_libdir}/lib*.so -%{_libdir}/pkgconfig/bdw-gc.pc -%{_includedir}/gc.h -%{_includedir}/gc_cpp.h -%{_includedir}/gc - -%files -n libatomic_ops-devel -%defattr(-,root,root,-) -%doc libatomic_ops/AUTHORS libatomic_ops/ChangeLog libatomic_ops/COPYING libatomic_ops/NEWS libatomic_ops/README -%doc libatomic_ops/doc/*.txt -%{_libdir}/pkgconfig/atomic_ops.pc -%{_includedir}/atomic_ops.h -%{_includedir}/atomic_ops_malloc.h -%{_includedir}/atomic_ops_stack.h -%{_includedir}/atomic_ops/ -%{_libdir}/libatomic_ops.a -%{_libdir}/libatomic_ops_gpl.a +%_libdir/libcord.so +%_libdir/libgc*.so +%_libdir/pkgconfig/bdw-gc.pc +%_includedir/gc.h +%_includedir/gc_cpp.h +%_includedir/gc/ %changelog diff --git a/libatomic_ops-aarch64.patch b/libatomic_ops-aarch64.patch deleted file mode 100644 index 308ac0b..0000000 --- a/libatomic_ops-aarch64.patch +++ /dev/null @@ -1,1375 +0,0 @@ -Index: libatomic_ops/src/atomic_ops.h -=================================================================== ---- libatomic_ops/src/atomic_ops.h.orig -+++ libatomic_ops/src/atomic_ops.h -@@ -244,6 +244,10 @@ - || defined(__powerpc64__) || defined(__ppc64__) - # include "atomic_ops/sysdeps/gcc/powerpc.h" - # endif /* __powerpc__ */ -+# if defined(__aarch64__) -+# include "atomic_ops/sysdeps/gcc/aarch64.h" -+# define AO_CAN_EMUL_CAS -+# endif /* __aarch64__ */ - # if defined(__arm__) && !defined(AO_USE_PTHREAD_DEFS) - # include "atomic_ops/sysdeps/gcc/arm.h" - # define AO_CAN_EMUL_CAS -Index: libatomic_ops/src/atomic_ops/sysdeps/Makefile.am -=================================================================== ---- libatomic_ops/src/atomic_ops/sysdeps/Makefile.am.orig -+++ libatomic_ops/src/atomic_ops/sysdeps/Makefile.am -@@ -30,6 +30,8 @@ nobase_sysdep_HEADERS= generic_pthread.h - gcc/hexagon.h gcc/hppa.h gcc/ia64.h gcc/m68k.h \ - gcc/mips.h gcc/powerpc.h gcc/s390.h \ - gcc/sh.h gcc/sparc.h gcc/x86.h gcc/x86_64.h \ -+ gcc/aarch64.h gcc/generic.h \ -+ gcc/generic-small.h gcc/generic-arithm.h \ - \ - hpc/hppa.h hpc/ia64.h \ - \ -Index: libatomic_ops/src/atomic_ops/sysdeps/gcc/aarch64.h -=================================================================== ---- /dev/null -+++ libatomic_ops/src/atomic_ops/sysdeps/gcc/aarch64.h -@@ -0,0 +1,176 @@ -+/* -+ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. -+ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. -+ * Copyright (c) 1999-2003 by Hewlett-Packard Company. All rights reserved. -+ * -+ * -+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED -+ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. -+ * -+ * Permission is hereby granted to use or copy this program -+ * for any purpose, provided the above notices are retained on all copies. -+ * Permission to modify the code and to distribute modified code is granted, -+ * provided the above notices are retained, and a notice that the code was -+ * modified is included with the above copyright notice. -+ * -+ */ -+ -+#include "../test_and_set_t_is_ao_t.h" -+ -+#include "../standard_ao_double_t.h" -+ -+#ifndef AO_UNIPROCESSOR -+ AO_INLINE void -+ AO_nop_write(void) -+ { -+ __asm__ __volatile__("dmb st" : : : "memory"); -+ } -+# define AO_HAVE_nop_write -+#endif -+ -+/* TODO: Adjust version check on fixing double-wide AO support in GCC. */ -+#if __GNUC__ == 4 -+ -+ AO_INLINE AO_double_t -+ AO_double_load(const volatile AO_double_t *addr) -+ { -+ AO_double_t result; -+ int status; -+ -+ /* Note that STXP cannot be discarded because LD[A]XP is not */ -+ /* single-copy atomic (unlike LDREXD for 32-bit ARM). */ -+ do { -+ __asm__ __volatile__("//AO_double_load\n" -+ " ldxp %0, %1, %3\n" -+ " stxp %w2, %0, %1, %3" -+ : "=&r" (result.AO_val1), "=&r" (result.AO_val2), "=&r" (status) -+ : "Q" (*addr)); -+ } while (status); -+ return result; -+ } -+# define AO_HAVE_double_load -+ -+ AO_INLINE AO_double_t -+ AO_double_load_acquire(const volatile AO_double_t *addr) -+ { -+ AO_double_t result; -+ int status; -+ -+ do { -+ __asm__ __volatile__("//AO_double_load_acquire\n" -+ " ldaxp %0, %1, %3\n" -+ " stxp %w2, %0, %1, %3" -+ : "=&r" (result.AO_val1), "=&r" (result.AO_val2), "=&r" (status) -+ : "Q" (*addr)); -+ } while (status); -+ return result; -+ } -+# define AO_HAVE_double_load_acquire -+ -+ AO_INLINE void -+ AO_double_store(volatile AO_double_t *addr, AO_double_t value) -+ { -+ AO_double_t old_val; -+ int status; -+ -+ do { -+ __asm__ __volatile__("//AO_double_store\n" -+ " ldxp %0, %1, %3\n" -+ " stxp %w2, %4, %5, %3" -+ : "=&r" (old_val.AO_val1), "=&r" (old_val.AO_val2), "=&r" (status), -+ "=Q" (*addr) -+ : "r" (value.AO_val1), "r" (value.AO_val2)); -+ /* Compared to the arm.h implementation, the 'cc' (flags) are not */ -+ /* clobbered because A64 has no concept of conditional execution. */ -+ } while (status); -+ } -+# define AO_HAVE_double_store -+ -+ AO_INLINE void -+ AO_double_store_release(volatile AO_double_t *addr, AO_double_t value) -+ { -+ AO_double_t old_val; -+ int status; -+ -+ do { -+ __asm__ __volatile__("//AO_double_store_release\n" -+ " ldxp %0, %1, %3\n" -+ " stlxp %w2, %4, %5, %3" -+ : "=&r" (old_val.AO_val1), "=&r" (old_val.AO_val2), "=&r" (status), -+ "=Q" (*addr) -+ : "r" (value.AO_val1), "r" (value.AO_val2)); -+ } while (status); -+ } -+# define AO_HAVE_double_store_release -+ -+ AO_INLINE int -+ AO_double_compare_and_swap(volatile AO_double_t *addr, -+ AO_double_t old_val, AO_double_t new_val) -+ { -+ AO_double_t tmp; -+ int result = 1; -+ -+ do { -+ __asm__ __volatile__("//AO_double_compare_and_swap\n" -+ " ldxp %0, %1, %2\n" -+ : "=&r" (tmp.AO_val1), "=&r" (tmp.AO_val2) -+ : "Q" (*addr)); -+ if (tmp.AO_val1 != old_val.AO_val1 || tmp.AO_val2 != old_val.AO_val2) -+ break; -+ __asm__ __volatile__( -+ " stxp %w0, %2, %3, %1\n" -+ : "=&r" (result), "=Q" (*addr) -+ : "r" (new_val.AO_val1), "r" (new_val.AO_val2)); -+ } while (result); -+ return !result; -+ } -+# define AO_HAVE_double_compare_and_swap -+ -+ AO_INLINE int -+ AO_double_compare_and_swap_acquire(volatile AO_double_t *addr, -+ AO_double_t old_val, AO_double_t new_val) -+ { -+ AO_double_t tmp; -+ int result = 1; -+ -+ do { -+ __asm__ __volatile__("//AO_double_compare_and_swap_acquire\n" -+ " ldaxp %0, %1, %2\n" -+ : "=&r" (tmp.AO_val1), "=&r" (tmp.AO_val2) -+ : "Q" (*addr)); -+ if (tmp.AO_val1 != old_val.AO_val1 || tmp.AO_val2 != old_val.AO_val2) -+ break; -+ __asm__ __volatile__( -+ " stxp %w0, %2, %3, %1\n" -+ : "=&r" (result), "=Q" (*addr) -+ : "r" (new_val.AO_val1), "r" (new_val.AO_val2)); -+ } while (result); -+ return !result; -+ } -+# define AO_HAVE_double_compare_and_swap_acquire -+ -+ AO_INLINE int -+ AO_double_compare_and_swap_release(volatile AO_double_t *addr, -+ AO_double_t old_val, AO_double_t new_val) -+ { -+ AO_double_t tmp; -+ int result = 1; -+ -+ do { -+ __asm__ __volatile__("//AO_double_compare_and_swap_release\n" -+ " ldxp %0, %1, %2\n" -+ : "=&r" (tmp.AO_val1), "=&r" (tmp.AO_val2) -+ : "Q" (*addr)); -+ if (tmp.AO_val1 != old_val.AO_val1 || tmp.AO_val2 != old_val.AO_val2) -+ break; -+ __asm__ __volatile__( -+ " stlxp %w0, %2, %3, %1\n" -+ : "=&r" (result), "=Q" (*addr) -+ : "r" (new_val.AO_val1), "r" (new_val.AO_val2)); -+ } while (result); -+ return !result; -+ } -+# define AO_HAVE_double_compare_and_swap_release -+#endif -+ -+#include "generic.h" -Index: libatomic_ops/src/atomic_ops/sysdeps/gcc/generic-arithm.h -=================================================================== ---- /dev/null -+++ libatomic_ops/src/atomic_ops/sysdeps/gcc/generic-arithm.h -@@ -0,0 +1,704 @@ -+/* -+ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. -+ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. -+ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. -+ * -+ * -+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED -+ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. -+ * -+ * Permission is hereby granted to use or copy this program -+ * for any purpose, provided the above notices are retained on all copies. -+ * Permission to modify the code and to distribute modified code is granted, -+ * provided the above notices are retained, and a notice that the code was -+ * modified is included with the above copyright notice. -+ * -+ */ -+ -+AO_INLINE unsigned/**/char -+AO_char_fetch_and_add(volatile unsigned/**/char *addr, unsigned/**/char incr) -+{ -+ return __atomic_fetch_add(addr, incr, __ATOMIC_RELAXED); -+} -+#define AO_HAVE_char_fetch_and_add -+ -+AO_INLINE void -+AO_char_and(volatile unsigned/**/char *addr, unsigned/**/char value) -+{ -+ (void)__atomic_and_fetch(addr, value, __ATOMIC_RELAXED); -+} -+#define AO_HAVE_char_and -+ -+AO_INLINE void -+AO_char_or(volatile unsigned/**/char *addr, unsigned/**/char value) -+{ -+ (void)__atomic_or_fetch(addr, value, __ATOMIC_RELAXED); -+} -+#define AO_HAVE_char_or -+ -+AO_INLINE void -+AO_char_xor(volatile unsigned/**/char *addr, unsigned/**/char value) -+{ -+ (void)__atomic_xor_fetch(addr, value, __ATOMIC_RELAXED); -+} -+#define AO_HAVE_char_xor -+/* -+ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. -+ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. -+ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. -+ * -+ * -+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED -+ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. -+ * -+ * Permission is hereby granted to use or copy this program -+ * for any purpose, provided the above notices are retained on all copies. -+ * Permission to modify the code and to distribute modified code is granted, -+ * provided the above notices are retained, and a notice that the code was -+ * modified is included with the above copyright notice. -+ * -+ */ -+ -+AO_INLINE unsigned/**/short -+AO_short_fetch_and_add(volatile unsigned/**/short *addr, unsigned/**/short incr) -+{ -+ return __atomic_fetch_add(addr, incr, __ATOMIC_RELAXED); -+} -+#define AO_HAVE_short_fetch_and_add -+ -+AO_INLINE void -+AO_short_and(volatile unsigned/**/short *addr, unsigned/**/short value) -+{ -+ (void)__atomic_and_fetch(addr, value, __ATOMIC_RELAXED); -+} -+#define AO_HAVE_short_and -+ -+AO_INLINE void -+AO_short_or(volatile unsigned/**/short *addr, unsigned/**/short value) -+{ -+ (void)__atomic_or_fetch(addr, value, __ATOMIC_RELAXED); -+} -+#define AO_HAVE_short_or -+ -+AO_INLINE void -+AO_short_xor(volatile unsigned/**/short *addr, unsigned/**/short value) -+{ -+ (void)__atomic_xor_fetch(addr, value, __ATOMIC_RELAXED); -+} -+#define AO_HAVE_short_xor -+/* -+ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. -+ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. -+ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. -+ * -+ * -+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED -+ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. -+ * -+ * Permission is hereby granted to use or copy this program -+ * for any purpose, provided the above notices are retained on all copies. -+ * Permission to modify the code and to distribute modified code is granted, -+ * provided the above notices are retained, and a notice that the code was -+ * modified is included with the above copyright notice. -+ * -+ */ -+ -+AO_INLINE unsigned -+AO_int_fetch_and_add(volatile unsigned *addr, unsigned incr) -+{ -+ return __atomic_fetch_add(addr, incr, __ATOMIC_RELAXED); -+} -+#define AO_HAVE_int_fetch_and_add -+ -+AO_INLINE void -+AO_int_and(volatile unsigned *addr, unsigned value) -+{ -+ (void)__atomic_and_fetch(addr, value, __ATOMIC_RELAXED); -+} -+#define AO_HAVE_int_and -+ -+AO_INLINE void -+AO_int_or(volatile unsigned *addr, unsigned value) -+{ -+ (void)__atomic_or_fetch(addr, value, __ATOMIC_RELAXED); -+} -+#define AO_HAVE_int_or -+ -+AO_INLINE void -+AO_int_xor(volatile unsigned *addr, unsigned value) -+{ -+ (void)__atomic_xor_fetch(addr, value, __ATOMIC_RELAXED); -+} -+#define AO_HAVE_int_xor -+/* -+ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. -+ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. -+ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. -+ * -+ * -+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED -+ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. -+ * -+ * Permission is hereby granted to use or copy this program -+ * for any purpose, provided the above notices are retained on all copies. -+ * Permission to modify the code and to distribute modified code is granted, -+ * provided the above notices are retained, and a notice that the code was -+ * modified is included with the above copyright notice. -+ * -+ */ -+ -+AO_INLINE AO_t -+AO_fetch_and_add(volatile AO_t *addr, AO_t incr) -+{ -+ return __atomic_fetch_add(addr, incr, __ATOMIC_RELAXED); -+} -+#define AO_HAVE_fetch_and_add -+ -+AO_INLINE void -+AO_and(volatile AO_t *addr, AO_t value) -+{ -+ (void)__atomic_and_fetch(addr, value, __ATOMIC_RELAXED); -+} -+#define AO_HAVE_and -+ -+AO_INLINE void -+AO_or(volatile AO_t *addr, AO_t value) -+{ -+ (void)__atomic_or_fetch(addr, value, __ATOMIC_RELAXED); -+} -+#define AO_HAVE_or -+ -+AO_INLINE void -+AO_xor(volatile AO_t *addr, AO_t value) -+{ -+ (void)__atomic_xor_fetch(addr, value, __ATOMIC_RELAXED); -+} -+#define AO_HAVE_xor -+/* -+ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. -+ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. -+ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. -+ * -+ * -+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED -+ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. -+ * -+ * Permission is hereby granted to use or copy this program -+ * for any purpose, provided the above notices are retained on all copies. -+ * Permission to modify the code and to distribute modified code is granted, -+ * provided the above notices are retained, and a notice that the code was -+ * modified is included with the above copyright notice. -+ * -+ */ -+ -+AO_INLINE unsigned/**/char -+AO_char_fetch_and_add_acquire(volatile unsigned/**/char *addr, unsigned/**/char incr) -+{ -+ return __atomic_fetch_add(addr, incr, __ATOMIC_ACQUIRE); -+} -+#define AO_HAVE_char_fetch_and_add_acquire -+ -+AO_INLINE void -+AO_char_and_acquire(volatile unsigned/**/char *addr, unsigned/**/char value) -+{ -+ (void)__atomic_and_fetch(addr, value, __ATOMIC_ACQUIRE); -+} -+#define AO_HAVE_char_and_acquire -+ -+AO_INLINE void -+AO_char_or_acquire(volatile unsigned/**/char *addr, unsigned/**/char value) -+{ -+ (void)__atomic_or_fetch(addr, value, __ATOMIC_ACQUIRE); -+} -+#define AO_HAVE_char_or_acquire -+ -+AO_INLINE void -+AO_char_xor_acquire(volatile unsigned/**/char *addr, unsigned/**/char value) -+{ -+ (void)__atomic_xor_fetch(addr, value, __ATOMIC_ACQUIRE); -+} -+#define AO_HAVE_char_xor_acquire -+/* -+ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. -+ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. -+ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. -+ * -+ * -+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED -+ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. -+ * -+ * Permission is hereby granted to use or copy this program -+ * for any purpose, provided the above notices are retained on all copies. -+ * Permission to modify the code and to distribute modified code is granted, -+ * provided the above notices are retained, and a notice that the code was -+ * modified is included with the above copyright notice. -+ * -+ */ -+ -+AO_INLINE unsigned/**/short -+AO_short_fetch_and_add_acquire(volatile unsigned/**/short *addr, unsigned/**/short incr) -+{ -+ return __atomic_fetch_add(addr, incr, __ATOMIC_ACQUIRE); -+} -+#define AO_HAVE_short_fetch_and_add_acquire -+ -+AO_INLINE void -+AO_short_and_acquire(volatile unsigned/**/short *addr, unsigned/**/short value) -+{ -+ (void)__atomic_and_fetch(addr, value, __ATOMIC_ACQUIRE); -+} -+#define AO_HAVE_short_and_acquire -+ -+AO_INLINE void -+AO_short_or_acquire(volatile unsigned/**/short *addr, unsigned/**/short value) -+{ -+ (void)__atomic_or_fetch(addr, value, __ATOMIC_ACQUIRE); -+} -+#define AO_HAVE_short_or_acquire -+ -+AO_INLINE void -+AO_short_xor_acquire(volatile unsigned/**/short *addr, unsigned/**/short value) -+{ -+ (void)__atomic_xor_fetch(addr, value, __ATOMIC_ACQUIRE); -+} -+#define AO_HAVE_short_xor_acquire -+/* -+ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. -+ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. -+ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. -+ * -+ * -+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED -+ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. -+ * -+ * Permission is hereby granted to use or copy this program -+ * for any purpose, provided the above notices are retained on all copies. -+ * Permission to modify the code and to distribute modified code is granted, -+ * provided the above notices are retained, and a notice that the code was -+ * modified is included with the above copyright notice. -+ * -+ */ -+ -+AO_INLINE unsigned -+AO_int_fetch_and_add_acquire(volatile unsigned *addr, unsigned incr) -+{ -+ return __atomic_fetch_add(addr, incr, __ATOMIC_ACQUIRE); -+} -+#define AO_HAVE_int_fetch_and_add_acquire -+ -+AO_INLINE void -+AO_int_and_acquire(volatile unsigned *addr, unsigned value) -+{ -+ (void)__atomic_and_fetch(addr, value, __ATOMIC_ACQUIRE); -+} -+#define AO_HAVE_int_and_acquire -+ -+AO_INLINE void -+AO_int_or_acquire(volatile unsigned *addr, unsigned value) -+{ -+ (void)__atomic_or_fetch(addr, value, __ATOMIC_ACQUIRE); -+} -+#define AO_HAVE_int_or_acquire -+ -+AO_INLINE void -+AO_int_xor_acquire(volatile unsigned *addr, unsigned value) -+{ -+ (void)__atomic_xor_fetch(addr, value, __ATOMIC_ACQUIRE); -+} -+#define AO_HAVE_int_xor_acquire -+/* -+ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. -+ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. -+ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. -+ * -+ * -+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED -+ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. -+ * -+ * Permission is hereby granted to use or copy this program -+ * for any purpose, provided the above notices are retained on all copies. -+ * Permission to modify the code and to distribute modified code is granted, -+ * provided the above notices are retained, and a notice that the code was -+ * modified is included with the above copyright notice. -+ * -+ */ -+ -+AO_INLINE AO_t -+AO_fetch_and_add_acquire(volatile AO_t *addr, AO_t incr) -+{ -+ return __atomic_fetch_add(addr, incr, __ATOMIC_ACQUIRE); -+} -+#define AO_HAVE_fetch_and_add_acquire -+ -+AO_INLINE void -+AO_and_acquire(volatile AO_t *addr, AO_t value) -+{ -+ (void)__atomic_and_fetch(addr, value, __ATOMIC_ACQUIRE); -+} -+#define AO_HAVE_and_acquire -+ -+AO_INLINE void -+AO_or_acquire(volatile AO_t *addr, AO_t value) -+{ -+ (void)__atomic_or_fetch(addr, value, __ATOMIC_ACQUIRE); -+} -+#define AO_HAVE_or_acquire -+ -+AO_INLINE void -+AO_xor_acquire(volatile AO_t *addr, AO_t value) -+{ -+ (void)__atomic_xor_fetch(addr, value, __ATOMIC_ACQUIRE); -+} -+#define AO_HAVE_xor_acquire -+/* -+ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. -+ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. -+ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. -+ * -+ * -+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED -+ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. -+ * -+ * Permission is hereby granted to use or copy this program -+ * for any purpose, provided the above notices are retained on all copies. -+ * Permission to modify the code and to distribute modified code is granted, -+ * provided the above notices are retained, and a notice that the code was -+ * modified is included with the above copyright notice. -+ * -+ */ -+ -+AO_INLINE unsigned/**/char -+AO_char_fetch_and_add_release(volatile unsigned/**/char *addr, unsigned/**/char incr) -+{ -+ return __atomic_fetch_add(addr, incr, __ATOMIC_RELEASE); -+} -+#define AO_HAVE_char_fetch_and_add_release -+ -+AO_INLINE void -+AO_char_and_release(volatile unsigned/**/char *addr, unsigned/**/char value) -+{ -+ (void)__atomic_and_fetch(addr, value, __ATOMIC_RELEASE); -+} -+#define AO_HAVE_char_and_release -+ -+AO_INLINE void -+AO_char_or_release(volatile unsigned/**/char *addr, unsigned/**/char value) -+{ -+ (void)__atomic_or_fetch(addr, value, __ATOMIC_RELEASE); -+} -+#define AO_HAVE_char_or_release -+ -+AO_INLINE void -+AO_char_xor_release(volatile unsigned/**/char *addr, unsigned/**/char value) -+{ -+ (void)__atomic_xor_fetch(addr, value, __ATOMIC_RELEASE); -+} -+#define AO_HAVE_char_xor_release -+/* -+ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. -+ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. -+ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. -+ * -+ * -+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED -+ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. -+ * -+ * Permission is hereby granted to use or copy this program -+ * for any purpose, provided the above notices are retained on all copies. -+ * Permission to modify the code and to distribute modified code is granted, -+ * provided the above notices are retained, and a notice that the code was -+ * modified is included with the above copyright notice. -+ * -+ */ -+ -+AO_INLINE unsigned/**/short -+AO_short_fetch_and_add_release(volatile unsigned/**/short *addr, unsigned/**/short incr) -+{ -+ return __atomic_fetch_add(addr, incr, __ATOMIC_RELEASE); -+} -+#define AO_HAVE_short_fetch_and_add_release -+ -+AO_INLINE void -+AO_short_and_release(volatile unsigned/**/short *addr, unsigned/**/short value) -+{ -+ (void)__atomic_and_fetch(addr, value, __ATOMIC_RELEASE); -+} -+#define AO_HAVE_short_and_release -+ -+AO_INLINE void -+AO_short_or_release(volatile unsigned/**/short *addr, unsigned/**/short value) -+{ -+ (void)__atomic_or_fetch(addr, value, __ATOMIC_RELEASE); -+} -+#define AO_HAVE_short_or_release -+ -+AO_INLINE void -+AO_short_xor_release(volatile unsigned/**/short *addr, unsigned/**/short value) -+{ -+ (void)__atomic_xor_fetch(addr, value, __ATOMIC_RELEASE); -+} -+#define AO_HAVE_short_xor_release -+/* -+ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. -+ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. -+ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. -+ * -+ * -+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED -+ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. -+ * -+ * Permission is hereby granted to use or copy this program -+ * for any purpose, provided the above notices are retained on all copies. -+ * Permission to modify the code and to distribute modified code is granted, -+ * provided the above notices are retained, and a notice that the code was -+ * modified is included with the above copyright notice. -+ * -+ */ -+ -+AO_INLINE unsigned -+AO_int_fetch_and_add_release(volatile unsigned *addr, unsigned incr) -+{ -+ return __atomic_fetch_add(addr, incr, __ATOMIC_RELEASE); -+} -+#define AO_HAVE_int_fetch_and_add_release -+ -+AO_INLINE void -+AO_int_and_release(volatile unsigned *addr, unsigned value) -+{ -+ (void)__atomic_and_fetch(addr, value, __ATOMIC_RELEASE); -+} -+#define AO_HAVE_int_and_release -+ -+AO_INLINE void -+AO_int_or_release(volatile unsigned *addr, unsigned value) -+{ -+ (void)__atomic_or_fetch(addr, value, __ATOMIC_RELEASE); -+} -+#define AO_HAVE_int_or_release -+ -+AO_INLINE void -+AO_int_xor_release(volatile unsigned *addr, unsigned value) -+{ -+ (void)__atomic_xor_fetch(addr, value, __ATOMIC_RELEASE); -+} -+#define AO_HAVE_int_xor_release -+/* -+ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. -+ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. -+ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. -+ * -+ * -+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED -+ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. -+ * -+ * Permission is hereby granted to use or copy this program -+ * for any purpose, provided the above notices are retained on all copies. -+ * Permission to modify the code and to distribute modified code is granted, -+ * provided the above notices are retained, and a notice that the code was -+ * modified is included with the above copyright notice. -+ * -+ */ -+ -+AO_INLINE AO_t -+AO_fetch_and_add_release(volatile AO_t *addr, AO_t incr) -+{ -+ return __atomic_fetch_add(addr, incr, __ATOMIC_RELEASE); -+} -+#define AO_HAVE_fetch_and_add_release -+ -+AO_INLINE void -+AO_and_release(volatile AO_t *addr, AO_t value) -+{ -+ (void)__atomic_and_fetch(addr, value, __ATOMIC_RELEASE); -+} -+#define AO_HAVE_and_release -+ -+AO_INLINE void -+AO_or_release(volatile AO_t *addr, AO_t value) -+{ -+ (void)__atomic_or_fetch(addr, value, __ATOMIC_RELEASE); -+} -+#define AO_HAVE_or_release -+ -+AO_INLINE void -+AO_xor_release(volatile AO_t *addr, AO_t value) -+{ -+ (void)__atomic_xor_fetch(addr, value, __ATOMIC_RELEASE); -+} -+#define AO_HAVE_xor_release -+/* -+ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. -+ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. -+ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. -+ * -+ * -+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED -+ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. -+ * -+ * Permission is hereby granted to use or copy this program -+ * for any purpose, provided the above notices are retained on all copies. -+ * Permission to modify the code and to distribute modified code is granted, -+ * provided the above notices are retained, and a notice that the code was -+ * modified is included with the above copyright notice. -+ * -+ */ -+ -+AO_INLINE unsigned/**/char -+AO_char_fetch_and_add_full(volatile unsigned/**/char *addr, unsigned/**/char incr) -+{ -+ return __atomic_fetch_add(addr, incr, __ATOMIC_SEQ_CST); -+} -+#define AO_HAVE_char_fetch_and_add_full -+ -+AO_INLINE void -+AO_char_and_full(volatile unsigned/**/char *addr, unsigned/**/char value) -+{ -+ (void)__atomic_and_fetch(addr, value, __ATOMIC_SEQ_CST); -+} -+#define AO_HAVE_char_and_full -+ -+AO_INLINE void -+AO_char_or_full(volatile unsigned/**/char *addr, unsigned/**/char value) -+{ -+ (void)__atomic_or_fetch(addr, value, __ATOMIC_SEQ_CST); -+} -+#define AO_HAVE_char_or_full -+ -+AO_INLINE void -+AO_char_xor_full(volatile unsigned/**/char *addr, unsigned/**/char value) -+{ -+ (void)__atomic_xor_fetch(addr, value, __ATOMIC_SEQ_CST); -+} -+#define AO_HAVE_char_xor_full -+/* -+ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. -+ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. -+ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. -+ * -+ * -+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED -+ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. -+ * -+ * Permission is hereby granted to use or copy this program -+ * for any purpose, provided the above notices are retained on all copies. -+ * Permission to modify the code and to distribute modified code is granted, -+ * provided the above notices are retained, and a notice that the code was -+ * modified is included with the above copyright notice. -+ * -+ */ -+ -+AO_INLINE unsigned/**/short -+AO_short_fetch_and_add_full(volatile unsigned/**/short *addr, unsigned/**/short incr) -+{ -+ return __atomic_fetch_add(addr, incr, __ATOMIC_SEQ_CST); -+} -+#define AO_HAVE_short_fetch_and_add_full -+ -+AO_INLINE void -+AO_short_and_full(volatile unsigned/**/short *addr, unsigned/**/short value) -+{ -+ (void)__atomic_and_fetch(addr, value, __ATOMIC_SEQ_CST); -+} -+#define AO_HAVE_short_and_full -+ -+AO_INLINE void -+AO_short_or_full(volatile unsigned/**/short *addr, unsigned/**/short value) -+{ -+ (void)__atomic_or_fetch(addr, value, __ATOMIC_SEQ_CST); -+} -+#define AO_HAVE_short_or_full -+ -+AO_INLINE void -+AO_short_xor_full(volatile unsigned/**/short *addr, unsigned/**/short value) -+{ -+ (void)__atomic_xor_fetch(addr, value, __ATOMIC_SEQ_CST); -+} -+#define AO_HAVE_short_xor_full -+/* -+ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. -+ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. -+ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. -+ * -+ * -+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED -+ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. -+ * -+ * Permission is hereby granted to use or copy this program -+ * for any purpose, provided the above notices are retained on all copies. -+ * Permission to modify the code and to distribute modified code is granted, -+ * provided the above notices are retained, and a notice that the code was -+ * modified is included with the above copyright notice. -+ * -+ */ -+ -+AO_INLINE unsigned -+AO_int_fetch_and_add_full(volatile unsigned *addr, unsigned incr) -+{ -+ return __atomic_fetch_add(addr, incr, __ATOMIC_SEQ_CST); -+} -+#define AO_HAVE_int_fetch_and_add_full -+ -+AO_INLINE void -+AO_int_and_full(volatile unsigned *addr, unsigned value) -+{ -+ (void)__atomic_and_fetch(addr, value, __ATOMIC_SEQ_CST); -+} -+#define AO_HAVE_int_and_full -+ -+AO_INLINE void -+AO_int_or_full(volatile unsigned *addr, unsigned value) -+{ -+ (void)__atomic_or_fetch(addr, value, __ATOMIC_SEQ_CST); -+} -+#define AO_HAVE_int_or_full -+ -+AO_INLINE void -+AO_int_xor_full(volatile unsigned *addr, unsigned value) -+{ -+ (void)__atomic_xor_fetch(addr, value, __ATOMIC_SEQ_CST); -+} -+#define AO_HAVE_int_xor_full -+/* -+ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. -+ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. -+ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. -+ * -+ * -+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED -+ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. -+ * -+ * Permission is hereby granted to use or copy this program -+ * for any purpose, provided the above notices are retained on all copies. -+ * Permission to modify the code and to distribute modified code is granted, -+ * provided the above notices are retained, and a notice that the code was -+ * modified is included with the above copyright notice. -+ * -+ */ -+ -+AO_INLINE AO_t -+AO_fetch_and_add_full(volatile AO_t *addr, AO_t incr) -+{ -+ return __atomic_fetch_add(addr, incr, __ATOMIC_SEQ_CST); -+} -+#define AO_HAVE_fetch_and_add_full -+ -+AO_INLINE void -+AO_and_full(volatile AO_t *addr, AO_t value) -+{ -+ (void)__atomic_and_fetch(addr, value, __ATOMIC_SEQ_CST); -+} -+#define AO_HAVE_and_full -+ -+AO_INLINE void -+AO_or_full(volatile AO_t *addr, AO_t value) -+{ -+ (void)__atomic_or_fetch(addr, value, __ATOMIC_SEQ_CST); -+} -+#define AO_HAVE_or_full -+ -+AO_INLINE void -+AO_xor_full(volatile AO_t *addr, AO_t value) -+{ -+ (void)__atomic_xor_fetch(addr, value, __ATOMIC_SEQ_CST); -+} -+#define AO_HAVE_xor_full -Index: libatomic_ops/src/atomic_ops/sysdeps/gcc/generic-small.h -=================================================================== ---- /dev/null -+++ libatomic_ops/src/atomic_ops/sysdeps/gcc/generic-small.h -@@ -0,0 +1,280 @@ -+/* -+ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. -+ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. -+ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. -+ * -+ * -+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED -+ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. -+ * -+ * Permission is hereby granted to use or copy this program -+ * for any purpose, provided the above notices are retained on all copies. -+ * Permission to modify the code and to distribute modified code is granted, -+ * provided the above notices are retained, and a notice that the code was -+ * modified is included with the above copyright notice. -+ * -+ */ -+ -+AO_INLINE unsigned/**/char -+AO_char_load(const volatile unsigned/**/char *addr) -+{ -+ return __atomic_load_n(addr, __ATOMIC_RELAXED); -+} -+#define AO_HAVE_char_load -+ -+AO_INLINE unsigned/**/char -+AO_char_load_acquire(const volatile unsigned/**/char *addr) -+{ -+ return __atomic_load_n(addr, __ATOMIC_ACQUIRE); -+} -+#define AO_HAVE_char_load_acquire -+ -+/* char_load_full is generalized using load and nop_full, so that */ -+/* char_load_read is defined using load and nop_read. */ -+/* char_store_full definition is omitted similar to load_full reason. */ -+ -+AO_INLINE void -+AO_char_store(volatile unsigned/**/char *addr, unsigned/**/char value) -+{ -+ __atomic_store_n(addr, value, __ATOMIC_RELAXED); -+} -+#define AO_HAVE_char_store -+ -+AO_INLINE void -+AO_char_store_release(volatile unsigned/**/char *addr, unsigned/**/char value) -+{ -+ __atomic_store_n(addr, value, __ATOMIC_RELEASE); -+} -+#define AO_HAVE_char_store_release -+ -+AO_INLINE unsigned/**/char -+AO_char_fetch_compare_and_swap(volatile unsigned/**/char *addr, -+ unsigned/**/char old_val, unsigned/**/char new_val) -+{ -+ return __sync_val_compare_and_swap(addr, old_val, new_val -+ /* empty protection list */); -+} -+#define AO_HAVE_char_fetch_compare_and_swap -+ -+/* TODO: Add CAS _acquire/release/full primitives. */ -+ -+#ifndef AO_GENERALIZE_ASM_BOOL_CAS -+ AO_INLINE int -+ AO_char_compare_and_swap(volatile unsigned/**/char *addr, -+ unsigned/**/char old_val, unsigned/**/char new_val) -+ { -+ return __sync_bool_compare_and_swap(addr, old_val, new_val -+ /* empty protection list */); -+ } -+# define AO_HAVE_char_compare_and_swap -+#endif /* !AO_GENERALIZE_ASM_BOOL_CAS */ -+/* -+ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. -+ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. -+ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. -+ * -+ * -+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED -+ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. -+ * -+ * Permission is hereby granted to use or copy this program -+ * for any purpose, provided the above notices are retained on all copies. -+ * Permission to modify the code and to distribute modified code is granted, -+ * provided the above notices are retained, and a notice that the code was -+ * modified is included with the above copyright notice. -+ * -+ */ -+ -+AO_INLINE unsigned/**/short -+AO_short_load(const volatile unsigned/**/short *addr) -+{ -+ return __atomic_load_n(addr, __ATOMIC_RELAXED); -+} -+#define AO_HAVE_short_load -+ -+AO_INLINE unsigned/**/short -+AO_short_load_acquire(const volatile unsigned/**/short *addr) -+{ -+ return __atomic_load_n(addr, __ATOMIC_ACQUIRE); -+} -+#define AO_HAVE_short_load_acquire -+ -+/* short_load_full is generalized using load and nop_full, so that */ -+/* short_load_read is defined using load and nop_read. */ -+/* short_store_full definition is omitted similar to load_full reason. */ -+ -+AO_INLINE void -+AO_short_store(volatile unsigned/**/short *addr, unsigned/**/short value) -+{ -+ __atomic_store_n(addr, value, __ATOMIC_RELAXED); -+} -+#define AO_HAVE_short_store -+ -+AO_INLINE void -+AO_short_store_release(volatile unsigned/**/short *addr, unsigned/**/short value) -+{ -+ __atomic_store_n(addr, value, __ATOMIC_RELEASE); -+} -+#define AO_HAVE_short_store_release -+ -+AO_INLINE unsigned/**/short -+AO_short_fetch_compare_and_swap(volatile unsigned/**/short *addr, -+ unsigned/**/short old_val, unsigned/**/short new_val) -+{ -+ return __sync_val_compare_and_swap(addr, old_val, new_val -+ /* empty protection list */); -+} -+#define AO_HAVE_short_fetch_compare_and_swap -+ -+/* TODO: Add CAS _acquire/release/full primitives. */ -+ -+#ifndef AO_GENERALIZE_ASM_BOOL_CAS -+ AO_INLINE int -+ AO_short_compare_and_swap(volatile unsigned/**/short *addr, -+ unsigned/**/short old_val, unsigned/**/short new_val) -+ { -+ return __sync_bool_compare_and_swap(addr, old_val, new_val -+ /* empty protection list */); -+ } -+# define AO_HAVE_short_compare_and_swap -+#endif /* !AO_GENERALIZE_ASM_BOOL_CAS */ -+/* -+ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. -+ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. -+ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. -+ * -+ * -+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED -+ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. -+ * -+ * Permission is hereby granted to use or copy this program -+ * for any purpose, provided the above notices are retained on all copies. -+ * Permission to modify the code and to distribute modified code is granted, -+ * provided the above notices are retained, and a notice that the code was -+ * modified is included with the above copyright notice. -+ * -+ */ -+ -+AO_INLINE unsigned -+AO_int_load(const volatile unsigned *addr) -+{ -+ return __atomic_load_n(addr, __ATOMIC_RELAXED); -+} -+#define AO_HAVE_int_load -+ -+AO_INLINE unsigned -+AO_int_load_acquire(const volatile unsigned *addr) -+{ -+ return __atomic_load_n(addr, __ATOMIC_ACQUIRE); -+} -+#define AO_HAVE_int_load_acquire -+ -+/* int_load_full is generalized using load and nop_full, so that */ -+/* int_load_read is defined using load and nop_read. */ -+/* int_store_full definition is omitted similar to load_full reason. */ -+ -+AO_INLINE void -+AO_int_store(volatile unsigned *addr, unsigned value) -+{ -+ __atomic_store_n(addr, value, __ATOMIC_RELAXED); -+} -+#define AO_HAVE_int_store -+ -+AO_INLINE void -+AO_int_store_release(volatile unsigned *addr, unsigned value) -+{ -+ __atomic_store_n(addr, value, __ATOMIC_RELEASE); -+} -+#define AO_HAVE_int_store_release -+ -+AO_INLINE unsigned -+AO_int_fetch_compare_and_swap(volatile unsigned *addr, -+ unsigned old_val, unsigned new_val) -+{ -+ return __sync_val_compare_and_swap(addr, old_val, new_val -+ /* empty protection list */); -+} -+#define AO_HAVE_int_fetch_compare_and_swap -+ -+/* TODO: Add CAS _acquire/release/full primitives. */ -+ -+#ifndef AO_GENERALIZE_ASM_BOOL_CAS -+ AO_INLINE int -+ AO_int_compare_and_swap(volatile unsigned *addr, -+ unsigned old_val, unsigned new_val) -+ { -+ return __sync_bool_compare_and_swap(addr, old_val, new_val -+ /* empty protection list */); -+ } -+# define AO_HAVE_int_compare_and_swap -+#endif /* !AO_GENERALIZE_ASM_BOOL_CAS */ -+/* -+ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. -+ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. -+ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. -+ * -+ * -+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED -+ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. -+ * -+ * Permission is hereby granted to use or copy this program -+ * for any purpose, provided the above notices are retained on all copies. -+ * Permission to modify the code and to distribute modified code is granted, -+ * provided the above notices are retained, and a notice that the code was -+ * modified is included with the above copyright notice. -+ * -+ */ -+ -+AO_INLINE AO_t -+AO_load(const volatile AO_t *addr) -+{ -+ return __atomic_load_n(addr, __ATOMIC_RELAXED); -+} -+#define AO_HAVE_load -+ -+AO_INLINE AO_t -+AO_load_acquire(const volatile AO_t *addr) -+{ -+ return __atomic_load_n(addr, __ATOMIC_ACQUIRE); -+} -+#define AO_HAVE_load_acquire -+ -+/* load_full is generalized using load and nop_full, so that */ -+/* load_read is defined using load and nop_read. */ -+/* store_full definition is omitted similar to load_full reason. */ -+ -+AO_INLINE void -+AO_store(volatile AO_t *addr, AO_t value) -+{ -+ __atomic_store_n(addr, value, __ATOMIC_RELAXED); -+} -+#define AO_HAVE_store -+ -+AO_INLINE void -+AO_store_release(volatile AO_t *addr, AO_t value) -+{ -+ __atomic_store_n(addr, value, __ATOMIC_RELEASE); -+} -+#define AO_HAVE_store_release -+ -+AO_INLINE AO_t -+AO_fetch_compare_and_swap(volatile AO_t *addr, -+ AO_t old_val, AO_t new_val) -+{ -+ return __sync_val_compare_and_swap(addr, old_val, new_val -+ /* empty protection list */); -+} -+#define AO_HAVE_fetch_compare_and_swap -+ -+/* TODO: Add CAS _acquire/release/full primitives. */ -+ -+#ifndef AO_GENERALIZE_ASM_BOOL_CAS -+ AO_INLINE int -+ AO_compare_and_swap(volatile AO_t *addr, -+ AO_t old_val, AO_t new_val) -+ { -+ return __sync_bool_compare_and_swap(addr, old_val, new_val -+ /* empty protection list */); -+ } -+# define AO_HAVE_compare_and_swap -+#endif /* !AO_GENERALIZE_ASM_BOOL_CAS */ -Index: libatomic_ops/src/atomic_ops/sysdeps/gcc/generic.h -=================================================================== ---- /dev/null -+++ libatomic_ops/src/atomic_ops/sysdeps/gcc/generic.h -@@ -0,0 +1,154 @@ -+/* -+ * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. -+ * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved. -+ * Copyright (c) 2003-2011 Hewlett-Packard Development Company, L.P. -+ * -+ * -+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED -+ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. -+ * -+ * Permission is hereby granted to use or copy this program -+ * for any purpose, provided the above notices are retained on all copies. -+ * Permission to modify the code and to distribute modified code is granted, -+ * provided the above notices are retained, and a notice that the code was -+ * modified is included with the above copyright notice. -+ * -+ */ -+ -+/* The following implementation assumes GCC 4.7 or later. */ -+/* For the details, see GNU Manual, chapter 6.52 (Built-in functions */ -+/* for memory model aware atomic operations). */ -+ -+/* TODO: Include this file for other targets if gcc 4.7+ */ -+ -+#ifdef AO_UNIPROCESSOR -+ /* If only a single processor (core) is used, AO_UNIPROCESSOR could */ -+ /* be defined by the client to avoid unnecessary memory barrier. */ -+ AO_INLINE void -+ AO_nop_full(void) -+ { -+ AO_compiler_barrier(); -+ } -+# define AO_HAVE_nop_full -+ -+#else -+ AO_INLINE void -+ AO_nop_read(void) -+ { -+ __atomic_thread_fence(__ATOMIC_ACQUIRE); -+ } -+# define AO_HAVE_nop_read -+ -+# ifndef AO_HAVE_nop_write -+ AO_INLINE void -+ AO_nop_write(void) -+ { -+ __atomic_thread_fence(__ATOMIC_RELEASE); -+ } -+# define AO_HAVE_nop_write -+# endif -+ -+ AO_INLINE void -+ AO_nop_full(void) -+ { -+ /* __sync_synchronize() could be used instead. */ -+ __atomic_thread_fence(__ATOMIC_SEQ_CST); -+ } -+# define AO_HAVE_nop_full -+#endif /* !AO_UNIPROCESSOR */ -+ -+#include "generic-small.h" -+ -+#ifndef AO_PREFER_GENERALIZED -+# include "generic-arithm.h" -+ -+ AO_INLINE AO_TS_VAL_t -+ AO_test_and_set(volatile AO_TS_t *addr) -+ { -+ return (AO_TS_VAL_t)__atomic_test_and_set(addr, __ATOMIC_RELAXED); -+ } -+# define AO_HAVE_test_and_set -+ -+ AO_INLINE AO_TS_VAL_t -+ AO_test_and_set_acquire(volatile AO_TS_t *addr) -+ { -+ return (AO_TS_VAL_t)__atomic_test_and_set(addr, __ATOMIC_ACQUIRE); -+ } -+# define AO_HAVE_test_and_set_acquire -+ -+ AO_INLINE AO_TS_VAL_t -+ AO_test_and_set_release(volatile AO_TS_t *addr) -+ { -+ return (AO_TS_VAL_t)__atomic_test_and_set(addr, __ATOMIC_RELEASE); -+ } -+# define AO_HAVE_test_and_set_release -+ -+ AO_INLINE AO_TS_VAL_t -+ AO_test_and_set_full(volatile AO_TS_t *addr) -+ { -+ return (AO_TS_VAL_t)__atomic_test_and_set(addr, __ATOMIC_SEQ_CST); -+ } -+# define AO_HAVE_test_and_set_full -+#endif /* !AO_PREFER_GENERALIZED */ -+ -+#ifdef AO_HAVE_DOUBLE_PTR_STORAGE -+ -+# ifndef AO_HAVE_double_load -+ AO_INLINE AO_double_t -+ AO_double_load(const volatile AO_double_t *addr) -+ { -+ AO_double_t result; -+ -+ result.AO_whole = __atomic_load_n(&addr->AO_whole, __ATOMIC_RELAXED); -+ return result; -+ } -+# define AO_HAVE_double_load -+# endif -+ -+# ifndef AO_HAVE_double_load_acquire -+ AO_INLINE AO_double_t -+ AO_double_load_acquire(const volatile AO_double_t *addr) -+ { -+ AO_double_t result; -+ -+ result.AO_whole = __atomic_load_n(&addr->AO_whole, __ATOMIC_ACQUIRE); -+ return result; -+ } -+# define AO_HAVE_double_load_acquire -+# endif -+ -+# ifndef AO_HAVE_double_store -+ AO_INLINE void -+ AO_double_store(volatile AO_double_t *addr, AO_double_t value) -+ { -+ __atomic_store_n(&addr->AO_whole, value.AO_whole, __ATOMIC_RELAXED); -+ } -+# define AO_HAVE_double_store -+# endif -+ -+# ifndef AO_HAVE_double_store_release -+ AO_INLINE void -+ AO_double_store_release(volatile AO_double_t *addr, AO_double_t value) -+ { -+ __atomic_store_n(&addr->AO_whole, value.AO_whole, __ATOMIC_RELEASE); -+ } -+# define AO_HAVE_double_store_release -+# endif -+ -+# ifndef AO_HAVE_double_compare_and_swap -+ AO_INLINE int -+ AO_double_compare_and_swap(volatile AO_double_t *addr, -+ AO_double_t old_val, AO_double_t new_val) -+ { -+ return (int)__atomic_compare_exchange_n(&addr->AO_whole, -+ &old_val.AO_whole /* p_expected */, -+ new_val.AO_whole /* desired */, -+ 0 /* is_weak: false */, -+ __ATOMIC_RELAXED /* success */, -+ __ATOMIC_RELAXED /* failure */); -+ } -+# define AO_HAVE_double_compare_and_swap -+# endif -+ -+ /* TODO: Add double CAS _acquire/release/full primitives. */ -+#endif /* AO_HAVE_DOUBLE_PTR_STORAGE */ -Index: libatomic_ops/src/atomic_ops/sysdeps/standard_ao_double_t.h -=================================================================== ---- libatomic_ops/src/atomic_ops/sysdeps/standard_ao_double_t.h.orig -+++ libatomic_ops/src/atomic_ops/sysdeps/standard_ao_double_t.h -@@ -11,6 +11,8 @@ - typedef __m128 double_ptr_storage; - #elif defined(_WIN32) && !defined(__GNUC__) - typedef unsigned __int64 double_ptr_storage; -+#elif defined(__aarch64__) -+ typedef unsigned __int128 double_ptr_storage; - #else - typedef unsigned long long double_ptr_storage; - #endif