d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge CK as of commit 255a47553aa5e8d0bb5f8eec63acac7f4c25a6d8, mostly

Browse Source 
to make sure we don't use any FP instruction.
This commit is contained in:
Olivier Houchard 2016-12-30 18:23:58 +00:00
commit 8f87df16d4
11 changed files with 743 additions and 380 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
sys/contrib/ck/FREEBSD-Xlist
View File

@ -8,3 +8,4 @@
*/regressions
*/tools
*/include/ck_md.h.in
*/src/Makefile.in

4
sys/contrib/ck/include/ck_md.h
View File

@ -49,6 +49,10 @@
#define CK_MD_VMA_BITS_UNKNOWN
#endif /* CK_MD_VMA_BITS_UNKNOWN */
#ifndef CK_PR_DISABLE_DOUBLE
#define CK_PR_DISABLE_DOUBLE
#endif /* CK_PR_DISABLE_DOUBLE */
#ifndef CK_MD_RMO
#define CK_MD_RMO
#endif /* CK_MD_RMO */

24
sys/contrib/ck/include/ck_pr.h
View File

@ -173,7 +173,9 @@ ck_pr_rfo(const void *m)
#define ck_pr_store_ptr(DST, VAL) CK_PR_STORE_SAFE((DST), (VAL), ptr)
#define ck_pr_store_char(DST, VAL) CK_PR_STORE_SAFE((DST), (VAL), char)
#ifndef CK_PR_DISABLE_DOUBLE
#define ck_pr_store_double(DST, VAL) CK_PR_STORE_SAFE((DST), (VAL), double)
#endif
#define ck_pr_store_uint(DST, VAL) CK_PR_STORE_SAFE((DST), (VAL), uint)
#define ck_pr_store_int(DST, VAL) CK_PR_STORE_SAFE((DST), (VAL), int)
#define ck_pr_store_32(DST, VAL) CK_PR_STORE_SAFE((DST), (VAL), 32)
@ -191,7 +193,9 @@ ck_pr_rfo(const void *m)
#define CK_PR_LOAD_SAFE(SRC, TYPE) ck_pr_md_load_##TYPE((SRC))
#define ck_pr_load_char(SRC) CK_PR_LOAD_SAFE((SRC), char)
#ifndef CK_PR_DISABLE_DOUBLE
#define ck_pr_load_double(SRC) CK_PR_LOAD_SAFE((SRC), double)
#endif
#define ck_pr_load_uint(SRC) CK_PR_LOAD_SAFE((SRC), uint)
#define ck_pr_load_int(SRC) CK_PR_LOAD_SAFE((SRC), int)
#define ck_pr_load_32(SRC) CK_PR_LOAD_SAFE((SRC), 32)
@ -279,7 +283,8 @@ CK_PR_BIN_S(or, int, int, |)
#endif /* CK_F_PR_LOAD_INT && CK_F_PR_CAS_INT_VALUE */
#if defined(CK_F_PR_LOAD_DOUBLE) && defined(CK_F_PR_CAS_DOUBLE_VALUE)
#if defined(CK_F_PR_LOAD_DOUBLE) && defined(CK_F_PR_CAS_DOUBLE_VALUE) && \
!defined(CK_PR_DISABLE_DOUBLE)
#ifndef CK_F_PR_ADD_DOUBLE
#define CK_F_PR_ADD_DOUBLE
@ -291,7 +296,7 @@ CK_PR_BIN_S(add, double, double, +)
CK_PR_BIN_S(sub, double, double, -)
#endif /* CK_F_PR_SUB_DOUBLE */
#endif /* CK_F_PR_LOAD_DOUBLE && CK_F_PR_CAS_DOUBLE_VALUE */
#endif /* CK_F_PR_LOAD_DOUBLE && CK_F_PR_CAS_DOUBLE_VALUE && !CK_PR_DISABLE_DOUBLE */
#if defined(CK_F_PR_LOAD_UINT) && defined(CK_F_PR_CAS_UINT_VALUE)
@ -679,7 +684,8 @@ CK_PR_UNARY_Z_S(dec, int, int, -, 1)
#endif /* CK_F_PR_LOAD_INT && CK_F_PR_CAS_INT_VALUE */
#if defined(CK_F_PR_LOAD_DOUBLE) && defined(CK_F_PR_CAS_DOUBLE_VALUE)
#if defined(CK_F_PR_LOAD_DOUBLE) && defined(CK_F_PR_CAS_DOUBLE_VALUE) && \
!defined(CK_PR_DISABLE_DOUBLE)
#ifndef CK_F_PR_INC_DOUBLE
#define CK_F_PR_INC_DOUBLE
@ -691,7 +697,7 @@ CK_PR_UNARY_S(inc, add, double, double)
CK_PR_UNARY_S(dec, sub, double, double)
#endif /* CK_F_PR_DEC_DOUBLE */
#endif /* CK_F_PR_LOAD_DOUBLE && CK_F_PR_CAS_DOUBLE_VALUE */
#endif /* CK_F_PR_LOAD_DOUBLE && CK_F_PR_CAS_DOUBLE_VALUE && !CK_PR_DISABLE_DOUBLE */
#if defined(CK_F_PR_LOAD_UINT) && defined(CK_F_PR_CAS_UINT_VALUE)
@ -918,14 +924,15 @@ CK_PR_N_Z_S(int, int)
#endif /* CK_F_PR_LOAD_INT && CK_F_PR_CAS_INT_VALUE */
#if defined(CK_F_PR_LOAD_DOUBLE) && defined(CK_F_PR_CAS_DOUBLE_VALUE)
#if defined(CK_F_PR_LOAD_DOUBLE) && defined(CK_F_PR_CAS_DOUBLE_VALUE) && \
!defined(CK_PR_DISABLE_DOUBLE)
#ifndef CK_F_PR_NEG_DOUBLE
#define CK_F_PR_NEG_DOUBLE
CK_PR_N_S(neg, double, double, -)
#endif /* CK_F_PR_NEG_DOUBLE */
#endif /* CK_F_PR_LOAD_DOUBLE && CK_F_PR_CAS_DOUBLE_VALUE */
#endif /* CK_F_PR_LOAD_DOUBLE && CK_F_PR_CAS_DOUBLE_VALUE && !CK_PR_DISABLE_DOUBLE */
#if defined(CK_F_PR_LOAD_UINT) && defined(CK_F_PR_CAS_UINT_VALUE)
@ -1109,7 +1116,8 @@ CK_PR_FAS_S(int, int)
#endif /* CK_F_PR_LOAD_INT && CK_F_PR_CAS_INT_VALUE */
#if defined(CK_F_PR_LOAD_DOUBLE) && defined(CK_F_PR_CAS_DOUBLE_VALUE)
#if defined(CK_F_PR_LOAD_DOUBLE) && defined(CK_F_PR_CAS_DOUBLE_VALUE) && \
!defined(CK_PR_DISABLE_DOUBLE)
#ifndef CK_F_PR_FAA_DOUBLE
#define CK_F_PR_FAA_DOUBLE
@ -1121,7 +1129,7 @@ CK_PR_FAA_S(double, double)
CK_PR_FAS_S(double, double)
#endif /* CK_F_PR_FAS_DOUBLE */
#endif /* CK_F_PR_LOAD_DOUBLE && CK_F_PR_CAS_DOUBLE_VALUE */
#endif /* CK_F_PR_LOAD_DOUBLE && CK_F_PR_CAS_DOUBLE_VALUE && !CK_PR_DISABLE_DOUBLE */
#if defined(CK_F_PR_LOAD_UINT) && defined(CK_F_PR_CAS_UINT_VALUE)

351
sys/contrib/ck/include/gcc/aarch64/ck_pr.h
View File

@ -124,7 +124,9 @@ CK_PR_LOAD_S(uint, unsigned int, "ldr")
CK_PR_LOAD_S(int, int, "ldr")
CK_PR_LOAD_S(short, short, "ldrh")
CK_PR_LOAD_S(char, char, "ldrb")
#ifndef CK_PR_DISABLE_DOUBLE
CK_PR_LOAD_S_64(double, double, "ldr")
#endif
#undef CK_PR_LOAD_S
#undef CK_PR_LOAD_S_64
@ -167,326 +169,59 @@ CK_PR_STORE_S(uint, unsigned int, "str")
CK_PR_STORE_S(int, int, "str")
CK_PR_STORE_S(short, short, "strh")
CK_PR_STORE_S(char, char, "strb")
#ifndef CK_PR_DISABLE_DOUBLE
CK_PR_STORE_S_64(double, double, "str")
#endif
#undef CK_PR_STORE_S
#undef CK_PR_STORE_S_64
#undef CK_PR_STORE
#undef CK_PR_STORE_64
CK_CC_INLINE static bool
ck_pr_cas_64_2_value(uint64_t target[2], uint64_t compare[2], uint64_t set[2], uint64_t value[2])
{
uint64_t tmp1, tmp2;
__asm__ __volatile__("1:"
"ldxp %0, %1, [%4];"
"mov %2, %0;"
"mov %3, %1;"
"eor %0, %0, %5;"
"eor %1, %1, %6;"
"orr %1, %0, %1;"
"mov %w0, #0;"
"cbnz %1, 2f;"
"stxp %w0, %7, %8, [%4];"
"cbnz %w0, 1b;"
"mov %w0, #1;"
"2:"
: "=&r" (tmp1), "=&r" (tmp2), "=&r" (value[0]), "=&r" (value[1])
: "r" (target), "r" (compare[0]), "r" (compare[1]), "r" (set[0]), "r" (set[1]));
#ifdef CK_MD_LSE_ENABLE
#include "ck_pr_lse.h"
#else
#include "ck_pr_llsc.h"
#endif
return (tmp1);
}
/*
* ck_pr_neg_*() functions can only be implemented via LL/SC, as there are no
* LSE alternatives.
*/
#define CK_PR_NEG(N, M, T, W, R) \
CK_CC_INLINE static void \
ck_pr_neg_##N(M *target) \
{ \
T previous = 0; \
T tmp = 0; \
__asm__ __volatile__("1:" \
"ldxr" W " %" R "0, [%2];" \
"neg %" R "0, %" R "0;" \
"stxr" W " %w1, %" R "0, [%2];" \
"cbnz %w1, 1b;" \
: "=&r" (previous), \
"=&r" (tmp) \
: "r" (target) \
: "memory", "cc"); \
return; \
}
CK_CC_INLINE static bool
ck_pr_cas_ptr_2_value(void *target, void *compare, void *set, void *value)
{
return (ck_pr_cas_64_2_value(CK_CPP_CAST(uint64_t *, target),
CK_CPP_CAST(uint64_t *, compare),
CK_CPP_CAST(uint64_t *, set),
CK_CPP_CAST(uint64_t *, value)));
}
CK_PR_NEG(ptr, void, void *, "", "")
CK_PR_NEG(64, uint64_t, uint64_t, "", "")
CK_CC_INLINE static bool
ck_pr_cas_64_2(uint64_t target[2], uint64_t compare[2], uint64_t set[2])
{
uint64_t tmp1, tmp2;
__asm__ __volatile__("1:"
"ldxp %0, %1, [%2];"
"eor %0, %0, %3;"
"eor %1, %1, %4;"
"orr %1, %0, %1;"
"mov %w0, #0;"
"cbnz %1, 2f;"
"stxp %w0, %5, %6, [%2];"
"cbnz %w0, 1b;"
"mov %w0, #1;"
"2:"
: "=&r" (tmp1), "=&r" (tmp2)
: "r" (target), "r" (compare[0]), "r" (compare[1]), "r" (set[0]), "r" (set[1]));
#define CK_PR_NEG_S(S, T, W) \
CK_PR_NEG(S, T, T, W, "w") \
return (tmp1);
}
CK_CC_INLINE static bool
ck_pr_cas_ptr_2(void *target, void *compare, void *set)
{
return (ck_pr_cas_64_2(CK_CPP_CAST(uint64_t *, target),
CK_CPP_CAST(uint64_t *, compare),
CK_CPP_CAST(uint64_t *, set)));
}
CK_PR_NEG_S(32, uint32_t, "")
CK_PR_NEG_S(uint, unsigned int, "")
CK_PR_NEG_S(int, int, "")
CK_PR_NEG_S(16, uint16_t, "h")
CK_PR_NEG_S(8, uint8_t, "b")
CK_PR_NEG_S(short, short, "h")
CK_PR_NEG_S(char, char, "b")
#define CK_PR_CAS(N, M, T, W, R) \
CK_CC_INLINE static bool \
ck_pr_cas_##N##_value(M *target, T compare, T set, M *value) \
{ \
T previous; \
T tmp; \
__asm__ __volatile__("1:" \
"ldxr" W " %" R "0, [%2];" \
"cmp %" R "0, %" R "4;" \
"b.ne 2f;" \
"stxr" W " %w1, %" R "3, [%2];" \
"cbnz %w1, 1b;" \
"2:" \
: "=&r" (previous), \
"=&r" (tmp) \
: "r" (target), \
"r" (set), \
"r" (compare) \
: "memory", "cc"); \
*(T *)value = previous; \
return (previous == compare); \
} \
CK_CC_INLINE static bool \
ck_pr_cas_##N(M *target, T compare, T set) \
{ \
T previous; \
T tmp; \
__asm__ __volatile__( \
"1:" \
"ldxr" W " %" R "0, [%2];" \
"cmp %" R "0, %" R "4;" \
"b.ne 2f;" \
"stxr" W " %w1, %" R "3, [%2];" \
"cbnz %w1, 1b;" \
"2:" \
: "=&r" (previous), \
"=&r" (tmp) \
: "r" (target), \
"r" (set), \
"r" (compare) \
: "memory", "cc"); \
return (previous == compare); \
}
CK_PR_CAS(ptr, void, void *, "", "")
#define CK_PR_CAS_S(N, M, W, R) CK_PR_CAS(N, M, M, W, R)
CK_PR_CAS_S(64, uint64_t, "", "")
CK_PR_CAS_S(double, double, "", "")
CK_PR_CAS_S(32, uint32_t, "", "w")
CK_PR_CAS_S(uint, unsigned int, "", "w")
CK_PR_CAS_S(int, int, "", "w")
CK_PR_CAS_S(16, uint16_t, "h", "w")
CK_PR_CAS_S(8, uint8_t, "b", "w")
CK_PR_CAS_S(short, short, "h", "w")
CK_PR_CAS_S(char, char, "b", "w")
#undef CK_PR_CAS_S
#undef CK_PR_CAS
#define CK_PR_FAS(N, M, T, W, R) \
CK_CC_INLINE static T \
ck_pr_fas_##N(M *target, T v) \
{ \
T previous; \
T tmp; \
__asm__ __volatile__("1:" \
"ldxr" W " %" R "0, [%2];" \
"stxr" W " %w1, %" R "3, [%2];"\
"cbnz %w1, 1b;" \
: "=&r" (previous), \
"=&r" (tmp) \
: "r" (target), \
"r" (v) \
: "memory", "cc"); \
return (previous); \
}
CK_PR_FAS(64, uint64_t, uint64_t, "", "")
CK_PR_FAS(32, uint32_t, uint32_t, "", "w")
CK_PR_FAS(ptr, void, void *, "", "")
CK_PR_FAS(int, int, int, "", "w")
CK_PR_FAS(uint, unsigned int, unsigned int, "", "w")
CK_PR_FAS(16, uint16_t, uint16_t, "h", "w")
CK_PR_FAS(8, uint8_t, uint8_t, "b", "w")
CK_PR_FAS(short, short, short, "h", "w")
CK_PR_FAS(char, char, char, "b", "w")
#undef CK_PR_FAS
#define CK_PR_UNARY(O, N, M, T, I, W, R) \
CK_CC_INLINE static void \
ck_pr_##O##_##N(M *target) \
{ \
T previous = 0; \
T tmp = 0; \
__asm__ __volatile__("1:" \
"ldxr" W " %" R "0, [%2];" \
I ";" \
"stxr" W " %w1, %" R "0, [%2];" \
"cbnz %w1, 1b;" \
: "=&r" (previous), \
"=&r" (tmp) \
: "r" (target) \
: "memory", "cc"); \
return; \
}
CK_PR_UNARY(inc, ptr, void, void *, "add %0, %0, #1", "", "")
CK_PR_UNARY(dec, ptr, void, void *, "sub %0, %0, #1", "", "")
CK_PR_UNARY(not, ptr, void, void *, "mvn %0, %0", "", "")
CK_PR_UNARY(neg, ptr, void, void *, "neg %0, %0", "", "")
CK_PR_UNARY(inc, 64, uint64_t, uint64_t, "add %0, %0, #1", "", "")
CK_PR_UNARY(dec, 64, uint64_t, uint64_t, "sub %0, %0, #1", "", "")
CK_PR_UNARY(not, 64, uint64_t, uint64_t, "mvn %0, %0", "", "")
CK_PR_UNARY(neg, 64, uint64_t, uint64_t, "neg %0, %0", "", "")
#define CK_PR_UNARY_S(S, T, W) \
CK_PR_UNARY(inc, S, T, T, "add %w0, %w0, #1", W, "w") \
CK_PR_UNARY(dec, S, T, T, "sub %w0, %w0, #1", W, "w") \
CK_PR_UNARY(not, S, T, T, "mvn %w0, %w0", W, "w") \
CK_PR_UNARY(neg, S, T, T, "neg %w0, %w0", W, "w") \
CK_PR_UNARY_S(32, uint32_t, "")
CK_PR_UNARY_S(uint, unsigned int, "")
CK_PR_UNARY_S(int, int, "")
CK_PR_UNARY_S(16, uint16_t, "h")
CK_PR_UNARY_S(8, uint8_t, "b")
CK_PR_UNARY_S(short, short, "h")
CK_PR_UNARY_S(char, char, "b")
#undef CK_PR_UNARY_S
#undef CK_PR_UNARY
#define CK_PR_BINARY(O, N, M, T, I, W, R) \
CK_CC_INLINE static void \
ck_pr_##O##_##N(M *target, T delta) \
{ \
T previous; \
T tmp; \
__asm__ __volatile__("1:" \
"ldxr" W " %" R "0, [%2];"\
I " %" R "0, %" R "0, %" R "3;" \
"stxr" W " %w1, %" R "0, [%2];" \
"cbnz %w1, 1b;" \
: "=&r" (previous), \
"=&r" (tmp) \
: "r" (target), \
"r" (delta) \
: "memory", "cc"); \
return; \
}
CK_PR_BINARY(and, ptr, void, uintptr_t, "and", "", "")
CK_PR_BINARY(add, ptr, void, uintptr_t, "add", "", "")
CK_PR_BINARY(or, ptr, void, uintptr_t, "orr", "", "")
CK_PR_BINARY(sub, ptr, void, uintptr_t, "sub", "", "")
CK_PR_BINARY(xor, ptr, void, uintptr_t, "eor", "", "")
CK_PR_BINARY(and, 64, uint64_t, uint64_t, "and", "", "")
CK_PR_BINARY(add, 64, uint64_t, uint64_t, "add", "", "")
CK_PR_BINARY(or, 64, uint64_t, uint64_t, "orr", "", "")
CK_PR_BINARY(sub, 64, uint64_t, uint64_t, "sub", "", "")
CK_PR_BINARY(xor, 64, uint64_t, uint64_t, "eor", "", "")
#define CK_PR_BINARY_S(S, T, W) \
CK_PR_BINARY(and, S, T, T, "and", W, "w") \
CK_PR_BINARY(add, S, T, T, "add", W, "w") \
CK_PR_BINARY(or, S, T, T, "orr", W, "w") \
CK_PR_BINARY(sub, S, T, T, "sub", W, "w") \
CK_PR_BINARY(xor, S, T, T, "eor", W, "w")
CK_PR_BINARY_S(32, uint32_t, "")
CK_PR_BINARY_S(uint, unsigned int, "")
CK_PR_BINARY_S(int, int, "")
CK_PR_BINARY_S(16, uint16_t, "h")
CK_PR_BINARY_S(8, uint8_t, "b")
CK_PR_BINARY_S(short, short, "h")
CK_PR_BINARY_S(char, char, "b")
#undef CK_PR_BINARY_S
#undef CK_PR_BINARY
CK_CC_INLINE static void *
ck_pr_faa_ptr(void *target, uintptr_t delta)
{
uintptr_t previous, r, tmp;
__asm__ __volatile__("1:"
"ldxr %0, [%3];"
"add %1, %4, %0;"
"stxr %w2, %1, [%3];"
"cbnz %w2, 1b;"
: "=&r" (previous),
"=&r" (r),
"=&r" (tmp)
: "r" (target),
"r" (delta)
: "memory", "cc");
return (void *)(previous);
}
CK_CC_INLINE static uint64_t
ck_pr_faa_64(uint64_t *target, uint64_t delta)
{
uint64_t previous, r, tmp;
__asm__ __volatile__("1:"
"ldxr %0, [%3];"
"add %1, %4, %0;"
"stxr %w2, %1, [%3];"
"cbnz %w2, 1b;"
: "=&r" (previous),
"=&r" (r),
"=&r" (tmp)
: "r" (target),
"r" (delta)
: "memory", "cc");
return (previous);
}
#define CK_PR_FAA(S, T, W) \
CK_CC_INLINE static T \
ck_pr_faa_##S(T *target, T delta) \
{ \
T previous, r, tmp; \
__asm__ __volatile__("1:" \
"ldxr" W " %w0, [%3];" \
"add %w1, %w4, %w0;" \
"stxr" W " %w2, %w1, [%3];" \
"cbnz %w2, 1b;" \
: "=&r" (previous), \
"=&r" (r), \
"=&r" (tmp) \
: "r" (target), \
"r" (delta) \
: "memory", "cc"); \
return (previous); \
}
CK_PR_FAA(32, uint32_t, "")
CK_PR_FAA(uint, unsigned int, "")
CK_PR_FAA(int, int, "")
CK_PR_FAA(16, uint16_t, "h")
CK_PR_FAA(8, uint8_t, "b")
CK_PR_FAA(short, short, "h")
CK_PR_FAA(char, char, "b")
#undef CK_PR_FAA
#undef CK_PR_NEG_S
#undef CK_PR_NEG
#endif /* CK_PR_AARCH64_H */

352
sys/contrib/ck/include/gcc/aarch64/ck_pr_llsc.h Normal file
View File

@ -0,0 +1,352 @@
/*
* Copyright 2009-2016 Samy Al Bahra.
* Copyright 2013-2016 Olivier Houchard.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#ifndef CK_PR_AARCH64_LLSC_H
#define CK_PR_AARCH64_LLSC_H
#ifndef CK_PR_H
#error Do not include this file directly, use ck_pr.h
#endif
CK_CC_INLINE static bool
ck_pr_cas_64_2_value(uint64_t target[2], uint64_t compare[2], uint64_t set[2], uint64_t value[2])
{
uint64_t tmp1, tmp2;
__asm__ __volatile__("1:"
"ldxp %0, %1, [%4];"
"mov %2, %0;"
"mov %3, %1;"
"eor %0, %0, %5;"
"eor %1, %1, %6;"
"orr %1, %0, %1;"
"mov %w0, #0;"
"cbnz %1, 2f;"
"stxp %w0, %7, %8, [%4];"
"cbnz %w0, 1b;"
"mov %w0, #1;"
"2:"
: "=&r" (tmp1), "=&r" (tmp2), "=&r" (value[0]), "=&r" (value[1])
: "r" (target), "r" (compare[0]), "r" (compare[1]), "r" (set[0]), "r" (set[1])
: "cc", "memory");
return (tmp1);
}
CK_CC_INLINE static bool
ck_pr_cas_ptr_2_value(void *target, void *compare, void *set, void *value)
{
return (ck_pr_cas_64_2_value(CK_CPP_CAST(uint64_t *, target),
CK_CPP_CAST(uint64_t *, compare),
CK_CPP_CAST(uint64_t *, set),
CK_CPP_CAST(uint64_t *, value)));
}
CK_CC_INLINE static bool
ck_pr_cas_64_2(uint64_t target[2], uint64_t compare[2], uint64_t set[2])
{
uint64_t tmp1, tmp2;
__asm__ __volatile__("1:"
"ldxp %0, %1, [%2];"
"eor %0, %0, %3;"
"eor %1, %1, %4;"
"orr %1, %0, %1;"
"mov %w0, #0;"
"cbnz %1, 2f;"
"stxp %w0, %5, %6, [%2];"
"cbnz %w0, 1b;"
"mov %w0, #1;"
"2:"
: "=&r" (tmp1), "=&r" (tmp2)
: "r" (target), "r" (compare[0]), "r" (compare[1]), "r" (set[0]), "r" (set[1])
: "cc", "memory");
return (tmp1);
}
CK_CC_INLINE static bool
ck_pr_cas_ptr_2(void *target, void *compare, void *set)
{
return (ck_pr_cas_64_2(CK_CPP_CAST(uint64_t *, target),
CK_CPP_CAST(uint64_t *, compare),
CK_CPP_CAST(uint64_t *, set)));
}
#define CK_PR_CAS(N, M, T, W, R) \
CK_CC_INLINE static bool \
ck_pr_cas_##N##_value(M *target, T compare, T set, M *value) \
{ \
T previous; \
T tmp; \
__asm__ __volatile__("1:" \
"ldxr" W " %" R "0, [%2];" \
"cmp %" R "0, %" R "4;" \
"b.ne 2f;" \
"stxr" W " %w1, %" R "3, [%2];" \
"cbnz %w1, 1b;" \
"2:" \
: "=&r" (previous), \
"=&r" (tmp) \
: "r" (target), \
"r" (set), \
"r" (compare) \
: "memory", "cc"); \
*(T *)value = previous; \
return (previous == compare); \
} \
CK_CC_INLINE static bool \
ck_pr_cas_##N(M *target, T compare, T set) \
{ \
T previous; \
T tmp; \
__asm__ __volatile__( \
"1:" \
"ldxr" W " %" R "0, [%2];" \
"cmp %" R "0, %" R "4;" \
"b.ne 2f;" \
"stxr" W " %w1, %" R "3, [%2];" \
"cbnz %w1, 1b;" \
"2:" \
: "=&r" (previous), \
"=&r" (tmp) \
: "r" (target), \
"r" (set), \
"r" (compare) \
: "memory", "cc"); \
return (previous == compare); \
}
CK_PR_CAS(ptr, void, void *, "", "")
#define CK_PR_CAS_S(N, M, W, R) CK_PR_CAS(N, M, M, W, R)
CK_PR_CAS_S(64, uint64_t, "", "")
#ifndef CK_PR_DISABLE_DOUBLE
CK_PR_CAS_S(double, double, "", "")
#endif
CK_PR_CAS_S(32, uint32_t, "", "w")
CK_PR_CAS_S(uint, unsigned int, "", "w")
CK_PR_CAS_S(int, int, "", "w")
CK_PR_CAS_S(16, uint16_t, "h", "w")
CK_PR_CAS_S(8, uint8_t, "b", "w")
CK_PR_CAS_S(short, short, "h", "w")
CK_PR_CAS_S(char, char, "b", "w")
#undef CK_PR_CAS_S
#undef CK_PR_CAS
#define CK_PR_FAS(N, M, T, W, R) \
CK_CC_INLINE static T \
ck_pr_fas_##N(M *target, T v) \
{ \
T previous; \
T tmp; \
__asm__ __volatile__("1:" \
"ldxr" W " %" R "0, [%2];" \
"stxr" W " %w1, %" R "3, [%2];"\
"cbnz %w1, 1b;" \
: "=&r" (previous), \
"=&r" (tmp) \
: "r" (target), \
"r" (v) \
: "memory", "cc"); \
return (previous); \
}
CK_PR_FAS(64, uint64_t, uint64_t, "", "")
CK_PR_FAS(32, uint32_t, uint32_t, "", "w")
CK_PR_FAS(ptr, void, void *, "", "")
CK_PR_FAS(int, int, int, "", "w")
CK_PR_FAS(uint, unsigned int, unsigned int, "", "w")
CK_PR_FAS(16, uint16_t, uint16_t, "h", "w")
CK_PR_FAS(8, uint8_t, uint8_t, "b", "w")
CK_PR_FAS(short, short, short, "h", "w")
CK_PR_FAS(char, char, char, "b", "w")
#undef CK_PR_FAS
#define CK_PR_UNARY(O, N, M, T, I, W, R) \
CK_CC_INLINE static void \
ck_pr_##O##_##N(M *target) \
{ \
T previous = 0; \
T tmp = 0; \
__asm__ __volatile__("1:" \
"ldxr" W " %" R "0, [%2];" \
I ";" \
"stxr" W " %w1, %" R "0, [%2];" \
"cbnz %w1, 1b;" \
: "=&r" (previous), \
"=&r" (tmp) \
: "r" (target) \
: "memory", "cc"); \
return; \
}
CK_PR_UNARY(inc, ptr, void, void *, "add %0, %0, #1", "", "")
CK_PR_UNARY(dec, ptr, void, void *, "sub %0, %0, #1", "", "")
CK_PR_UNARY(not, ptr, void, void *, "mvn %0, %0", "", "")
CK_PR_UNARY(inc, 64, uint64_t, uint64_t, "add %0, %0, #1", "", "")
CK_PR_UNARY(dec, 64, uint64_t, uint64_t, "sub %0, %0, #1", "", "")
CK_PR_UNARY(not, 64, uint64_t, uint64_t, "mvn %0, %0", "", "")
#define CK_PR_UNARY_S(S, T, W) \
CK_PR_UNARY(inc, S, T, T, "add %w0, %w0, #1", W, "w") \
CK_PR_UNARY(dec, S, T, T, "sub %w0, %w0, #1", W, "w") \
CK_PR_UNARY(not, S, T, T, "mvn %w0, %w0", W, "w") \
CK_PR_UNARY_S(32, uint32_t, "")
CK_PR_UNARY_S(uint, unsigned int, "")
CK_PR_UNARY_S(int, int, "")
CK_PR_UNARY_S(16, uint16_t, "h")
CK_PR_UNARY_S(8, uint8_t, "b")
CK_PR_UNARY_S(short, short, "h")
CK_PR_UNARY_S(char, char, "b")
#undef CK_PR_UNARY_S
#undef CK_PR_UNARY
#define CK_PR_BINARY(O, N, M, T, I, W, R) \
CK_CC_INLINE static void \
ck_pr_##O##_##N(M *target, T delta) \
{ \
T previous; \
T tmp; \
__asm__ __volatile__("1:" \
"ldxr" W " %" R "0, [%2];"\
I " %" R "0, %" R "0, %" R "3;" \
"stxr" W " %w1, %" R "0, [%2];" \
"cbnz %w1, 1b;" \
: "=&r" (previous), \
"=&r" (tmp) \
: "r" (target), \
"r" (delta) \
: "memory", "cc"); \
return; \
}
CK_PR_BINARY(and, ptr, void, uintptr_t, "and", "", "")
CK_PR_BINARY(add, ptr, void, uintptr_t, "add", "", "")
CK_PR_BINARY(or, ptr, void, uintptr_t, "orr", "", "")
CK_PR_BINARY(sub, ptr, void, uintptr_t, "sub", "", "")
CK_PR_BINARY(xor, ptr, void, uintptr_t, "eor", "", "")
CK_PR_BINARY(and, 64, uint64_t, uint64_t, "and", "", "")
CK_PR_BINARY(add, 64, uint64_t, uint64_t, "add", "", "")
CK_PR_BINARY(or, 64, uint64_t, uint64_t, "orr", "", "")
CK_PR_BINARY(sub, 64, uint64_t, uint64_t, "sub", "", "")
CK_PR_BINARY(xor, 64, uint64_t, uint64_t, "eor", "", "")
#define CK_PR_BINARY_S(S, T, W) \
CK_PR_BINARY(and, S, T, T, "and", W, "w") \
CK_PR_BINARY(add, S, T, T, "add", W, "w") \
CK_PR_BINARY(or, S, T, T, "orr", W, "w") \
CK_PR_BINARY(sub, S, T, T, "sub", W, "w") \
CK_PR_BINARY(xor, S, T, T, "eor", W, "w")
CK_PR_BINARY_S(32, uint32_t, "")
CK_PR_BINARY_S(uint, unsigned int, "")
CK_PR_BINARY_S(int, int, "")
CK_PR_BINARY_S(16, uint16_t, "h")
CK_PR_BINARY_S(8, uint8_t, "b")
CK_PR_BINARY_S(short, short, "h")
CK_PR_BINARY_S(char, char, "b")
#undef CK_PR_BINARY_S
#undef CK_PR_BINARY
CK_CC_INLINE static void *
ck_pr_faa_ptr(void *target, uintptr_t delta)
{
uintptr_t previous, r, tmp;
__asm__ __volatile__("1:"
"ldxr %0, [%3];"
"add %1, %4, %0;"
"stxr %w2, %1, [%3];"
"cbnz %w2, 1b;"
: "=&r" (previous),
"=&r" (r),
"=&r" (tmp)
: "r" (target),
"r" (delta)
: "memory", "cc");
return (void *)(previous);
}
CK_CC_INLINE static uint64_t
ck_pr_faa_64(uint64_t *target, uint64_t delta)
{
uint64_t previous, r, tmp;
__asm__ __volatile__("1:"
"ldxr %0, [%3];"
"add %1, %4, %0;"
"stxr %w2, %1, [%3];"
"cbnz %w2, 1b;"
: "=&r" (previous),
"=&r" (r),
"=&r" (tmp)
: "r" (target),
"r" (delta)
: "memory", "cc");
return (previous);
}
#define CK_PR_FAA(S, T, W) \
CK_CC_INLINE static T \
ck_pr_faa_##S(T *target, T delta) \
{ \
T previous, r, tmp; \
__asm__ __volatile__("1:" \
"ldxr" W " %w0, [%3];" \
"add %w1, %w4, %w0;" \
"stxr" W " %w2, %w1, [%3];" \
"cbnz %w2, 1b;" \
: "=&r" (previous), \
"=&r" (r), \
"=&r" (tmp) \
: "r" (target), \
"r" (delta) \
: "memory", "cc"); \
return (previous); \
}
CK_PR_FAA(32, uint32_t, "")
CK_PR_FAA(uint, unsigned int, "")
CK_PR_FAA(int, int, "")
CK_PR_FAA(16, uint16_t, "h")
CK_PR_FAA(8, uint8_t, "b")
CK_PR_FAA(short, short, "h")
CK_PR_FAA(char, char, "b")
#undef CK_PR_FAA
#endif /* CK_PR_AARCH64_LLSC_H */

298
sys/contrib/ck/include/gcc/aarch64/ck_pr_lse.h Normal file
View File

@ -0,0 +1,298 @@
/*
* Copyright 2009-2016 Samy Al Bahra.
* Copyright 2013-2016 Olivier Houchard.
* Copyright 2016 Alexey Kopytov.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#ifndef CK_PR_AARCH64_LSE_H
#define CK_PR_AARCH64_LSE_H
#ifndef CK_PR_H
#error Do not include this file directly, use ck_pr.h
#endif
CK_CC_INLINE static bool
ck_pr_cas_64_2_value(uint64_t target[2], uint64_t compare[2], uint64_t set[2], uint64_t value[2])
{
uint64_t tmp1;
uint64_t tmp2;
register uint64_t x0 __asm__ ("x0") = compare[0];
register uint64_t x1 __asm__ ("x1") = compare[1];
register uint64_t x2 __asm__ ("x2") = set[0];
register uint64_t x3 __asm__ ("x3") = set[1];
__asm__ __volatile__("casp %0, %1, %4, %5, [%6];"
"eor %2, %0, %7;"
"eor %3, %1, %8;"
"orr %2, %2, %3;"
: "+&r" (x0), "+&r" (x1), "=&r" (tmp1), "=&r" (tmp2)
: "r" (x2), "r" (x3), "r" (target), "r" (compare[0]), "r" (compare[1])
: "memory");
value[0] = x0;
value[1] = x1;
return (!!tmp1);
}
CK_CC_INLINE static bool
ck_pr_cas_ptr_2_value(void *target, void *compare, void *set, void *value)
{
return (ck_pr_cas_64_2_value(CK_CPP_CAST(uint64_t *, target),
CK_CPP_CAST(uint64_t *, compare),
CK_CPP_CAST(uint64_t *, set),
CK_CPP_CAST(uint64_t *, value)));
}
CK_CC_INLINE static bool
ck_pr_cas_64_2(uint64_t target[2], uint64_t compare[2], uint64_t set[2])
{
register uint64_t x0 __asm__ ("x0") = compare[0];
register uint64_t x1 __asm__ ("x1") = compare[1];
register uint64_t x2 __asm__ ("x2") = set[0];
register uint64_t x3 __asm__ ("x3") = set[1];
__asm__ __volatile__("casp %0, %1, %2, %3, [%4];"
"eor %0, %0, %5;"
"eor %1, %1, %6;"
"orr %0, %0, %1;"
: "+&r" (x0), "+&r" (x1)
: "r" (x2), "r" (x3), "r" (target), "r" (compare[0]), "r" (compare[1])
: "memory");
return (!!x0);
}
CK_CC_INLINE static bool
ck_pr_cas_ptr_2(void *target, void *compare, void *set)
{
return (ck_pr_cas_64_2(CK_CPP_CAST(uint64_t *, target),
CK_CPP_CAST(uint64_t *, compare),
CK_CPP_CAST(uint64_t *, set)));
}
#define CK_PR_CAS(N, M, T, W, R) \
CK_CC_INLINE static bool \
ck_pr_cas_##N##_value(M *target, T compare, T set, M *value) \
{ \
*(T *)value = compare; \
__asm__ __volatile__( \
"cas" W " %" R "0, %" R "2, [%1];" \
: "+&r" (*(T *)value) \
: "r" (target), \
"r" (set) \
: "memory"); \
return (*(T *)value == compare); \
} \
CK_CC_INLINE static bool \
ck_pr_cas_##N(M *target, T compare, T set) \
{ \
T previous = compare; \
__asm__ __volatile__( \
"cas" W " %" R "0, %" R "2, [%1];" \
: "+&r" (previous) \
: "r" (target), \
"r" (set) \
: "memory"); \
return (previous == compare); \
}
CK_PR_CAS(ptr, void, void *, "", "")
#define CK_PR_CAS_S(N, M, W, R) CK_PR_CAS(N, M, M, W, R)
CK_PR_CAS_S(64, uint64_t, "", "")
#ifndef CK_PR_DISABLE_DOUBLE
CK_PR_CAS_S(double, double, "", "")
#endif
CK_PR_CAS_S(32, uint32_t, "", "w")
CK_PR_CAS_S(uint, unsigned int, "", "w")
CK_PR_CAS_S(int, int, "", "w")
CK_PR_CAS_S(16, uint16_t, "h", "w")
CK_PR_CAS_S(8, uint8_t, "b", "w")
CK_PR_CAS_S(short, short, "h", "w")
CK_PR_CAS_S(char, char, "b", "w")
#undef CK_PR_CAS_S
#undef CK_PR_CAS
#define CK_PR_FAS(N, M, T, W, R) \
CK_CC_INLINE static T \
ck_pr_fas_##N(M *target, T v) \
{ \
T previous; \
__asm__ __volatile__( \
"swp" W " %" R "2, %" R "0, [%1];" \
: "=&r" (previous) \
: "r" (target), \
"r" (v) \
: "memory"); \
return (previous); \
}
CK_PR_FAS(64, uint64_t, uint64_t, "", "")
CK_PR_FAS(32, uint32_t, uint32_t, "", "w")
CK_PR_FAS(ptr, void, void *, "", "")
CK_PR_FAS(int, int, int, "", "w")
CK_PR_FAS(uint, unsigned int, unsigned int, "", "w")
CK_PR_FAS(16, uint16_t, uint16_t, "h", "w")
CK_PR_FAS(8, uint8_t, uint8_t, "b", "w")
CK_PR_FAS(short, short, short, "h", "w")
CK_PR_FAS(char, char, char, "b", "w")
#undef CK_PR_FAS
#define CK_PR_UNARY(O, N, M, T, I, W, R, S) \
CK_CC_INLINE static void \
ck_pr_##O##_##N(M *target) \
{ \
__asm__ __volatile__(I ";" \
"st" S W " " R "0, [%0];" \
: \
: "r" (target) \
: "x0", "memory"); \
return; \
}
CK_PR_UNARY(inc, ptr, void, void *, "mov x0, 1", "", "x", "add")
CK_PR_UNARY(dec, ptr, void, void *, "mov x0, -1", "", "x", "add")
CK_PR_UNARY(not, ptr, void, void *, "mov x0, -1", "", "x", "eor")
CK_PR_UNARY(inc, 64, uint64_t, uint64_t, "mov x0, 1", "", "x", "add")
CK_PR_UNARY(dec, 64, uint64_t, uint64_t, "mov x0, -1", "", "x", "add")
CK_PR_UNARY(not, 64, uint64_t, uint64_t, "mov x0, -1", "", "x", "eor")
#define CK_PR_UNARY_S(S, T, W) \
CK_PR_UNARY(inc, S, T, T, "mov w0, 1", W, "w", "add") \
CK_PR_UNARY(dec, S, T, T, "mov w0, -1", W, "w", "add") \
CK_PR_UNARY(not, S, T, T, "mov w0, -1", W, "w", "eor") \
CK_PR_UNARY_S(32, uint32_t, "")
CK_PR_UNARY_S(uint, unsigned int, "")
CK_PR_UNARY_S(int, int, "")
CK_PR_UNARY_S(16, uint16_t, "h")
CK_PR_UNARY_S(8, uint8_t, "b")
CK_PR_UNARY_S(short, short, "h")
CK_PR_UNARY_S(char, char, "b")
#undef CK_PR_UNARY_S
#undef CK_PR_UNARY
#define CK_PR_BINARY(O, N, M, T, S, W, R, I) \
CK_CC_INLINE static void \
ck_pr_##O##_##N(M *target, T delta) \
{ \
__asm__ __volatile__(I ";" \
"st" S W " %" R "0, [%1];" \
: "+&r" (delta) \
: "r" (target) \
: "memory"); \
return; \
}
CK_PR_BINARY(and, ptr, void, uintptr_t, "clr", "", "", "mvn %0, %0")
CK_PR_BINARY(add, ptr, void, uintptr_t, "add", "", "", "")
CK_PR_BINARY(or, ptr, void, uintptr_t, "set", "", "", "")
CK_PR_BINARY(sub, ptr, void, uintptr_t, "add", "", "", "neg %0, %0")
CK_PR_BINARY(xor, ptr, void, uintptr_t, "eor", "", "", "")
CK_PR_BINARY(and, 64, uint64_t, uint64_t, "clr", "", "", "mvn %0, %0")
CK_PR_BINARY(add, 64, uint64_t, uint64_t, "add", "", "", "")
CK_PR_BINARY(or, 64, uint64_t, uint64_t, "set", "", "", "")
CK_PR_BINARY(sub, 64, uint64_t, uint64_t, "add", "", "", "neg %0, %0")
CK_PR_BINARY(xor, 64, uint64_t, uint64_t, "eor", "", "", "")
#define CK_PR_BINARY_S(S, T, W) \
CK_PR_BINARY(and, S, T, T, "clr", W, "w", "mvn %w0, %w0") \
CK_PR_BINARY(add, S, T, T, "add", W, "w", "") \
CK_PR_BINARY(or, S, T, T, "set", W, "w", "") \
CK_PR_BINARY(sub, S, T, T, "add", W, "w", "neg %w0, %w0") \
CK_PR_BINARY(xor, S, T, T, "eor", W, "w", "")
CK_PR_BINARY_S(32, uint32_t, "")
CK_PR_BINARY_S(uint, unsigned int, "")
CK_PR_BINARY_S(int, int, "")
CK_PR_BINARY_S(16, uint16_t, "h")
CK_PR_BINARY_S(8, uint8_t, "b")
CK_PR_BINARY_S(short, short, "h")
CK_PR_BINARY_S(char, char, "b")
#undef CK_PR_BINARY_S
#undef CK_PR_BINARY
CK_CC_INLINE static void *
ck_pr_faa_ptr(void *target, uintptr_t delta)
{
uintptr_t previous;
__asm__ __volatile__(
"ldadd %2, %0, [%1];"
: "=r" (previous)
: "r" (target),
"r" (delta)
: "memory");
return (void *)(previous);
}
CK_CC_INLINE static uint64_t
ck_pr_faa_64(uint64_t *target, uint64_t delta)
{
uint64_t previous;
__asm__ __volatile__(
"ldadd %2, %0, [%1];"
: "=r" (previous)
: "r" (target),
"r" (delta)
: "memory");
return (previous);
}
#define CK_PR_FAA(S, T, W) \
CK_CC_INLINE static T \
ck_pr_faa_##S(T *target, T delta) \
{ \
T previous; \
__asm__ __volatile__( \
"ldadd" W " %w2, %w0, [%1];" \
: "=r" (previous) \
: "r" (target), \
"r" (delta) \
: "memory"); \
return (previous); \
}
CK_PR_FAA(32, uint32_t, "")
CK_PR_FAA(uint, unsigned int, "")
CK_PR_FAA(int, int, "")
CK_PR_FAA(16, uint16_t, "h")
CK_PR_FAA(8, uint8_t, "b")
CK_PR_FAA(short, short, "h")
CK_PR_FAA(char, char, "b")
#undef CK_PR_FAA
#endif /* CK_PR_AARCH64_LSE_H */

9
sys/contrib/ck/include/gcc/arm/ck_pr.h
View File

@ -148,7 +148,9 @@ ck_pr_md_load_##N(const T *target) \
}
CK_PR_DOUBLE_LOAD(uint64_t, 64)
#ifndef CK_PR_DISABLE_DOUBLE
CK_PR_DOUBLE_LOAD(double, double)
#endif
#undef CK_PR_DOUBLE_LOAD
#endif
@ -199,7 +201,9 @@ ck_pr_md_store_##N(const T *target, T value) \
}
CK_PR_DOUBLE_STORE(uint64_t, 64)
#ifndef CK_PR_DISABLE_DOUBLE
CK_PR_DOUBLE_STORE(double, double)
#endif
#undef CK_PR_DOUBLE_STORE
@ -227,7 +231,9 @@ ck_pr_cas_##N##_value(T *target, T compare, T set, T *value) \
}
CK_PR_DOUBLE_CAS_VALUE(uint64_t, 64)
#ifndef CK_PR_DISABLE_DOUBLE
CK_PR_DOUBLE_CAS_VALUE(double, double)
#endif
#undef CK_PR_DOUBLE_CAS_VALUE
@ -271,7 +277,10 @@ ck_pr_cas_##N(T *target, T compare, T set) \
}
CK_PR_DOUBLE_CAS(uint64_t, 64)
#ifndef CK_PR_DISABLE_DOUBLE
CK_PR_DOUBLE_CAS(double, double)
#endif
CK_CC_INLINE static bool
ck_pr_cas_ptr_2(void *target, void *compare, void *set)
{

2
sys/contrib/ck/include/gcc/ck_pr.h
View File

@ -101,7 +101,9 @@ ck_pr_md_store_ptr(void *target, const void *v)
CK_PR_LOAD_S(char, char)
CK_PR_LOAD_S(uint, unsigned int)
CK_PR_LOAD_S(int, int)
#ifndef CK_PR_DISABLE_DOUBLE
CK_PR_LOAD_S(double, double)
#endif
CK_PR_LOAD_S(64, uint64_t)
CK_PR_LOAD_S(32, uint32_t)
CK_PR_LOAD_S(16, uint16_t)

6
sys/contrib/ck/include/gcc/ppc64/ck_pr.h
View File

@ -112,7 +112,9 @@ CK_PR_LOAD_S(uint, unsigned int, "lwz")
CK_PR_LOAD_S(int, int, "lwz")
CK_PR_LOAD_S(short, short, "lhz")
CK_PR_LOAD_S(char, char, "lbz")
#ifndef CK_PR_DISABLE_DOUBLE
CK_PR_LOAD_S(double, double, "ld")
#endif
#undef CK_PR_LOAD_S
#undef CK_PR_LOAD
@ -140,7 +142,9 @@ CK_PR_STORE_S(uint, unsigned int, "stw")
CK_PR_STORE_S(int, int, "stw")
CK_PR_STORE_S(short, short, "sth")
CK_PR_STORE_S(char, char, "stb")
#ifndef CK_PR_DISABLE_DOUBLE
CK_PR_STORE_S(double, double, "std")
#endif
#undef CK_PR_STORE_S
#undef CK_PR_STORE
@ -294,7 +298,9 @@ CK_PR_CAS(int, int)
CK_PR_FAS(64, uint64_t, uint64_t, "d")
CK_PR_FAS(32, uint32_t, uint32_t, "w")
#ifndef CK_PR_DISABLE_DOUBLE
CK_PR_FAS(double, double, double, "d")
#endif
CK_PR_FAS(ptr, void, void *, "d")
CK_PR_FAS(int, int, int, "w")
CK_PR_FAS(uint, unsigned int, unsigned int, "w")

12
sys/contrib/ck/include/gcc/x86_64/ck_pr.h
View File

@ -132,7 +132,9 @@ CK_PR_FAS(ptr, void, void *, char, "xchgq")
#define CK_PR_FAS_S(S, T, I) CK_PR_FAS(S, T, T, T, I)
#ifndef CK_PR_DISABLE_DOUBLE
CK_PR_FAS_S(double, double, "xchgq")
#endif
CK_PR_FAS_S(char, char, "xchgb")
CK_PR_FAS_S(uint, unsigned int, "xchgl")
CK_PR_FAS_S(int, int, "xchgl")
@ -166,7 +168,9 @@ CK_PR_LOAD(ptr, void, void *, char, "movq")
CK_PR_LOAD_S(char, char, "movb")
CK_PR_LOAD_S(uint, unsigned int, "movl")
CK_PR_LOAD_S(int, int, "movl")
#ifndef CK_PR_DISABLE_DOUBLE
CK_PR_LOAD_S(double, double, "movq")
#endif
CK_PR_LOAD_S(64, uint64_t, "movq")
CK_PR_LOAD_S(32, uint32_t, "movl")
CK_PR_LOAD_S(16, uint16_t, "movw")
@ -240,7 +244,9 @@ CK_PR_LOAD_2(8, 16, uint8_t)
}
CK_PR_STORE_IMM(ptr, void, const void *, char, "movq", CK_CC_IMM_U32)
#ifndef CK_PR_DISABLE_DOUBLE
CK_PR_STORE(double, double, double, double, "movq")
#endif
#define CK_PR_STORE_S(S, T, I, K) CK_PR_STORE_IMM(S, T, T, T, I, K)
@ -404,7 +410,9 @@ CK_PR_CAS(ptr, void, void *, char, "cmpxchgq")
CK_PR_CAS_S(char, char, "cmpxchgb")
CK_PR_CAS_S(int, int, "cmpxchgl")
CK_PR_CAS_S(uint, unsigned int, "cmpxchgl")
#ifndef CK_PR_DISABLE_DOUBLE
CK_PR_CAS_S(double, double, "cmpxchgq")
#endif
CK_PR_CAS_S(64, uint64_t, "cmpxchgq")
CK_PR_CAS_S(32, uint32_t, "cmpxchgl")
CK_PR_CAS_S(16, uint16_t, "cmpxchgw")
@ -441,7 +449,9 @@ CK_PR_CAS_O(ptr, void, void *, char, "q", "rax")
CK_PR_CAS_O_S(char, char, "b", "al")
CK_PR_CAS_O_S(int, int, "l", "eax")
CK_PR_CAS_O_S(uint, unsigned int, "l", "eax")
#ifndef CK_PR_DISABLE_DOUBLE
CK_PR_CAS_O_S(double, double, "q", "rax")
#endif
CK_PR_CAS_O_S(64, uint64_t, "q", "rax")
CK_PR_CAS_O_S(32, uint32_t, "l", "eax")
CK_PR_CAS_O_S(16, uint16_t, "w", "ax")
@ -526,7 +536,9 @@ ck_pr_cas_##S##_##W##_value(T *t, T c[W], T s[W], T *v) \
(uint64_t *)(void *)v); \
}
#ifndef CK_PR_DISABLE_DOUBLE
CK_PR_CAS_V(double, 2, double)
#endif
CK_PR_CAS_V(char, 16, char)
CK_PR_CAS_V(int, 4, int)
CK_PR_CAS_V(uint, 4, unsigned int)

64
sys/contrib/ck/src/Makefile.in
View File

@ -1,64 +0,0 @@
.PHONY: clean distribution
include @BUILD_DIR@/build/ck.build
TARGET_DIR=$(BUILD_DIR)/src
SDIR=$(SRC_DIR)/src
INCLUDE_DIR=$(SRC_DIR)/include
OBJECTS=ck_barrier_centralized.o \
ck_barrier_combining.o \
ck_barrier_dissemination.o \
ck_barrier_tournament.o \
ck_barrier_mcs.o \
ck_epoch.o \
ck_ht.o \
ck_hp.o \
ck_hs.o \
ck_rhs.o \
ck_array.o
all: $(ALL_LIBS)
libck.so: $(OBJECTS)
$(LD) $(LDFLAGS) -o $(TARGET_DIR)/libck.so $(OBJECTS)
libck.a: $(OBJECTS)
ar rcs $(TARGET_DIR)/libck.a $(OBJECTS)
ck_array.o: $(INCLUDE_DIR)/ck_array.h $(SDIR)/ck_array.c
$(CC) $(CFLAGS) -c -o $(TARGET_DIR)/ck_array.o $(SDIR)/ck_array.c
ck_epoch.o: $(INCLUDE_DIR)/ck_epoch.h $(SDIR)/ck_epoch.c $(INCLUDE_DIR)/ck_stack.h
$(CC) $(CFLAGS) -c -o $(TARGET_DIR)/ck_epoch.o $(SDIR)/ck_epoch.c
ck_hs.o: $(INCLUDE_DIR)/ck_hs.h $(SDIR)/ck_hs.c
$(CC) $(CFLAGS) -c -o $(TARGET_DIR)/ck_hs.o $(SDIR)/ck_hs.c
ck_rhs.o: $(INCLUDE_DIR)/ck_rhs.h $(SDIR)/ck_rhs.c
$(CC) $(CFLAGS) -c -o $(TARGET_DIR)/ck_rhs.o $(SDIR)/ck_rhs.c
ck_ht.o: $(INCLUDE_DIR)/ck_ht.h $(SDIR)/ck_ht.c
$(CC) $(CFLAGS) -c -o $(TARGET_DIR)/ck_ht.o $(SDIR)/ck_ht.c
ck_hp.o: $(SDIR)/ck_hp.c $(INCLUDE_DIR)/ck_hp.h $(INCLUDE_DIR)/ck_stack.h
$(CC) $(CFLAGS) -c -o $(TARGET_DIR)/ck_hp.o $(SDIR)/ck_hp.c
ck_barrier_centralized.o: $(SDIR)/ck_barrier_centralized.c
$(CC) $(CFLAGS) -c -o $(TARGET_DIR)/ck_barrier_centralized.o $(SDIR)/ck_barrier_centralized.c
ck_barrier_combining.o: $(SDIR)/ck_barrier_combining.c
$(CC) $(CFLAGS) -c -o $(TARGET_DIR)/ck_barrier_combining.o $(SDIR)/ck_barrier_combining.c
ck_barrier_dissemination.o: $(SDIR)/ck_barrier_dissemination.c
$(CC) $(CFLAGS) -c -o $(TARGET_DIR)/ck_barrier_dissemination.o $(SDIR)/ck_barrier_dissemination.c
ck_barrier_tournament.o: $(SDIR)/ck_barrier_tournament.c
$(CC) $(CFLAGS) -c -o $(TARGET_DIR)/ck_barrier_tournament.o $(SDIR)/ck_barrier_tournament.c
ck_barrier_mcs.o: $(SDIR)/ck_barrier_mcs.c
$(CC) $(CFLAGS) -c -o $(TARGET_DIR)/ck_barrier_mcs.o $(SDIR)/ck_barrier_mcs.c
clean:
rm -rf $(TARGET_DIR)/*.dSYM $(TARGET_DIR)/*~ $(TARGET_DIR)/*.o \
$(OBJECTS) $(TARGET_DIR)/libck.a $(TARGET_DIR)/libck.so