/*
* 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.
*/

#if AO_CLANG_PREREQ(3, 9) && !defined(AO_DISABLE_GCC_ATOMICS)
 /* Probably, it could be enabled for earlier clang versions as well.  */

 /* As of clang-3.9, __GCC_HAVE_SYNC_COMPARE_AND_SWAP_n are missing.   */
# define AO_GCC_FORCE_HAVE_CAS

# define AO_GCC_HAVE_double_SYNC_CAS
# include "../standard_ao_double_t.h"

# include "generic.h"

#else /* AO_DISABLE_GCC_ATOMICS */

#include "../all_aligned_atomic_load_store.h"

#include "../test_and_set_t_is_ao_t.h"

/* There's also "isync" and "barrier"; however, for all current CPU     */
/* versions, "syncht" should suffice.  Likewise, it seems that the      */
/* auto-defined versions of *_acquire, *_release or *_full suffice for  */
/* all current ISA implementations.                                     */
AO_INLINE void
AO_nop_full(void)
{
 __asm__ __volatile__("syncht" : : : "memory");
}
#define AO_HAVE_nop_full

/* The Hexagon has load-locked, store-conditional primitives, and so    */
/* resulting code is very nearly identical to that of PowerPC.          */

#ifndef AO_PREFER_GENERALIZED
AO_INLINE AO_t
AO_fetch_and_add(volatile AO_t *addr, AO_t incr)
{
 AO_t oldval;
 AO_t newval;
 __asm__ __volatile__(
    "1:\n"
    "  %0 = memw_locked(%3);\n"        /* load and reserve             */
    "  %1 = add (%0,%4);\n"            /* increment                    */
    "  memw_locked(%3,p1) = %1;\n"     /* store conditional            */
    "  if (!p1) jump 1b;\n"            /* retry if lost reservation    */
    : "=&r"(oldval), "=&r"(newval), "+m"(*addr)
    : "r"(addr), "r"(incr)
    : "memory", "p1");
 return oldval;
}
#define AO_HAVE_fetch_and_add

AO_INLINE AO_TS_VAL_t
AO_test_and_set(volatile AO_TS_t *addr)
{
 int oldval;
 int locked_value = 1;

 __asm__ __volatile__(
    "1:\n"
    "  %0 = memw_locked(%2);\n"        /* load and reserve             */
    "  {\n"
    "    p2 = cmp.eq(%0,#0);\n"        /* if load is not zero,         */
    "    if (!p2.new) jump:nt 2f;\n"   /* we are done                  */
    "  }\n"
    "  memw_locked(%2,p1) = %3;\n"     /* else store conditional       */
    "  if (!p1) jump 1b;\n"            /* retry if lost reservation    */
    "2:\n"                             /* oldval is zero if we set     */
    : "=&r"(oldval), "+m"(*addr)
    : "r"(addr), "r"(locked_value)
    : "memory", "p1", "p2");
 return (AO_TS_VAL_t)oldval;
}
#define AO_HAVE_test_and_set
#endif /* !AO_PREFER_GENERALIZED */

#ifndef AO_GENERALIZE_ASM_BOOL_CAS
 AO_INLINE int
 AO_compare_and_swap(volatile AO_t *addr, AO_t old, AO_t new_val)
 {
   AO_t __oldval;
   int result = 0;
   __asm__ __volatile__(
     "1:\n"
     "  %0 = memw_locked(%3);\n"       /* load and reserve             */
     "  {\n"
     "    p2 = cmp.eq(%0,%4);\n"       /* if load is not equal to      */
     "    if (!p2.new) jump:nt 2f;\n"  /* old, fail                    */
     "  }\n"
     "  memw_locked(%3,p1) = %5;\n"    /* else store conditional       */
     "  if (!p1) jump 1b;\n"           /* retry if lost reservation    */
     "  %1 = #1\n"                     /* success, result = 1          */
     "2:\n"
     : "=&r" (__oldval), "+r" (result), "+m"(*addr)
     : "r" (addr), "r" (old), "r" (new_val)
     : "p1", "p2", "memory"
   );
   return result;
 }
# define AO_HAVE_compare_and_swap
#endif /* !AO_GENERALIZE_ASM_BOOL_CAS */

AO_INLINE AO_t
AO_fetch_compare_and_swap(volatile AO_t *addr, AO_t old_val, AO_t new_val)
{
 AO_t __oldval;

 __asm__ __volatile__(
    "1:\n"
    "  %0 = memw_locked(%2);\n"        /* load and reserve             */
    "  {\n"
    "    p2 = cmp.eq(%0,%3);\n"        /* if load is not equal to      */
    "    if (!p2.new) jump:nt 2f;\n"   /* old_val, fail                */
    "  }\n"
    "  memw_locked(%2,p1) = %4;\n"     /* else store conditional       */
    "  if (!p1) jump 1b;\n"            /* retry if lost reservation    */
    "2:\n"
    : "=&r" (__oldval), "+m"(*addr)
    : "r" (addr), "r" (old_val), "r" (new_val)
    : "p1", "p2", "memory"
 );
 return __oldval;
}
#define AO_HAVE_fetch_compare_and_swap

#define AO_T_IS_INT

#endif /* AO_DISABLE_GCC_ATOMICS */

#undef AO_GCC_FORCE_HAVE_CAS
#undef AO_GCC_HAVE_double_SYNC_CAS