Quelle list_atomic.c Sprache: C

#include "atomic_ops.h"
/*
* Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
*
* This file is covered by the GNU general public license, version 2.
* see COPYING for details.
*/

/* This generates a compilable program.  But it is really meant to be   */
/* be used only with cc -E, to inspect the expensions generated by      */
/* primitives.                                                          */

/* The result will not link or run.                                     */

#include <stdlib.h> /* for exit() */

void list_atomic(void)
{
# if defined(AO_HAVE_load) || defined(AO_HAVE_store) \
     || defined(AO_HAVE_fetch_and_add) \
     || defined(AO_HAVE_fetch_and_add1) \
     || defined(AO_HAVE_and) \
     || defined(AO_HAVE_compare_and_swap) \
     || defined(AO_HAVE_fetch_compare_and_swap)
    static volatile AO_t val /* = 0 */;
# endif
# if defined(AO_HAVE_compare_and_swap) \
     || defined(AO_HAVE_fetch_compare_and_swap)
    static AO_t oldval /* = 0 */;
# endif
# if defined(AO_HAVE_store) \
     || defined(AO_HAVE_compare_and_swap) \
     || defined(AO_HAVE_fetch_compare_and_swap)
    static AO_t newval /* = 0 */;
# endif
# if defined(AO_HAVE_test_and_set)
    AO_TS_t ts = AO_TS_INITIALIZER;
# endif
# if defined(AO_HAVE_fetch_and_add) || defined(AO_HAVE_and) \
     || defined(AO_HAVE_or) || defined(AO_HAVE_xor)
    static AO_t incr /* = 0 */;
# endif

# if defined(AO_HAVE_nop)
    (void)"AO_nop(): ";
    AO_nop();
# else
    (void)"No AO_nop";
# endif

# ifdef AO_HAVE_load
    (void)"AO_load(&val):";
    (void)AO_load(&val);
# else
    (void)"No AO_load";
# endif
# ifdef AO_HAVE_store
    (void)"AO_store(&val, newval):";
    AO_store(&val, newval);
# else
    (void)"No AO_store";
# endif
# ifdef AO_HAVE_fetch_and_add
    (void)"AO_fetch_and_add(&val, incr):";
    (void)AO_fetch_and_add(&val, incr);
# else
    (void)"No AO_fetch_and_add";
# endif
# ifdef AO_HAVE_fetch_and_add1
    (void)"AO_fetch_and_add1(&val):";
    (void)AO_fetch_and_add1(&val);
# else
    (void)"No AO_fetch_and_add1";
# endif
# ifdef AO_HAVE_fetch_and_sub1
    (void)"AO_fetch_and_sub1(&val):";
    (void)AO_fetch_and_sub1(&val);
# else
    (void)"No AO_fetch_and_sub1";
# endif
# ifdef AO_HAVE_and
    (void)"AO_and(&val, incr):";
    AO_and(&val, incr);
# else
    (void)"No AO_and";
# endif
# ifdef AO_HAVE_or
    (void)"AO_or(&val, incr):";
    AO_or(&val, incr);
# else
    (void)"No AO_or";
# endif
# ifdef AO_HAVE_xor
    (void)"AO_xor(&val, incr):";
    AO_xor(&val, incr);
# else
    (void)"No AO_xor";
# endif
# ifdef AO_HAVE_compare_and_swap
    (void)"AO_compare_and_swap(&val, oldval, newval):";
    if (!AO_compare_and_swap(&val, oldval, newval))
      exit(1);
# else
    (void)"No AO_compare_and_swap";
# endif
  /* TODO: Add AO_compare_double_and_swap_double */
  /* TODO: Add AO_compare_and_swap_double */
# ifdef AO_HAVE_fetch_compare_and_swap
    (void)"AO_fetch_compare_and_swap(&val, oldval, newval):";
    if (AO_fetch_compare_and_swap(&val, oldval, newval) != oldval)
      exit(1);
# else
    (void)"No AO_fetch_compare_and_swap";
# endif

# if defined(AO_HAVE_test_and_set)
    (void)"AO_test_and_set(&ts):";
    (void)AO_test_and_set(&ts);
# else
    (void)"No AO_test_and_set";
# endif
}
/*
* Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
*
* This file is covered by the GNU general public license, version 2.
* see COPYING for details.
*/

/* This generates a compilable program.  But it is really meant to be   */
/* be used only with cc -E, to inspect the expensions generated by      */
/* primitives.                                                          */

/* The result will not link or run.                                     */

#include <stdlib.h> /* for exit() */

void list_atomic_release(void)
{
# if defined(AO_HAVE_load_release) || defined(AO_HAVE_store_release) \
     || defined(AO_HAVE_fetch_and_add_release) \
     || defined(AO_HAVE_fetch_and_add1_release) \
     || defined(AO_HAVE_and_release) \
     || defined(AO_HAVE_compare_and_swap_release) \
     || defined(AO_HAVE_fetch_compare_and_swap_release)
    static volatile AO_t val /* = 0 */;
# endif
# if defined(AO_HAVE_compare_and_swap_release) \
     || defined(AO_HAVE_fetch_compare_and_swap_release)
    static AO_t oldval /* = 0 */;
# endif
# if defined(AO_HAVE_store_release) \
     || defined(AO_HAVE_compare_and_swap_release) \
     || defined(AO_HAVE_fetch_compare_and_swap_release)
    static AO_t newval /* = 0 */;
# endif
# if defined(AO_HAVE_test_and_set_release)
    AO_TS_t ts = AO_TS_INITIALIZER;
# endif
# if defined(AO_HAVE_fetch_and_add_release) || defined(AO_HAVE_and_release) \
     || defined(AO_HAVE_or_release) || defined(AO_HAVE_xor_release)
    static AO_t incr /* = 0 */;
# endif

# if defined(AO_HAVE_nop_release)
    (void)"AO_nop_release(): ";
    AO_nop_release();
# else
    (void)"No AO_nop_release";
# endif

# ifdef AO_HAVE_load_release
    (void)"AO_load_release(&val):";
    (void)AO_load_release(&val);
# else
    (void)"No AO_load_release";
# endif
# ifdef AO_HAVE_store_release
    (void)"AO_store_release(&val, newval):";
    AO_store_release(&val, newval);
# else
    (void)"No AO_store_release";
# endif
# ifdef AO_HAVE_fetch_and_add_release
    (void)"AO_fetch_and_add_release(&val, incr):";
    (void)AO_fetch_and_add_release(&val, incr);
# else
    (void)"No AO_fetch_and_add_release";
# endif
# ifdef AO_HAVE_fetch_and_add1_release
    (void)"AO_fetch_and_add1_release(&val):";
    (void)AO_fetch_and_add1_release(&val);
# else
    (void)"No AO_fetch_and_add1_release";
# endif
# ifdef AO_HAVE_fetch_and_sub1_release
    (void)"AO_fetch_and_sub1_release(&val):";
    (void)AO_fetch_and_sub1_release(&val);
# else
    (void)"No AO_fetch_and_sub1_release";
# endif
# ifdef AO_HAVE_and_release
    (void)"AO_and_release(&val, incr):";
    AO_and_release(&val, incr);
# else
    (void)"No AO_and_release";
# endif
# ifdef AO_HAVE_or_release
    (void)"AO_or_release(&val, incr):";
    AO_or_release(&val, incr);
# else
    (void)"No AO_or_release";
# endif
# ifdef AO_HAVE_xor_release
    (void)"AO_xor_release(&val, incr):";
    AO_xor_release(&val, incr);
# else
    (void)"No AO_xor_release";
# endif
# ifdef AO_HAVE_compare_and_swap_release
    (void)"AO_compare_and_swap_release(&val, oldval, newval):";
    if (!AO_compare_and_swap_release(&val, oldval, newval))
      exit(1);
# else
    (void)"No AO_compare_and_swap_release";
# endif
  /* TODO: Add AO_compare_double_and_swap_double_release */
  /* TODO: Add AO_compare_and_swap_double_release */
# ifdef AO_HAVE_fetch_compare_and_swap_release
    (void)"AO_fetch_compare_and_swap_release(&val, oldval, newval):";
    if (AO_fetch_compare_and_swap_release(&val, oldval, newval) != oldval)
      exit(1);
# else
    (void)"No AO_fetch_compare_and_swap_release";
# endif

# if defined(AO_HAVE_test_and_set_release)
    (void)"AO_test_and_set_release(&ts):";
    (void)AO_test_and_set_release(&ts);
# else
    (void)"No AO_test_and_set_release";
# endif
}
/*
* Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
*
* This file is covered by the GNU general public license, version 2.
* see COPYING for details.
*/

/* This generates a compilable program.  But it is really meant to be   */
/* be used only with cc -E, to inspect the expensions generated by      */
/* primitives.                                                          */

/* The result will not link or run.                                     */

#include <stdlib.h> /* for exit() */

void list_atomic_acquire(void)
{
# if defined(AO_HAVE_load_acquire) || defined(AO_HAVE_store_acquire) \
     || defined(AO_HAVE_fetch_and_add_acquire) \
     || defined(AO_HAVE_fetch_and_add1_acquire) \
     || defined(AO_HAVE_and_acquire) \
     || defined(AO_HAVE_compare_and_swap_acquire) \
     || defined(AO_HAVE_fetch_compare_and_swap_acquire)
    static volatile AO_t val /* = 0 */;
# endif
# if defined(AO_HAVE_compare_and_swap_acquire) \
     || defined(AO_HAVE_fetch_compare_and_swap_acquire)
    static AO_t oldval /* = 0 */;
# endif
# if defined(AO_HAVE_store_acquire) \
     || defined(AO_HAVE_compare_and_swap_acquire) \
     || defined(AO_HAVE_fetch_compare_and_swap_acquire)
    static AO_t newval /* = 0 */;
# endif
# if defined(AO_HAVE_test_and_set_acquire)
    AO_TS_t ts = AO_TS_INITIALIZER;
# endif
# if defined(AO_HAVE_fetch_and_add_acquire) || defined(AO_HAVE_and_acquire) \
     || defined(AO_HAVE_or_acquire) || defined(AO_HAVE_xor_acquire)
    static AO_t incr /* = 0 */;
# endif

# if defined(AO_HAVE_nop_acquire)
    (void)"AO_nop_acquire(): ";
    AO_nop_acquire();
# else
    (void)"No AO_nop_acquire";
# endif

# ifdef AO_HAVE_load_acquire
    (void)"AO_load_acquire(&val):";
    (void)AO_load_acquire(&val);
# else
    (void)"No AO_load_acquire";
# endif
# ifdef AO_HAVE_store_acquire
    (void)"AO_store_acquire(&val, newval):";
    AO_store_acquire(&val, newval);
# else
    (void)"No AO_store_acquire";
# endif
# ifdef AO_HAVE_fetch_and_add_acquire
    (void)"AO_fetch_and_add_acquire(&val, incr):";
    (void)AO_fetch_and_add_acquire(&val, incr);
# else
    (void)"No AO_fetch_and_add_acquire";
# endif
# ifdef AO_HAVE_fetch_and_add1_acquire
    (void)"AO_fetch_and_add1_acquire(&val):";
    (void)AO_fetch_and_add1_acquire(&val);
# else
    (void)"No AO_fetch_and_add1_acquire";
# endif
# ifdef AO_HAVE_fetch_and_sub1_acquire
    (void)"AO_fetch_and_sub1_acquire(&val):";
    (void)AO_fetch_and_sub1_acquire(&val);
# else
    (void)"No AO_fetch_and_sub1_acquire";
# endif
# ifdef AO_HAVE_and_acquire
    (void)"AO_and_acquire(&val, incr):";
    AO_and_acquire(&val, incr);
# else
    (void)"No AO_and_acquire";
# endif
# ifdef AO_HAVE_or_acquire
    (void)"AO_or_acquire(&val, incr):";
    AO_or_acquire(&val, incr);
# else
    (void)"No AO_or_acquire";
# endif
# ifdef AO_HAVE_xor_acquire
    (void)"AO_xor_acquire(&val, incr):";
    AO_xor_acquire(&val, incr);
# else
    (void)"No AO_xor_acquire";
# endif
# ifdef AO_HAVE_compare_and_swap_acquire
    (void)"AO_compare_and_swap_acquire(&val, oldval, newval):";
    if (!AO_compare_and_swap_acquire(&val, oldval, newval))
      exit(1);
# else
    (void)"No AO_compare_and_swap_acquire";
# endif
  /* TODO: Add AO_compare_double_and_swap_double_acquire */
  /* TODO: Add AO_compare_and_swap_double_acquire */
# ifdef AO_HAVE_fetch_compare_and_swap_acquire
    (void)"AO_fetch_compare_and_swap_acquire(&val, oldval, newval):";
    if (AO_fetch_compare_and_swap_acquire(&val, oldval, newval) != oldval)
      exit(1);
# else
    (void)"No AO_fetch_compare_and_swap_acquire";
# endif

# if defined(AO_HAVE_test_and_set_acquire)
    (void)"AO_test_and_set_acquire(&ts):";
    (void)AO_test_and_set_acquire(&ts);
# else
    (void)"No AO_test_and_set_acquire";
# endif
}
/*
* Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
*
* This file is covered by the GNU general public license, version 2.
* see COPYING for details.
*/

/* This generates a compilable program.  But it is really meant to be   */
/* be used only with cc -E, to inspect the expensions generated by      */
/* primitives.                                                          */

/* The result will not link or run.                                     */

#include <stdlib.h> /* for exit() */

void list_atomic_read(void)
{
# if defined(AO_HAVE_load_read) || defined(AO_HAVE_store_read) \
     || defined(AO_HAVE_fetch_and_add_read) \
     || defined(AO_HAVE_fetch_and_add1_read) \
     || defined(AO_HAVE_and_read) \
     || defined(AO_HAVE_compare_and_swap_read) \
     || defined(AO_HAVE_fetch_compare_and_swap_read)
    static volatile AO_t val /* = 0 */;
# endif
# if defined(AO_HAVE_compare_and_swap_read) \
     || defined(AO_HAVE_fetch_compare_and_swap_read)
    static AO_t oldval /* = 0 */;
# endif
# if defined(AO_HAVE_store_read) \
     || defined(AO_HAVE_compare_and_swap_read) \
     || defined(AO_HAVE_fetch_compare_and_swap_read)
    static AO_t newval /* = 0 */;
# endif
# if defined(AO_HAVE_test_and_set_read)
    AO_TS_t ts = AO_TS_INITIALIZER;
# endif
# if defined(AO_HAVE_fetch_and_add_read) || defined(AO_HAVE_and_read) \
     || defined(AO_HAVE_or_read) || defined(AO_HAVE_xor_read)
    static AO_t incr /* = 0 */;
# endif

# if defined(AO_HAVE_nop_read)
    (void)"AO_nop_read(): ";
    AO_nop_read();
# else
    (void)"No AO_nop_read";
# endif

# ifdef AO_HAVE_load_read
    (void)"AO_load_read(&val):";
    (void)AO_load_read(&val);
# else
    (void)"No AO_load_read";
# endif
# ifdef AO_HAVE_store_read
    (void)"AO_store_read(&val, newval):";
    AO_store_read(&val, newval);
# else
    (void)"No AO_store_read";
# endif
# ifdef AO_HAVE_fetch_and_add_read
    (void)"AO_fetch_and_add_read(&val, incr):";
    (void)AO_fetch_and_add_read(&val, incr);
# else
    (void)"No AO_fetch_and_add_read";
# endif
# ifdef AO_HAVE_fetch_and_add1_read
    (void)"AO_fetch_and_add1_read(&val):";
    (void)AO_fetch_and_add1_read(&val);
# else
    (void)"No AO_fetch_and_add1_read";
# endif
# ifdef AO_HAVE_fetch_and_sub1_read
    (void)"AO_fetch_and_sub1_read(&val):";
    (void)AO_fetch_and_sub1_read(&val);
# else
    (void)"No AO_fetch_and_sub1_read";
# endif
# ifdef AO_HAVE_and_read
    (void)"AO_and_read(&val, incr):";
    AO_and_read(&val, incr);
# else
    (void)"No AO_and_read";
# endif
# ifdef AO_HAVE_or_read
    (void)"AO_or_read(&val, incr):";
    AO_or_read(&val, incr);
# else
    (void)"No AO_or_read";
# endif
# ifdef AO_HAVE_xor_read
    (void)"AO_xor_read(&val, incr):";
    AO_xor_read(&val, incr);
# else
    (void)"No AO_xor_read";
# endif
# ifdef AO_HAVE_compare_and_swap_read
    (void)"AO_compare_and_swap_read(&val, oldval, newval):";
    if (!AO_compare_and_swap_read(&val, oldval, newval))
      exit(1);
# else
    (void)"No AO_compare_and_swap_read";
# endif
  /* TODO: Add AO_compare_double_and_swap_double_read */
  /* TODO: Add AO_compare_and_swap_double_read */
# ifdef AO_HAVE_fetch_compare_and_swap_read
    (void)"AO_fetch_compare_and_swap_read(&val, oldval, newval):";
    if (AO_fetch_compare_and_swap_read(&val, oldval, newval) != oldval)
      exit(1);
# else
    (void)"No AO_fetch_compare_and_swap_read";
# endif

# if defined(AO_HAVE_test_and_set_read)
    (void)"AO_test_and_set_read(&ts):";
    (void)AO_test_and_set_read(&ts);
# else
    (void)"No AO_test_and_set_read";
# endif
}
/*
* Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
*
* This file is covered by the GNU general public license, version 2.
* see COPYING for details.
*/

/* This generates a compilable program.  But it is really meant to be   */
/* be used only with cc -E, to inspect the expensions generated by      */
/* primitives.                                                          */

/* The result will not link or run.                                     */

#include <stdlib.h> /* for exit() */

void list_atomic_write(void)
{
# if defined(AO_HAVE_load_write) || defined(AO_HAVE_store_write) \
     || defined(AO_HAVE_fetch_and_add_write) \
     || defined(AO_HAVE_fetch_and_add1_write) \
     || defined(AO_HAVE_and_write) \
     || defined(AO_HAVE_compare_and_swap_write) \
     || defined(AO_HAVE_fetch_compare_and_swap_write)
    static volatile AO_t val /* = 0 */;
# endif
# if defined(AO_HAVE_compare_and_swap_write) \
     || defined(AO_HAVE_fetch_compare_and_swap_write)
    static AO_t oldval /* = 0 */;
# endif
# if defined(AO_HAVE_store_write) \
     || defined(AO_HAVE_compare_and_swap_write) \
     || defined(AO_HAVE_fetch_compare_and_swap_write)
    static AO_t newval /* = 0 */;
# endif
# if defined(AO_HAVE_test_and_set_write)
    AO_TS_t ts = AO_TS_INITIALIZER;
# endif
# if defined(AO_HAVE_fetch_and_add_write) || defined(AO_HAVE_and_write) \
     || defined(AO_HAVE_or_write) || defined(AO_HAVE_xor_write)
    static AO_t incr /* = 0 */;
# endif

# if defined(AO_HAVE_nop_write)
    (void)"AO_nop_write(): ";
    AO_nop_write();
# else
    (void)"No AO_nop_write";
# endif

# ifdef AO_HAVE_load_write
    (void)"AO_load_write(&val):";
    (void)AO_load_write(&val);
# else
    (void)"No AO_load_write";
# endif
# ifdef AO_HAVE_store_write
    (void)"AO_store_write(&val, newval):";
    AO_store_write(&val, newval);
# else
    (void)"No AO_store_write";
# endif
# ifdef AO_HAVE_fetch_and_add_write
    (void)"AO_fetch_and_add_write(&val, incr):";
    (void)AO_fetch_and_add_write(&val, incr);
# else
    (void)"No AO_fetch_and_add_write";
# endif
# ifdef AO_HAVE_fetch_and_add1_write
    (void)"AO_fetch_and_add1_write(&val):";
    (void)AO_fetch_and_add1_write(&val);
# else
    (void)"No AO_fetch_and_add1_write";
# endif
# ifdef AO_HAVE_fetch_and_sub1_write
    (void)"AO_fetch_and_sub1_write(&val):";
    (void)AO_fetch_and_sub1_write(&val);
# else
    (void)"No AO_fetch_and_sub1_write";
# endif
# ifdef AO_HAVE_and_write
    (void)"AO_and_write(&val, incr):";
    AO_and_write(&val, incr);
# else
    (void)"No AO_and_write";
# endif
# ifdef AO_HAVE_or_write
    (void)"AO_or_write(&val, incr):";
    AO_or_write(&val, incr);
# else
    (void)"No AO_or_write";
# endif
# ifdef AO_HAVE_xor_write
    (void)"AO_xor_write(&val, incr):";
    AO_xor_write(&val, incr);
# else
    (void)"No AO_xor_write";
# endif
# ifdef AO_HAVE_compare_and_swap_write
    (void)"AO_compare_and_swap_write(&val, oldval, newval):";
    if (!AO_compare_and_swap_write(&val, oldval, newval))
      exit(1);
# else
    (void)"No AO_compare_and_swap_write";
# endif
  /* TODO: Add AO_compare_double_and_swap_double_write */
  /* TODO: Add AO_compare_and_swap_double_write */
# ifdef AO_HAVE_fetch_compare_and_swap_write
    (void)"AO_fetch_compare_and_swap_write(&val, oldval, newval):";
    if (AO_fetch_compare_and_swap_write(&val, oldval, newval) != oldval)
      exit(1);
# else
    (void)"No AO_fetch_compare_and_swap_write";
# endif

# if defined(AO_HAVE_test_and_set_write)
    (void)"AO_test_and_set_write(&ts):";
    (void)AO_test_and_set_write(&ts);
# else
    (void)"No AO_test_and_set_write";
# endif
}
/*
* Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
*
* This file is covered by the GNU general public license, version 2.
* see COPYING for details.
*/

/* This generates a compilable program.  But it is really meant to be   */
/* be used only with cc -E, to inspect the expensions generated by      */
/* primitives.                                                          */

/* The result will not link or run.                                     */

#include <stdlib.h> /* for exit() */

void list_atomic_full(void)
{
# if defined(AO_HAVE_load_full) || defined(AO_HAVE_store_full) \
     || defined(AO_HAVE_fetch_and_add_full) \
     || defined(AO_HAVE_fetch_and_add1_full) \
     || defined(AO_HAVE_and_full) \
     || defined(AO_HAVE_compare_and_swap_full) \
     || defined(AO_HAVE_fetch_compare_and_swap_full)
    static volatile AO_t val /* = 0 */;
# endif
# if defined(AO_HAVE_compare_and_swap_full) \
     || defined(AO_HAVE_fetch_compare_and_swap_full)
    static AO_t oldval /* = 0 */;
# endif
# if defined(AO_HAVE_store_full) \
     || defined(AO_HAVE_compare_and_swap_full) \
     || defined(AO_HAVE_fetch_compare_and_swap_full)
    static AO_t newval /* = 0 */;
# endif
# if defined(AO_HAVE_test_and_set_full)
    AO_TS_t ts = AO_TS_INITIALIZER;
# endif
# if defined(AO_HAVE_fetch_and_add_full) || defined(AO_HAVE_and_full) \
     || defined(AO_HAVE_or_full) || defined(AO_HAVE_xor_full)
    static AO_t incr /* = 0 */;
# endif

# if defined(AO_HAVE_nop_full)
    (void)"AO_nop_full(): ";
    AO_nop_full();
# else
    (void)"No AO_nop_full";
# endif

# ifdef AO_HAVE_load_full
    (void)"AO_load_full(&val):";
    (void)AO_load_full(&val);
# else
    (void)"No AO_load_full";
# endif
# ifdef AO_HAVE_store_full
    (void)"AO_store_full(&val, newval):";
    AO_store_full(&val, newval);
# else
    (void)"No AO_store_full";
# endif
# ifdef AO_HAVE_fetch_and_add_full
    (void)"AO_fetch_and_add_full(&val, incr):";
    (void)AO_fetch_and_add_full(&val, incr);
# else
    (void)"No AO_fetch_and_add_full";
# endif
# ifdef AO_HAVE_fetch_and_add1_full
    (void)"AO_fetch_and_add1_full(&val):";
    (void)AO_fetch_and_add1_full(&val);
# else
    (void)"No AO_fetch_and_add1_full";
# endif
# ifdef AO_HAVE_fetch_and_sub1_full
    (void)"AO_fetch_and_sub1_full(&val):";
    (void)AO_fetch_and_sub1_full(&val);
# else
    (void)"No AO_fetch_and_sub1_full";
# endif
# ifdef AO_HAVE_and_full
    (void)"AO_and_full(&val, incr):";
    AO_and_full(&val, incr);
# else
    (void)"No AO_and_full";
# endif
# ifdef AO_HAVE_or_full
    (void)"AO_or_full(&val, incr):";
    AO_or_full(&val, incr);
# else
    (void)"No AO_or_full";
# endif
# ifdef AO_HAVE_xor_full
    (void)"AO_xor_full(&val, incr):";
    AO_xor_full(&val, incr);
# else
    (void)"No AO_xor_full";
# endif
# ifdef AO_HAVE_compare_and_swap_full
    (void)"AO_compare_and_swap_full(&val, oldval, newval):";
    if (!AO_compare_and_swap_full(&val, oldval, newval))
      exit(1);
# else
    (void)"No AO_compare_and_swap_full";
# endif
  /* TODO: Add AO_compare_double_and_swap_double_full */
  /* TODO: Add AO_compare_and_swap_double_full */
# ifdef AO_HAVE_fetch_compare_and_swap_full
    (void)"AO_fetch_compare_and_swap_full(&val, oldval, newval):";
    if (AO_fetch_compare_and_swap_full(&val, oldval, newval) != oldval)
      exit(1);
# else
    (void)"No AO_fetch_compare_and_swap_full";
# endif

# if defined(AO_HAVE_test_and_set_full)
    (void)"AO_test_and_set_full(&ts):";
    (void)AO_test_and_set_full(&ts);
# else
    (void)"No AO_test_and_set_full";
# endif
}
/*
* Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
*
* This file is covered by the GNU general public license, version 2.
* see COPYING for details.
*/

/* This generates a compilable program.  But it is really meant to be   */
/* be used only with cc -E, to inspect the expensions generated by      */
/* primitives.                                                          */

/* The result will not link or run.                                     */

#include <stdlib.h> /* for exit() */

void list_atomic_release_write(void)
{
# if defined(AO_HAVE_load_release_write) || defined(AO_HAVE_store_release_write) \
     || defined(AO_HAVE_fetch_and_add_release_write) \
     || defined(AO_HAVE_fetch_and_add1_release_write) \
     || defined(AO_HAVE_and_release_write) \
     || defined(AO_HAVE_compare_and_swap_release_write) \
     || defined(AO_HAVE_fetch_compare_and_swap_release_write)
    static volatile AO_t val /* = 0 */;
# endif
# if defined(AO_HAVE_compare_and_swap_release_write) \
     || defined(AO_HAVE_fetch_compare_and_swap_release_write)
    static AO_t oldval /* = 0 */;
# endif
# if defined(AO_HAVE_store_release_write) \
     || defined(AO_HAVE_compare_and_swap_release_write) \
     || defined(AO_HAVE_fetch_compare_and_swap_release_write)
    static AO_t newval /* = 0 */;
# endif
# if defined(AO_HAVE_test_and_set_release_write)
    AO_TS_t ts = AO_TS_INITIALIZER;
# endif
# if defined(AO_HAVE_fetch_and_add_release_write) || defined(AO_HAVE_and_release_write) \
     || defined(AO_HAVE_or_release_write) || defined(AO_HAVE_xor_release_write)
    static AO_t incr /* = 0 */;
# endif

# if defined(AO_HAVE_nop_release_write)
    (void)"AO_nop_release_write(): ";
    AO_nop_release_write();
# else
    (void)"No AO_nop_release_write";
# endif

# ifdef AO_HAVE_load_release_write
    (void)"AO_load_release_write(&val):";
    (void)AO_load_release_write(&val);
# else
    (void)"No AO_load_release_write";
# endif
# ifdef AO_HAVE_store_release_write
    (void)"AO_store_release_write(&val, newval):";
    AO_store_release_write(&val, newval);
# else
    (void)"No AO_store_release_write";
# endif
# ifdef AO_HAVE_fetch_and_add_release_write
    (void)"AO_fetch_and_add_release_write(&val, incr):";
    (void)AO_fetch_and_add_release_write(&val, incr);
# else
    (void)"No AO_fetch_and_add_release_write";
# endif
# ifdef AO_HAVE_fetch_and_add1_release_write
    (void)"AO_fetch_and_add1_release_write(&val):";
    (void)AO_fetch_and_add1_release_write(&val);
# else
    (void)"No AO_fetch_and_add1_release_write";
# endif
# ifdef AO_HAVE_fetch_and_sub1_release_write
    (void)"AO_fetch_and_sub1_release_write(&val):";
    (void)AO_fetch_and_sub1_release_write(&val);
# else
    (void)"No AO_fetch_and_sub1_release_write";
# endif
# ifdef AO_HAVE_and_release_write
    (void)"AO_and_release_write(&val, incr):";
    AO_and_release_write(&val, incr);
# else
    (void)"No AO_and_release_write";
# endif
# ifdef AO_HAVE_or_release_write
    (void)"AO_or_release_write(&val, incr):";
    AO_or_release_write(&val, incr);
# else
    (void)"No AO_or_release_write";
# endif
# ifdef AO_HAVE_xor_release_write
    (void)"AO_xor_release_write(&val, incr):";
    AO_xor_release_write(&val, incr);
# else
    (void)"No AO_xor_release_write";
# endif
# ifdef AO_HAVE_compare_and_swap_release_write
    (void)"AO_compare_and_swap_release_write(&val, oldval, newval):";
    if (!AO_compare_and_swap_release_write(&val, oldval, newval))
      exit(1);
# else
    (void)"No AO_compare_and_swap_release_write";
# endif
  /* TODO: Add AO_compare_double_and_swap_double_release_write */
  /* TODO: Add AO_compare_and_swap_double_release_write */
# ifdef AO_HAVE_fetch_compare_and_swap_release_write
    (void)"AO_fetch_compare_and_swap_release_write(&val, oldval, newval):";
    if (AO_fetch_compare_and_swap_release_write(&val, oldval, newval) != oldval)
      exit(1);
# else
    (void)"No AO_fetch_compare_and_swap_release_write";
# endif

# if defined(AO_HAVE_test_and_set_release_write)
    (void)"AO_test_and_set_release_write(&ts):";
    (void)AO_test_and_set_release_write(&ts);
# else
    (void)"No AO_test_and_set_release_write";
# endif
}
/*
* Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
*
* This file is covered by the GNU general public license, version 2.
* see COPYING for details.
*/

/* This generates a compilable program.  But it is really meant to be   */
/* be used only with cc -E, to inspect the expensions generated by      */
/* primitives.                                                          */

/* The result will not link or run.                                     */

#include <stdlib.h> /* for exit() */

void list_atomic_acquire_read(void)
{
# if defined(AO_HAVE_load_acquire_read) || defined(AO_HAVE_store_acquire_read) \
     || defined(AO_HAVE_fetch_and_add_acquire_read) \
     || defined(AO_HAVE_fetch_and_add1_acquire_read) \
     || defined(AO_HAVE_and_acquire_read) \
     || defined(AO_HAVE_compare_and_swap_acquire_read) \
     || defined(AO_HAVE_fetch_compare_and_swap_acquire_read)
    static volatile AO_t val /* = 0 */;
# endif
# if defined(AO_HAVE_compare_and_swap_acquire_read) \
     || defined(AO_HAVE_fetch_compare_and_swap_acquire_read)
    static AO_t oldval /* = 0 */;
# endif
# if defined(AO_HAVE_store_acquire_read) \
     || defined(AO_HAVE_compare_and_swap_acquire_read) \
     || defined(AO_HAVE_fetch_compare_and_swap_acquire_read)
    static AO_t newval /* = 0 */;
# endif
# if defined(AO_HAVE_test_and_set_acquire_read)
    AO_TS_t ts = AO_TS_INITIALIZER;
# endif
# if defined(AO_HAVE_fetch_and_add_acquire_read) || defined(AO_HAVE_and_acquire_read) \
     || defined(AO_HAVE_or_acquire_read) || defined(AO_HAVE_xor_acquire_read)
    static AO_t incr /* = 0 */;
# endif

# if defined(AO_HAVE_nop_acquire_read)
    (void)"AO_nop_acquire_read(): ";
    AO_nop_acquire_read();
# else
    (void)"No AO_nop_acquire_read";
# endif

# ifdef AO_HAVE_load_acquire_read
    (void)"AO_load_acquire_read(&val):";
    (void)AO_load_acquire_read(&val);
# else
    (void)"No AO_load_acquire_read";
# endif
# ifdef AO_HAVE_store_acquire_read
    (void)"AO_store_acquire_read(&val, newval):";
    AO_store_acquire_read(&val, newval);
# else
    (void)"No AO_store_acquire_read";
# endif
# ifdef AO_HAVE_fetch_and_add_acquire_read
    (void)"AO_fetch_and_add_acquire_read(&val, incr):";
    (void)AO_fetch_and_add_acquire_read(&val, incr);
# else
    (void)"No AO_fetch_and_add_acquire_read";
# endif
# ifdef AO_HAVE_fetch_and_add1_acquire_read
    (void)"AO_fetch_and_add1_acquire_read(&val):";
    (void)AO_fetch_and_add1_acquire_read(&val);
# else
    (void)"No AO_fetch_and_add1_acquire_read";
# endif
# ifdef AO_HAVE_fetch_and_sub1_acquire_read
    (void)"AO_fetch_and_sub1_acquire_read(&val):";
    (void)AO_fetch_and_sub1_acquire_read(&val);
# else
    (void)"No AO_fetch_and_sub1_acquire_read";
# endif
# ifdef AO_HAVE_and_acquire_read
    (void)"AO_and_acquire_read(&val, incr):";
    AO_and_acquire_read(&val, incr);
# else
    (void)"No AO_and_acquire_read";
# endif
# ifdef AO_HAVE_or_acquire_read
    (void)"AO_or_acquire_read(&val, incr):";
    AO_or_acquire_read(&val, incr);
# else
    (void)"No AO_or_acquire_read";
# endif
# ifdef AO_HAVE_xor_acquire_read
    (void)"AO_xor_acquire_read(&val, incr):";
    AO_xor_acquire_read(&val, incr);
# else
    (void)"No AO_xor_acquire_read";
# endif
# ifdef AO_HAVE_compare_and_swap_acquire_read
    (void)"AO_compare_and_swap_acquire_read(&val, oldval, newval):";
    if (!AO_compare_and_swap_acquire_read(&val, oldval, newval))
      exit(1);
# else
    (void)"No AO_compare_and_swap_acquire_read";
# endif
  /* TODO: Add AO_compare_double_and_swap_double_acquire_read */
  /* TODO: Add AO_compare_and_swap_double_acquire_read */
# ifdef AO_HAVE_fetch_compare_and_swap_acquire_read
    (void)"AO_fetch_compare_and_swap_acquire_read(&val, oldval, newval):";
    if (AO_fetch_compare_and_swap_acquire_read(&val, oldval, newval) != oldval)
      exit(1);
# else
    (void)"No AO_fetch_compare_and_swap_acquire_read";
# endif

# if defined(AO_HAVE_test_and_set_acquire_read)
    (void)"AO_test_and_set_acquire_read(&ts):";
    (void)AO_test_and_set_acquire_read(&ts);
# else
    (void)"No AO_test_and_set_acquire_read";
# endif
}
/*
* Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
*
* This file is covered by the GNU general public license, version 2.
* see COPYING for details.
*/

/* This generates a compilable program.  But it is really meant to be   */
/* be used only with cc -E, to inspect the expensions generated by      */
/* primitives.                                                          */

/* The result will not link or run.                                     */

#include <stdlib.h> /* for exit() */

void list_atomic_dd_acquire_read(void)
{
# if defined(AO_HAVE_load_dd_acquire_read) || defined(AO_HAVE_store_dd_acquire_read) \
     || defined(AO_HAVE_fetch_and_add_dd_acquire_read) \
     || defined(AO_HAVE_fetch_and_add1_dd_acquire_read) \
     || defined(AO_HAVE_and_dd_acquire_read) \
     || defined(AO_HAVE_compare_and_swap_dd_acquire_read) \
     || defined(AO_HAVE_fetch_compare_and_swap_dd_acquire_read)
    static volatile AO_t val /* = 0 */;
# endif
# if defined(AO_HAVE_compare_and_swap_dd_acquire_read) \
     || defined(AO_HAVE_fetch_compare_and_swap_dd_acquire_read)
    static AO_t oldval /* = 0 */;
# endif
# if defined(AO_HAVE_store_dd_acquire_read) \
     || defined(AO_HAVE_compare_and_swap_dd_acquire_read) \
     || defined(AO_HAVE_fetch_compare_and_swap_dd_acquire_read)
    static AO_t newval /* = 0 */;
# endif
# if defined(AO_HAVE_test_and_set_dd_acquire_read)
    AO_TS_t ts = AO_TS_INITIALIZER;
# endif
# if defined(AO_HAVE_fetch_and_add_dd_acquire_read) || defined(AO_HAVE_and_dd_acquire_read) \
     || defined(AO_HAVE_or_dd_acquire_read) || defined(AO_HAVE_xor_dd_acquire_read)
    static AO_t incr /* = 0 */;
# endif

# if defined(AO_HAVE_nop_dd_acquire_read)
    (void)"AO_nop_dd_acquire_read(): ";
    AO_nop_dd_acquire_read();
# else
    (void)"No AO_nop_dd_acquire_read";
# endif

# ifdef AO_HAVE_load_dd_acquire_read
    (void)"AO_load_dd_acquire_read(&val):";
    (void)AO_load_dd_acquire_read(&val);
# else
    (void)"No AO_load_dd_acquire_read";
# endif
# ifdef AO_HAVE_store_dd_acquire_read
    (void)"AO_store_dd_acquire_read(&val, newval):";
    AO_store_dd_acquire_read(&val, newval);
# else
    (void)"No AO_store_dd_acquire_read";
# endif
# ifdef AO_HAVE_fetch_and_add_dd_acquire_read
    (void)"AO_fetch_and_add_dd_acquire_read(&val, incr):";
    (void)AO_fetch_and_add_dd_acquire_read(&val, incr);
# else
    (void)"No AO_fetch_and_add_dd_acquire_read";
# endif
# ifdef AO_HAVE_fetch_and_add1_dd_acquire_read
    (void)"AO_fetch_and_add1_dd_acquire_read(&val):";
    (void)AO_fetch_and_add1_dd_acquire_read(&val);
# else
    (void)"No AO_fetch_and_add1_dd_acquire_read";
# endif
# ifdef AO_HAVE_fetch_and_sub1_dd_acquire_read
    (void)"AO_fetch_and_sub1_dd_acquire_read(&val):";
    (void)AO_fetch_and_sub1_dd_acquire_read(&val);
# else
    (void)"No AO_fetch_and_sub1_dd_acquire_read";
# endif
# ifdef AO_HAVE_and_dd_acquire_read
    (void)"AO_and_dd_acquire_read(&val, incr):";
    AO_and_dd_acquire_read(&val, incr);
# else
    (void)"No AO_and_dd_acquire_read";
# endif
# ifdef AO_HAVE_or_dd_acquire_read
    (void)"AO_or_dd_acquire_read(&val, incr):";
    AO_or_dd_acquire_read(&val, incr);
# else
    (void)"No AO_or_dd_acquire_read";
# endif
# ifdef AO_HAVE_xor_dd_acquire_read
    (void)"AO_xor_dd_acquire_read(&val, incr):";
    AO_xor_dd_acquire_read(&val, incr);
# else
    (void)"No AO_xor_dd_acquire_read";
# endif
# ifdef AO_HAVE_compare_and_swap_dd_acquire_read
    (void)"AO_compare_and_swap_dd_acquire_read(&val, oldval, newval):";
    if (!AO_compare_and_swap_dd_acquire_read(&val, oldval, newval))
      exit(1);
# else
    (void)"No AO_compare_and_swap_dd_acquire_read";
# endif
  /* TODO: Add AO_compare_double_and_swap_double_dd_acquire_read */
  /* TODO: Add AO_compare_and_swap_double_dd_acquire_read */
# ifdef AO_HAVE_fetch_compare_and_swap_dd_acquire_read
    (void)"AO_fetch_compare_and_swap_dd_acquire_read(&val, oldval, newval):";
    if (AO_fetch_compare_and_swap_dd_acquire_read(&val, oldval, newval) != oldval)
      exit(1);
# else
    (void)"No AO_fetch_compare_and_swap_dd_acquire_read";
# endif

# if defined(AO_HAVE_test_and_set_dd_acquire_read)
    (void)"AO_test_and_set_dd_acquire_read(&ts):";
    (void)AO_test_and_set_dd_acquire_read(&ts);
# else
    (void)"No AO_test_and_set_dd_acquire_read";
# endif
}
/*
* Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
*
* This file is covered by the GNU general public license, version 2.
* see COPYING for details.
*/

/* This generates a compilable program.  But it is really meant to be   */
/* be used only with cc -E, to inspect the expensions generated by      */
/* primitives.                                                          */

/* The result will not link or run.                                     */

#include <stdlib.h> /* for exit() */

void char_list_atomic(void)
{
# if defined(AO_HAVE_char_load) || defined(AO_HAVE_char_store) \
     || defined(AO_HAVE_char_fetch_and_add) \
     || defined(AO_HAVE_char_fetch_and_add1) \
     || defined(AO_HAVE_char_and) \
     || defined(AO_HAVE_char_compare_and_swap) \
     || defined(AO_HAVE_char_fetch_compare_and_swap)
    static volatile unsigned/**/char val /* = 0 */;
# endif
# if defined(AO_HAVE_char_compare_and_swap) \
     || defined(AO_HAVE_char_fetch_compare_and_swap)
    static unsigned/**/char oldval /* = 0 */;
# endif
# if defined(AO_HAVE_char_store) \
     || defined(AO_HAVE_char_compare_and_swap) \
     || defined(AO_HAVE_char_fetch_compare_and_swap)
    static unsigned/**/char newval /* = 0 */;
# endif
# if defined(AO_HAVE_test_and_set)
    AO_TS_t ts = AO_TS_INITIALIZER;
# endif
# if defined(AO_HAVE_char_fetch_and_add) || defined(AO_HAVE_char_and) \
     || defined(AO_HAVE_char_or) || defined(AO_HAVE_char_xor)
    static unsigned/**/char incr /* = 0 */;
# endif

# if defined(AO_HAVE_nop)
    (void)"AO_nop(): ";
    AO_nop();
# else
    (void)"No AO_nop";
# endif

# ifdef AO_HAVE_char_load
    (void)"AO_char_load(&val):";
    (void)AO_char_load(&val);
# else
    (void)"No AO_char_load";
# endif
# ifdef AO_HAVE_char_store
    (void)"AO_char_store(&val, newval):";
    AO_char_store(&val, newval);
# else
    (void)"No AO_char_store";
# endif
# ifdef AO_HAVE_char_fetch_and_add
    (void)"AO_char_fetch_and_add(&val, incr):";
    (void)AO_char_fetch_and_add(&val, incr);
# else
    (void)"No AO_char_fetch_and_add";
# endif
# ifdef AO_HAVE_char_fetch_and_add1
    (void)"AO_char_fetch_and_add1(&val):";
    (void)AO_char_fetch_and_add1(&val);
# else
    (void)"No AO_char_fetch_and_add1";
# endif
# ifdef AO_HAVE_char_fetch_and_sub1
    (void)"AO_char_fetch_and_sub1(&val):";
    (void)AO_char_fetch_and_sub1(&val);
# else
    (void)"No AO_char_fetch_and_sub1";
# endif
# ifdef AO_HAVE_char_and
    (void)"AO_char_and(&val, incr):";
    AO_char_and(&val, incr);
# else
    (void)"No AO_char_and";
# endif
# ifdef AO_HAVE_char_or
    (void)"AO_char_or(&val, incr):";
    AO_char_or(&val, incr);
# else
    (void)"No AO_char_or";
# endif
# ifdef AO_HAVE_char_xor
    (void)"AO_char_xor(&val, incr):";
    AO_char_xor(&val, incr);
# else
    (void)"No AO_char_xor";
# endif
# ifdef AO_HAVE_char_compare_and_swap
    (void)"AO_char_compare_and_swap(&val, oldval, newval):";
    if (!AO_char_compare_and_swap(&val, oldval, newval))
      exit(1);
# else
    (void)"No AO_char_compare_and_swap";
# endif
  /* TODO: Add AO_compare_double_and_swap_double */
  /* TODO: Add AO_compare_and_swap_double */
# ifdef AO_HAVE_char_fetch_compare_and_swap
    (void)"AO_char_fetch_compare_and_swap(&val, oldval, newval):";
    if (AO_char_fetch_compare_and_swap(&val, oldval, newval) != oldval)
      exit(1);
# else
    (void)"No AO_char_fetch_compare_and_swap";
# endif

# if defined(AO_HAVE_test_and_set)
    (void)"AO_test_and_set(&ts):";
    (void)AO_test_and_set(&ts);
# else
    (void)"No AO_test_and_set";
# endif
}
/*
* Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
*
* This file is covered by the GNU general public license, version 2.
* see COPYING for details.
*/

/* This generates a compilable program.  But it is really meant to be   */
/* be used only with cc -E, to inspect the expensions generated by      */
/* primitives.                                                          */

/* The result will not link or run.                                     */

#include <stdlib.h> /* for exit() */

void char_list_atomic_release(void)
{
# if defined(AO_HAVE_char_load_release) || defined(AO_HAVE_char_store_release) \
     || defined(AO_HAVE_char_fetch_and_add_release) \
     || defined(AO_HAVE_char_fetch_and_add1_release) \
     || defined(AO_HAVE_char_and_release) \
     || defined(AO_HAVE_char_compare_and_swap_release) \
     || defined(AO_HAVE_char_fetch_compare_and_swap_release)
    static volatile unsigned/**/char val /* = 0 */;
# endif
# if defined(AO_HAVE_char_compare_and_swap_release) \
     || defined(AO_HAVE_char_fetch_compare_and_swap_release)
    static unsigned/**/char oldval /* = 0 */;
# endif
# if defined(AO_HAVE_char_store_release) \
     || defined(AO_HAVE_char_compare_and_swap_release) \
     || defined(AO_HAVE_char_fetch_compare_and_swap_release)
    static unsigned/**/char newval /* = 0 */;
# endif
# if defined(AO_HAVE_test_and_set_release)
    AO_TS_t ts = AO_TS_INITIALIZER;
# endif
# if defined(AO_HAVE_char_fetch_and_add_release) || defined(AO_HAVE_char_and_release) \
     || defined(AO_HAVE_char_or_release) || defined(AO_HAVE_char_xor_release)
    static unsigned/**/char incr /* = 0 */;
# endif

# if defined(AO_HAVE_nop_release)
    (void)"AO_nop_release(): ";
    AO_nop_release();
# else
    (void)"No AO_nop_release";
# endif

# ifdef AO_HAVE_char_load_release
    (void)"AO_char_load_release(&val):";
    (void)AO_char_load_release(&val);
# else
    (void)"No AO_char_load_release";
# endif
# ifdef AO_HAVE_char_store_release
    (void)"AO_char_store_release(&val, newval):";
    AO_char_store_release(&val, newval);
# else
    (void)"No AO_char_store_release";
# endif
# ifdef AO_HAVE_char_fetch_and_add_release
    (void)"AO_char_fetch_and_add_release(&val, incr):";
    (void)AO_char_fetch_and_add_release(&val, incr);
# else
    (void)"No AO_char_fetch_and_add_release";
# endif
# ifdef AO_HAVE_char_fetch_and_add1_release
    (void)"AO_char_fetch_and_add1_release(&val):";
    (void)AO_char_fetch_and_add1_release(&val);
# else
    (void)"No AO_char_fetch_and_add1_release";
# endif
# ifdef AO_HAVE_char_fetch_and_sub1_release
    (void)"AO_char_fetch_and_sub1_release(&val):";
    (void)AO_char_fetch_and_sub1_release(&val);
# else
    (void)"No AO_char_fetch_and_sub1_release";
# endif
# ifdef AO_HAVE_char_and_release
    (void)"AO_char_and_release(&val, incr):";
    AO_char_and_release(&val, incr);
# else
    (void)"No AO_char_and_release";
# endif
# ifdef AO_HAVE_char_or_release
    (void)"AO_char_or_release(&val, incr):";
    AO_char_or_release(&val, incr);
# else
    (void)"No AO_char_or_release";
# endif
# ifdef AO_HAVE_char_xor_release
    (void)"AO_char_xor_release(&val, incr):";
    AO_char_xor_release(&val, incr);
# else
    (void)"No AO_char_xor_release";
# endif
# ifdef AO_HAVE_char_compare_and_swap_release
    (void)"AO_char_compare_and_swap_release(&val, oldval, newval):";
    if (!AO_char_compare_and_swap_release(&val, oldval, newval))
      exit(1);
# else
    (void)"No AO_char_compare_and_swap_release";
# endif
  /* TODO: Add AO_compare_double_and_swap_double_release */
  /* TODO: Add AO_compare_and_swap_double_release */
# ifdef AO_HAVE_char_fetch_compare_and_swap_release
    (void)"AO_char_fetch_compare_and_swap_release(&val, oldval, newval):";
    if (AO_char_fetch_compare_and_swap_release(&val, oldval, newval) != oldval)
      exit(1);
# else
    (void)"No AO_char_fetch_compare_and_swap_release";
# endif

# if defined(AO_HAVE_test_and_set_release)
    (void)"AO_test_and_set_release(&ts):";
    (void)AO_test_and_set_release(&ts);
# else
    (void)"No AO_test_and_set_release";
# endif
}
/*
* Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
*
* This file is covered by the GNU general public license, version 2.
* see COPYING for details.
*/

/* This generates a compilable program.  But it is really meant to be   */
/* be used only with cc -E, to inspect the expensions generated by      */
/* primitives.                                                          */

/* The result will not link or run.                                     */

#include <stdlib.h> /* for exit() */

void char_list_atomic_acquire(void)
{
# if defined(AO_HAVE_char_load_acquire) || defined(AO_HAVE_char_store_acquire) \
     || defined(AO_HAVE_char_fetch_and_add_acquire) \
     || defined(AO_HAVE_char_fetch_and_add1_acquire) \
     || defined(AO_HAVE_char_and_acquire) \
     || defined(AO_HAVE_char_compare_and_swap_acquire) \
     || defined(AO_HAVE_char_fetch_compare_and_swap_acquire)
    static volatile unsigned/**/char val /* = 0 */;
# endif
# if defined(AO_HAVE_char_compare_and_swap_acquire) \
     || defined(AO_HAVE_char_fetch_compare_and_swap_acquire)
    static unsigned/**/char oldval /* = 0 */;
# endif
# if defined(AO_HAVE_char_store_acquire) \
     || defined(AO_HAVE_char_compare_and_swap_acquire) \
     || defined(AO_HAVE_char_fetch_compare_and_swap_acquire)
    static unsigned/**/char newval /* = 0 */;
# endif
# if defined(AO_HAVE_test_and_set_acquire)
    AO_TS_t ts = AO_TS_INITIALIZER;
# endif
# if defined(AO_HAVE_char_fetch_and_add_acquire) || defined(AO_HAVE_char_and_acquire) \
     || defined(AO_HAVE_char_or_acquire) || defined(AO_HAVE_char_xor_acquire)
    static unsigned/**/char incr /* = 0 */;
# endif

# if defined(AO_HAVE_nop_acquire)
    (void)"AO_nop_acquire(): ";
    AO_nop_acquire();
# else
    (void)"No AO_nop_acquire";
# endif

# ifdef AO_HAVE_char_load_acquire
    (void)"AO_char_load_acquire(&val):";
    (void)AO_char_load_acquire(&val);
# else
    (void)"No AO_char_load_acquire";
# endif
# ifdef AO_HAVE_char_store_acquire
    (void)"AO_char_store_acquire(&val, newval):";
    AO_char_store_acquire(&val, newval);
# else
    (void)"No AO_char_store_acquire";
# endif
# ifdef AO_HAVE_char_fetch_and_add_acquire
    (void)"AO_char_fetch_and_add_acquire(&val, incr):";
    (void)AO_char_fetch_and_add_acquire(&val, incr);
# else
    (void)"No AO_char_fetch_and_add_acquire";
# endif
# ifdef AO_HAVE_char_fetch_and_add1_acquire
    (void)"AO_char_fetch_and_add1_acquire(&val):";
    (void)AO_char_fetch_and_add1_acquire(&val);
# else
    (void)"No AO_char_fetch_and_add1_acquire";
# endif
# ifdef AO_HAVE_char_fetch_and_sub1_acquire
    (void)"AO_char_fetch_and_sub1_acquire(&val):";
    (void)AO_char_fetch_and_sub1_acquire(&val);
# else
    (void)"No AO_char_fetch_and_sub1_acquire";
# endif
# ifdef AO_HAVE_char_and_acquire
    (void)"AO_char_and_acquire(&val, incr):";
    AO_char_and_acquire(&val, incr);
# else
    (void)"No AO_char_and_acquire";
# endif
# ifdef AO_HAVE_char_or_acquire
    (void)"AO_char_or_acquire(&val, incr):";
    AO_char_or_acquire(&val, incr);
# else
    (void)"No AO_char_or_acquire";
# endif
# ifdef AO_HAVE_char_xor_acquire
    (void)"AO_char_xor_acquire(&val, incr):";
    AO_char_xor_acquire(&val, incr);
# else
    (void)"No AO_char_xor_acquire";
# endif
# ifdef AO_HAVE_char_compare_and_swap_acquire
    (void)"AO_char_compare_and_swap_acquire(&val, oldval, newval):";
    if (!AO_char_compare_and_swap_acquire(&val, oldval, newval))
      exit(1);
# else
    (void)"No AO_char_compare_and_swap_acquire";
# endif
  /* TODO: Add AO_compare_double_and_swap_double_acquire */
  /* TODO: Add AO_compare_and_swap_double_acquire */
# ifdef AO_HAVE_char_fetch_compare_and_swap_acquire
    (void)"AO_char_fetch_compare_and_swap_acquire(&val, oldval, newval):";
    if (AO_char_fetch_compare_and_swap_acquire(&val, oldval, newval) != oldval)
      exit(1);
# else
    (void)"No AO_char_fetch_compare_and_swap_acquire";
# endif

# if defined(AO_HAVE_test_and_set_acquire)
    (void)"AO_test_and_set_acquire(&ts):";
    (void)AO_test_and_set_acquire(&ts);
# else
    (void)"No AO_test_and_set_acquire";
# endif
}
/*
* Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
*
* This file is covered by the GNU general public license, version 2.
* see COPYING for details.
*/

/* This generates a compilable program.  But it is really meant to be   */
/* be used only with cc -E, to inspect the expensions generated by      */
/* primitives.                                                          */

/* The result will not link or run.                                     */

#include <stdlib.h> /* for exit() */

void char_list_atomic_read(void)
{
# if defined(AO_HAVE_char_load_read) || defined(AO_HAVE_char_store_read) \
     || defined(AO_HAVE_char_fetch_and_add_read) \
     || defined(AO_HAVE_char_fetch_and_add1_read) \
     || defined(AO_HAVE_char_and_read) \
     || defined(AO_HAVE_char_compare_and_swap_read) \
     || defined(AO_HAVE_char_fetch_compare_and_swap_read)
    static volatile unsigned/**/char val /* = 0 */;
# endif
# if defined(AO_HAVE_char_compare_and_swap_read) \
     || defined(AO_HAVE_char_fetch_compare_and_swap_read)
    static unsigned/**/char oldval /* = 0 */;
# endif
# if defined(AO_HAVE_char_store_read) \
     || defined(AO_HAVE_char_compare_and_swap_read) \
     || defined(AO_HAVE_char_fetch_compare_and_swap_read)
    static unsigned/**/char newval /* = 0 */;
# endif
# if defined(AO_HAVE_test_and_set_read)
    AO_TS_t ts = AO_TS_INITIALIZER;
# endif
# if defined(AO_HAVE_char_fetch_and_add_read) || defined(AO_HAVE_char_and_read) \
     || defined(AO_HAVE_char_or_read) || defined(AO_HAVE_char_xor_read)
    static unsigned/**/char incr /* = 0 */;
# endif

# if defined(AO_HAVE_nop_read)
    (void)"AO_nop_read(): ";
    AO_nop_read();
# else
    (void)"No AO_nop_read";
# endif

# ifdef AO_HAVE_char_load_read
    (void)"AO_char_load_read(&val):";
    (void)AO_char_load_read(&val);
# else
    (void)"No AO_char_load_read";
# endif
# ifdef AO_HAVE_char_store_read
    (void)"AO_char_store_read(&val, newval):";
    AO_char_store_read(&val, newval);
# else
    (void)"No AO_char_store_read";
# endif
# ifdef AO_HAVE_char_fetch_and_add_read
    (void)"AO_char_fetch_and_add_read(&val, incr):";
    (void)AO_char_fetch_and_add_read(&val, incr);
# else
    (void)"No AO_char_fetch_and_add_read";
# endif
# ifdef AO_HAVE_char_fetch_and_add1_read
    (void)"AO_char_fetch_and_add1_read(&val):";
    (void)AO_char_fetch_and_add1_read(&val);
# else
    (void)"No AO_char_fetch_and_add1_read";
# endif
# ifdef AO_HAVE_char_fetch_and_sub1_read
    (void)"AO_char_fetch_and_sub1_read(&val):";
    (void)AO_char_fetch_and_sub1_read(&val);
# else
    (void)"No AO_char_fetch_and_sub1_read";
# endif
# ifdef AO_HAVE_char_and_read
    (void)"AO_char_and_read(&val, incr):";
    AO_char_and_read(&val, incr);
# else
    (void)"No AO_char_and_read";
# endif
# ifdef AO_HAVE_char_or_read
    (void)"AO_char_or_read(&val, incr):";
    AO_char_or_read(&val, incr);
# else
    (void)"No AO_char_or_read";
# endif
# ifdef AO_HAVE_char_xor_read
    (void)"AO_char_xor_read(&val, incr):";
    AO_char_xor_read(&val, incr);
# else
    (void)"No AO_char_xor_read";
# endif
# ifdef AO_HAVE_char_compare_and_swap_read
    (void)"AO_char_compare_and_swap_read(&val, oldval, newval):";
    if (!AO_char_compare_and_swap_read(&val, oldval, newval))
      exit(1);
# else
    (void)"No AO_char_compare_and_swap_read";
# endif
  /* TODO: Add AO_compare_double_and_swap_double_read */
  /* TODO: Add AO_compare_and_swap_double_read */
# ifdef AO_HAVE_char_fetch_compare_and_swap_read
    (void)"AO_char_fetch_compare_and_swap_read(&val, oldval, newval):";
    if (AO_char_fetch_compare_and_swap_read(&val, oldval, newval) != oldval)
      exit(1);
# else
    (void)"No AO_char_fetch_compare_and_swap_read";
# endif

# if defined(AO_HAVE_test_and_set_read)
    (void)"AO_test_and_set_read(&ts):";
    (void)AO_test_and_set_read(&ts);
# else
    (void)"No AO_test_and_set_read";
# endif
}
/*
* Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
*
* This file is covered by the GNU general public license, version 2.
* see COPYING for details.
*/

/* This generates a compilable program.  But it is really meant to be   */
/* be used only with cc -E, to inspect the expensions generated by      */
/* primitives.                                                          */

/* The result will not link or run.                                     */

#include <stdlib.h> /* for exit() */

void char_list_atomic_write(void)
{
# if defined(AO_HAVE_char_load_write) || defined(AO_HAVE_char_store_write) \
     || defined(AO_HAVE_char_fetch_and_add_write) \
     || defined(AO_HAVE_char_fetch_and_add1_write) \
     || defined(AO_HAVE_char_and_write) \
     || defined(AO_HAVE_char_compare_and_swap_write) \
     || defined(AO_HAVE_char_fetch_compare_and_swap_write)
    static volatile unsigned/**/char val /* = 0 */;
# endif
# if defined(AO_HAVE_char_compare_and_swap_write) \
     || defined(AO_HAVE_char_fetch_compare_and_swap_write)
    static unsigned/**/char oldval /* = 0 */;
# endif
# if defined(AO_HAVE_char_store_write) \
     || defined(AO_HAVE_char_compare_and_swap_write) \
     || defined(AO_HAVE_char_fetch_compare_and_swap_write)
    static unsigned/**/char newval /* = 0 */;
# endif
# if defined(AO_HAVE_test_and_set_write)
    AO_TS_t ts = AO_TS_INITIALIZER;
# endif
# if defined(AO_HAVE_char_fetch_and_add_write) || defined(AO_HAVE_char_and_write) \
     || defined(AO_HAVE_char_or_write) || defined(AO_HAVE_char_xor_write)
    static unsigned/**/char incr /* = 0 */;
# endif

# if defined(AO_HAVE_nop_write)
    (void)"AO_nop_write(): ";
    AO_nop_write();
# else
    (void)"No AO_nop_write";
# endif

# ifdef AO_HAVE_char_load_write
    (void)"AO_char_load_write(&val):";
    (void)AO_char_load_write(&val);
# else
    (void)"No AO_char_load_write";
# endif
# ifdef AO_HAVE_char_store_write
    (void)"AO_char_store_write(&val, newval):";
    AO_char_store_write(&val, newval);
# else
    (void)"No AO_char_store_write";
# endif
# ifdef AO_HAVE_char_fetch_and_add_write
    (void)"AO_char_fetch_and_add_write(&val, incr):";
    (void)AO_char_fetch_and_add_write(&val, incr);
# else
    (void)"No AO_char_fetch_and_add_write";
# endif
# ifdef AO_HAVE_char_fetch_and_add1_write
    (void)"AO_char_fetch_and_add1_write(&val):";
    (void)AO_char_fetch_and_add1_write(&val);
# else
    (void)"No AO_char_fetch_and_add1_write";
# endif
# ifdef AO_HAVE_char_fetch_and_sub1_write
    (void)"AO_char_fetch_and_sub1_write(&val):";
    (void)AO_char_fetch_and_sub1_write(&val);
# else
    (void)"No AO_char_fetch_and_sub1_write";
# endif
# ifdef AO_HAVE_char_and_write
    (void)"AO_char_and_write(&val, incr):";
    AO_char_and_write(&val, incr);
# else
    (void)"No AO_char_and_write";
# endif
# ifdef AO_HAVE_char_or_write
    (void)"AO_char_or_write(&val, incr):";
    AO_char_or_write(&val, incr);
# else
    (void)"No AO_char_or_write";
# endif
# ifdef AO_HAVE_char_xor_write
    (void)"AO_char_xor_write(&val, incr):";
    AO_char_xor_write(&val, incr);
# else
    (void)"No AO_char_xor_write";
# endif
# ifdef AO_HAVE_char_compare_and_swap_write
    (void)"AO_char_compare_and_swap_write(&val, oldval, newval):";
    if (!AO_char_compare_and_swap_write(&val, oldval, newval))
      exit(1);
# else
    (void)"No AO_char_compare_and_swap_write";
# endif
  /* TODO: Add AO_compare_double_and_swap_double_write */
  /* TODO: Add AO_compare_and_swap_double_write */
# ifdef AO_HAVE_char_fetch_compare_and_swap_write
    (void)"AO_char_fetch_compare_and_swap_write(&val, oldval, newval):";
    if (AO_char_fetch_compare_and_swap_write(&val, oldval, newval) != oldval)
      exit(1);
# else
    (void)"No AO_char_fetch_compare_and_swap_write";
# endif

# if defined(AO_HAVE_test_and_set_write)
    (void)"AO_test_and_set_write(&ts):";
    (void)AO_test_and_set_write(&ts);
# else
    (void)"No AO_test_and_set_write";
# endif
}
/*
* Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
*
* This file is covered by the GNU general public license, version 2.
* see COPYING for details.
*/

/* This generates a compilable program.  But it is really meant to be   */
/* be used only with cc -E, to inspect the expensions generated by      */
/* primitives.                                                          */

/* The result will not link or run.                                     */

#include <stdlib.h> /* for exit() */

void char_list_atomic_full(void)
{
# if defined(AO_HAVE_char_load_full) || defined(AO_HAVE_char_store_full) \
     || defined(AO_HAVE_char_fetch_and_add_full) \
     || defined(AO_HAVE_char_fetch_and_add1_full) \
     || defined(AO_HAVE_char_and_full) \
     || defined(AO_HAVE_char_compare_and_swap_full) \
     || defined(AO_HAVE_char_fetch_compare_and_swap_full)
    static volatile unsigned/**/char val /* = 0 */;
# endif
# if defined(AO_HAVE_char_compare_and_swap_full) \
     || defined(AO_HAVE_char_fetch_compare_and_swap_full)
    static unsigned/**/char oldval /* = 0 */;
# endif
# if defined(AO_HAVE_char_store_full) \
     || defined(AO_HAVE_char_compare_and_swap_full) \
     || defined(AO_HAVE_char_fetch_compare_and_swap_full)
    static unsigned/**/char newval /* = 0 */;
# endif
# if defined(AO_HAVE_test_and_set_full)
    AO_TS_t ts = AO_TS_INITIALIZER;
# endif
# if defined(AO_HAVE_char_fetch_and_add_full) || defined(AO_HAVE_char_and_full) \
     || defined(AO_HAVE_char_or_full) || defined(AO_HAVE_char_xor_full)
    static unsigned/**/char incr /* = 0 */;
# endif

# if defined(AO_HAVE_nop_full)
    (void)"AO_nop_full(): ";
    AO_nop_full();
# else
    (void)"No AO_nop_full";
# endif

# ifdef AO_HAVE_char_load_full
    (void)"AO_char_load_full(&val):";
    (void)AO_char_load_full(&val);
# else
    (void)"No AO_char_load_full";
# endif
# ifdef AO_HAVE_char_store_full
    (void)"AO_char_store_full(&val, newval):";
    AO_char_store_full(&val, newval);
# else
    (void)"No AO_char_store_full";
# endif
# ifdef AO_HAVE_char_fetch_and_add_full
    (void)"AO_char_fetch_and_add_full(&val, incr):";
    (void)AO_char_fetch_and_add_full(&val, incr);
# else
    (void)"No AO_char_fetch_and_add_full";
# endif
# ifdef AO_HAVE_char_fetch_and_add1_full
    (void)"AO_char_fetch_and_add1_full(&val):";
    (void)AO_char_fetch_and_add1_full(&val);
# else
    (void)"No AO_char_fetch_and_add1_full";
# endif
# ifdef AO_HAVE_char_fetch_and_sub1_full
    (void)"AO_char_fetch_and_sub1_full(&val):";
    (void)AO_char_fetch_and_sub1_full(&val);
# else
    (void)"No AO_char_fetch_and_sub1_full";
# endif
# ifdef AO_HAVE_char_and_full
    (void)"AO_char_and_full(&val, incr):";
    AO_char_and_full(&val, incr);
# else
    (void)"No AO_char_and_full";
# endif
# ifdef AO_HAVE_char_or_full
    (void)"AO_char_or_full(&val, incr):";
    AO_char_or_full(&val, incr);
# else
    (void)"No AO_char_or_full";
# endif
# ifdef AO_HAVE_char_xor_full
    (void)"AO_char_xor_full(&val, incr):";
    AO_char_xor_full(&val, incr);
# else
    (void)"No AO_char_xor_full";
# endif
# ifdef AO_HAVE_char_compare_and_swap_full
    (void)"AO_char_compare_and_swap_full(&val, oldval, newval):";
    if (!AO_char_compare_and_swap_full(&val, oldval, newval))
      exit(1);
# else
    (void)"No AO_char_compare_and_swap_full";
# endif
  /* TODO: Add AO_compare_double_and_swap_double_full */
  /* TODO: Add AO_compare_and_swap_double_full */
# ifdef AO_HAVE_char_fetch_compare_and_swap_full
    (void)"AO_char_fetch_compare_and_swap_full(&val, oldval, newval):";
    if (AO_char_fetch_compare_and_swap_full(&val, oldval, newval) != oldval)
      exit(1);
# else
    (void)"No AO_char_fetch_compare_and_swap_full";
# endif

# if defined(AO_HAVE_test_and_set_full)
    (void)"AO_test_and_set_full(&ts):";
    (void)AO_test_and_set_full(&ts);
# else
    (void)"No AO_test_and_set_full";
# endif
}
/*
* Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
*
* This file is covered by the GNU general public license, version 2.
* see COPYING for details.
*/

/* This generates a compilable program.  But it is really meant to be   */
/* be used only with cc -E, to inspect the expensions generated by      */
/* primitives.                                                          */

/* The result will not link or run.                                     */

#include <stdlib.h> /* for exit() */

void char_list_atomic_release_write(void)
{
# if defined(AO_HAVE_char_load_release_write) || defined(AO_HAVE_char_store_release_write) \
     || defined(AO_HAVE_char_fetch_and_add_release_write) \
     || defined(AO_HAVE_char_fetch_and_add1_release_write) \
     || defined(AO_HAVE_char_and_release_write) \
     || defined(AO_HAVE_char_compare_and_swap_release_write) \
     || defined(AO_HAVE_char_fetch_compare_and_swap_release_write)
    static volatile unsigned/**/char val /* = 0 */;
# endif
# if defined(AO_HAVE_char_compare_and_swap_release_write) \
     || defined(AO_HAVE_char_fetch_compare_and_swap_release_write)
    static unsigned/**/char oldval /* = 0 */;
# endif
# if defined(AO_HAVE_char_store_release_write) \
     || defined(AO_HAVE_char_compare_and_swap_release_write) \
     || defined(AO_HAVE_char_fetch_compare_and_swap_release_write)
    static unsigned/**/char newval /* = 0 */;
# endif
# if defined(AO_HAVE_test_and_set_release_write)
    AO_TS_t ts = AO_TS_INITIALIZER;
# endif
# if defined(AO_HAVE_char_fetch_and_add_release_write) || defined(AO_HAVE_char_and_release_write) \
     || defined(AO_HAVE_char_or_release_write) || defined(AO_HAVE_char_xor_release_write)
    static unsigned/**/char incr /* = 0 */;
# endif

# if defined(AO_HAVE_nop_release_write)
    (void)"AO_nop_release_write(): ";
    AO_nop_release_write();
# else
    (void)"No AO_nop_release_write";
# endif

# ifdef AO_HAVE_char_load_release_write
    (void)"AO_char_load_release_write(&val):";
    (void)AO_char_load_release_write(&val);
# else
    (void)"No AO_char_load_release_write";
# endif
# ifdef AO_HAVE_char_store_release_write
    (void)"AO_char_store_release_write(&val, newval):";
    AO_char_store_release_write(&val, newval);
# else
    (void)"No AO_char_store_release_write";
# endif
# ifdef AO_HAVE_char_fetch_and_add_release_write
    (void)"AO_char_fetch_and_add_release_write(&val, incr):";
    (void)AO_char_fetch_and_add_release_write(&val, incr);
# else
    (void)"No AO_char_fetch_and_add_release_write";
# endif
# ifdef AO_HAVE_char_fetch_and_add1_release_write
    (void)"AO_char_fetch_and_add1_release_write(&val):";
    (void)AO_char_fetch_and_add1_release_write(&val);
# else
    (void)"No AO_char_fetch_and_add1_release_write";
# endif
# ifdef AO_HAVE_char_fetch_and_sub1_release_write
    (void)"AO_char_fetch_and_sub1_release_write(&val):";
    (void)AO_char_fetch_and_sub1_release_write(&val);
# else
    (void)"No AO_char_fetch_and_sub1_release_write";
# endif
# ifdef AO_HAVE_char_and_release_write
    (void)"AO_char_and_release_write(&val, incr):";
    AO_char_and_release_write(&val, incr);
# else
    (void)"No AO_char_and_release_write";
# endif
# ifdef AO_HAVE_char_or_release_write
    (void)"AO_char_or_release_write(&val, incr):";
    AO_char_or_release_write(&val, incr);
# else
    (void)"No AO_char_or_release_write";
# endif
# ifdef AO_HAVE_char_xor_release_write
    (void)"AO_char_xor_release_write(&val, incr):";
    AO_char_xor_release_write(&val, incr);
# else
    (void)"No AO_char_xor_release_write";
# endif
# ifdef AO_HAVE_char_compare_and_swap_release_write
    (void)"AO_char_compare_and_swap_release_write(&val, oldval, newval):";
    if (!AO_char_compare_and_swap_release_write(&val, oldval, newval))
      exit(1);
# else
    (void)"No AO_char_compare_and_swap_release_write";
# endif
  /* TODO: Add AO_compare_double_and_swap_double_release_write */
  /* TODO: Add AO_compare_and_swap_double_release_write */
# ifdef AO_HAVE_char_fetch_compare_and_swap_release_write
    (void)"AO_char_fetch_compare_and_swap_release_write(&val, oldval, newval):";
    if (AO_char_fetch_compare_and_swap_release_write(&val, oldval, newval) != oldval)
      exit(1);
# else
    (void)"No AO_char_fetch_compare_and_swap_release_write";
# endif

# if defined(AO_HAVE_test_and_set_release_write)
    (void)"AO_test_and_set_release_write(&ts):";
    (void)AO_test_and_set_release_write(&ts);
# else
    (void)"No AO_test_and_set_release_write";
# endif
}
/*
* Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
*
* This file is covered by the GNU general public license, version 2.
* see COPYING for details.
*/

/* This generates a compilable program.  But it is really meant to be   */
/* be used only with cc -E, to inspect the expensions generated by      */
/* primitives.                                                          */

/* The result will not link or run.                                     */

#include <stdlib.h> /* for exit() */

void char_list_atomic_acquire_read(void)
{
# if defined(AO_HAVE_char_load_acquire_read) || defined(AO_HAVE_char_store_acquire_read) \
     || defined(AO_HAVE_char_fetch_and_add_acquire_read) \
     || defined(AO_HAVE_char_fetch_and_add1_acquire_read) \
     || defined(AO_HAVE_char_and_acquire_read) \
     || defined(AO_HAVE_char_compare_and_swap_acquire_read) \
     || defined(AO_HAVE_char_fetch_compare_and_swap_acquire_read)
    static volatile unsigned/**/char val /* = 0 */;
# endif
# if defined(AO_HAVE_char_compare_and_swap_acquire_read) \
     || defined(AO_HAVE_char_fetch_compare_and_swap_acquire_read)
    static unsigned/**/char oldval /* = 0 */;
# endif
# if defined(AO_HAVE_char_store_acquire_read) \
     || defined(AO_HAVE_char_compare_and_swap_acquire_read) \
     || defined(AO_HAVE_char_fetch_compare_and_swap_acquire_read)
    static unsigned/**/char newval /* = 0 */;
# endif
# if defined(AO_HAVE_test_and_set_acquire_read)
    AO_TS_t ts = AO_TS_INITIALIZER;
# endif
# if defined(AO_HAVE_char_fetch_and_add_acquire_read) || defined(AO_HAVE_char_and_acquire_read) \
     || defined(AO_HAVE_char_or_acquire_read) || defined(AO_HAVE_char_xor_acquire_read)
    static unsigned/**/char incr /* = 0 */;
# endif

# if defined(AO_HAVE_nop_acquire_read)
    (void)"AO_nop_acquire_read(): ";
    AO_nop_acquire_read();
# else
    (void)"No AO_nop_acquire_read";
# endif

# ifdef AO_HAVE_char_load_acquire_read
    (void)"AO_char_load_acquire_read(&val):";
    (void)AO_char_load_acquire_read(&val);
# else
    (void)"No AO_char_load_acquire_read";
# endif
# ifdef AO_HAVE_char_store_acquire_read
    (void)"AO_char_store_acquire_read(&val, newval):";
    AO_char_store_acquire_read(&val, newval);
# else
    (void)"No AO_char_store_acquire_read";
# endif
# ifdef AO_HAVE_char_fetch_and_add_acquire_read
    (void)"AO_char_fetch_and_add_acquire_read(&val, incr):";
    (void)AO_char_fetch_and_add_acquire_read(&val, incr);
# else
    (void)"No AO_char_fetch_and_add_acquire_read";
# endif
# ifdef AO_HAVE_char_fetch_and_add1_acquire_read
    (void)"AO_char_fetch_and_add1_acquire_read(&val):";
    (void)AO_char_fetch_and_add1_acquire_read(&val);
# else
    (void)"No AO_char_fetch_and_add1_acquire_read";
# endif
# ifdef AO_HAVE_char_fetch_and_sub1_acquire_read
    (void)"AO_char_fetch_and_sub1_acquire_read(&val):";
    (void)AO_char_fetch_and_sub1_acquire_read(&val);
# else
    (void)"No AO_char_fetch_and_sub1_acquire_read";
# endif
# ifdef AO_HAVE_char_and_acquire_read
    (void)"AO_char_and_acquire_read(&val, incr):";
    AO_char_and_acquire_read(&val, incr);
# else
    (void)"No AO_char_and_acquire_read";
# endif
# ifdef AO_HAVE_char_or_acquire_read
    (void)"AO_char_or_acquire_read(&val, incr):";
--> --------------------

--> maximum size reached

--> --------------------

quality99%

¤ Dauer der Verarbeitung: 0.30 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.