gc-7.2/libatomic_ops/tests/test_atomic.template

   1 /*
   2  * Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
   3  *
   4  * This file is covered by the GNU general public license, version 2.
   5  * see doc/COPYING for details.
   6  */
   7
   8 /* Some basic sanity tests.  These do not test the barrier semantics. */
   9
  10 #undef TA_assert
  11 #define TA_assert(e) \
  12   if (!(e)) { fprintf(stderr, "Assertion failed %s:%d (barrier: XX)\n", \
  13                     __FILE__, __LINE__), exit(1); }
  14
  15 #undef MISSING
  16 #define MISSING(name) \
  17   fprintf(stderr, "Missing: %s\n", #name "XX")
  18
  19 void test_atomicXX(void)
  20 {
  21   AO_t x;
  22   unsigned char b;
  23   unsigned short s;
  24   unsigned int zz;
  25 # if defined(AO_HAVE_test_and_setXX)
  26     AO_TS_t z = AO_TS_INITIALIZER;
  27 # endif
  28 # if defined(AO_HAVE_double_t)
  29     AO_double_t w;
  30     w.AO_val1 = 0;
  31     w.AO_val2 = 0;
  32 # endif
  33
  34 # if defined(AO_HAVE_nopXX)
  35     AO_nopXX();
  36 # else
  37     MISSING(AO_nop);
  38 # endif
  39 # if defined(AO_HAVE_storeXX)
  40     AO_storeXX(&x, 13);
  41     TA_assert (x == 13);
  42 # else
  43     MISSING(AO_store);
  44     x = 13;
  45 # endif
  46 # if defined(AO_HAVE_loadXX)
  47     TA_assert(AO_loadXX(&x) == 13);
  48 # else
  49     MISSING(AO_load);
  50 # endif
  51 # if defined(AO_HAVE_test_and_setXX)
  52     assert(AO_test_and_setXX(&z) == AO_TS_CLEAR);
  53     assert(AO_test_and_setXX(&z) == AO_TS_SET);
  54     assert(AO_test_and_setXX(&z) == AO_TS_SET);
  55     AO_CLEAR(&z);
  56 # else
  57     MISSING(AO_test_and_set);
  58 # endif
  59 # if defined(AO_HAVE_fetch_and_addXX)
  60     TA_assert(AO_fetch_and_addXX(&x, 42) == 13);
  61     TA_assert(AO_fetch_and_addXX(&x, -42) == 55);
  62 # else
  63     MISSING(AO_fetch_and_add);
  64 # endif
  65 # if defined(AO_HAVE_fetch_and_add1XX)
  66     TA_assert(AO_fetch_and_add1XX(&x) == 13);
  67 # else
  68     MISSING(AO_fetch_and_add1);
  69     ++x;
  70 # endif
  71 # if defined(AO_HAVE_fetch_and_sub1XX)
  72     TA_assert(AO_fetch_and_sub1XX(&x) == 14);
  73 # else
  74     MISSING(AO_fetch_and_sub1);
  75     --x;
  76 # endif
  77 # if defined(AO_HAVE_short_storeXX)
  78     AO_short_storeXX(&s, 13);
  79 # else
  80     MISSING(AO_short_store);
  81     s = 13;
  82 # endif
  83 # if defined(AO_HAVE_short_loadXX)
  84     TA_assert(AO_short_load(&s) == 13);
  85 # else
  86     MISSING(AO_short_load);
  87 # endif
  88 # if defined(AO_HAVE_short_fetch_and_addXX)
  89     TA_assert(AO_short_fetch_and_addXX(&s, 42) == 13);
  90     TA_assert(AO_short_fetch_and_addXX(&s, -42) == 55);
  91 # else
  92     MISSING(AO_short_fetch_and_add);
  93 # endif
  94 # if defined(AO_HAVE_short_fetch_and_add1XX)
  95     TA_assert(AO_short_fetch_and_add1XX(&s) == 13);
  96 # else
  97     MISSING(AO_short_fetch_and_add1);
  98     ++s;
  99 # endif
 100 # if defined(AO_HAVE_short_fetch_and_sub1XX)
 101     TA_assert(AO_short_fetch_and_sub1XX(&s) == 14);
 102 # else
 103     MISSING(AO_short_fetch_and_sub1);
 104     --s;
 105 # endif
 106 # if defined(AO_HAVE_char_storeXX)
 107     AO_char_storeXX(&b, 13);
 108 # else
 109     MISSING(AO_char_store);
 110     b = 13;
 111 # endif
 112 # if defined(AO_HAVE_char_loadXX)
 113     TA_assert(AO_char_load(&b) == 13);
 114 # else
 115     MISSING(AO_char_load);
 116 # endif
 117 # if defined(AO_HAVE_char_fetch_and_addXX)
 118     TA_assert(AO_char_fetch_and_addXX(&b, 42) == 13);
 119     TA_assert(AO_char_fetch_and_addXX(&b, -42) == 55);
 120 # else
 121     MISSING(AO_char_fetch_and_add);
 122 # endif
 123 # if defined(AO_HAVE_char_fetch_and_add1XX)
 124     TA_assert(AO_char_fetch_and_add1XX(&b) == 13);
 125 # else
 126     MISSING(AO_char_fetch_and_add1);
 127     ++b;
 128 # endif
 129 # if defined(AO_HAVE_char_fetch_and_sub1XX)
 130     TA_assert(AO_char_fetch_and_sub1XX(&b) == 14);
 131 # else
 132     MISSING(AO_char_fetch_and_sub1);
 133     --b;
 134 # endif
 135 # if defined(AO_HAVE_int_storeXX)
 136     AO_int_storeXX(&zz, 13);
 137 # else
 138     MISSING(AO_int_store);
 139     zz = 13;
 140 # endif
 141 # if defined(AO_HAVE_int_loadXX)
 142     TA_assert(AO_int_load(&zz) == 13);
 143 # else
 144     MISSING(AO_int_load);
 145 # endif
 146 # if defined(AO_HAVE_int_fetch_and_addXX)
 147     TA_assert(AO_int_fetch_and_addXX(&zz, 42) == 13);
 148     TA_assert(AO_int_fetch_and_addXX(&zz, -42) == 55);
 149 # else
 150     MISSING(AO_int_fetch_and_add);
 151 # endif
 152 # if defined(AO_HAVE_int_fetch_and_add1XX)
 153     TA_assert(AO_int_fetch_and_add1XX(&zz) == 13);
 154 # else
 155     MISSING(AO_int_fetch_and_add1);
 156     ++zz;
 157 # endif
 158 # if defined(AO_HAVE_int_fetch_and_sub1XX)
 159     TA_assert(AO_int_fetch_and_sub1XX(&zz) == 14);
 160 # else
 161     MISSING(AO_int_fetch_and_sub1);
 162     --zz;
 163 # endif
 164 # if defined(AO_HAVE_compare_and_swapXX)
 165     TA_assert(!AO_compare_and_swapXX(&x, 14, 42));
 166     TA_assert(x == 13);
 167     TA_assert(AO_compare_and_swapXX(&x, 13, 42));
 168     TA_assert(x == 42);
 169 # else
 170     MISSING(AO_compare_and_swap);
 171     if (x == 13) x = 42;
 172 # endif
 173 # if defined(AO_HAVE_orXX)
 174     AO_orXX(&x, 66);
 175     TA_assert(x == 106);
 176 # else
 177     MISSING(AO_or);
 178     x |= 34;
 179 # endif
 180 # if defined(AO_HAVE_compare_double_and_swap_doubleXX)
 181     TA_assert(!AO_compare_double_and_swap_doubleXX(&w, 17, 42, 12, 13));
 182     TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
 183     TA_assert(AO_compare_double_and_swap_doubleXX(&w, 0, 0, 12, 13));
 184     TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
 185     TA_assert(AO_compare_double_and_swap_doubleXX(&w, 12, 13, 17, 42));
 186     TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
 187     w.AO_val1 = 0; w.AO_val2 = 0;
 188 # else
 189     MISSING(AO_compare_double_and_swap_double);
 190 # endif
 191 # if defined(AO_HAVE_compare_and_swap_doubleXX)
 192     TA_assert(!AO_compare_and_swap_doubleXX(&w, 17, 12, 13));
 193     TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
 194     TA_assert(AO_compare_and_swap_doubleXX(&w, 0, 12, 13));
 195     TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
 196     TA_assert(AO_compare_and_swap_doubleXX(&w, 12, 17, 42));
 197     TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
 198 # else
 199     MISSING(AO_compare_and_swap_double);
 200 # endif
 201 }
 202
 203
 204