blob: 89ec63460cfb6fd16d887407bbdf8f9a7e383d4c [file] [log] [blame]
// Copyright (C) 2018-2022 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// { dg-do compile { target c++11 } }
// { dg-require-atomic-builtins "" }
#include <atomic>
void
test01()
{
struct X { };
struct Y { };
// Primary template
volatile std::atomic<X> v;
std::atomic<Y> a;
const std::memory_order mo = std::memory_order_seq_cst;
X x;
Y y;
auto r1 = atomic_is_lock_free(&v);
static_assert( std::is_same<decltype(r1), bool>::value, "" );
auto r2 = atomic_is_lock_free(&a);
static_assert( std::is_same<decltype(r2), bool>::value, "" );
atomic_init(&v, x);
atomic_init(&a, y);
atomic_store(&v, x);
atomic_store(&a, y);
atomic_store_explicit(&v, x, mo);
atomic_store_explicit(&a, y, mo);
auto r3 = atomic_load(&v);
static_assert( std::is_same<decltype(r3), X>::value, "" );
auto r4 = atomic_load(&a);
static_assert( std::is_same<decltype(r4), Y>::value, "" );
auto r5 = atomic_load_explicit(&v, mo);
static_assert( std::is_same<decltype(r5), X>::value, "" );
auto r6 = atomic_load_explicit(&a, mo);
static_assert( std::is_same<decltype(r6), Y>::value, "" );
auto r7 = atomic_exchange(&v, x);
static_assert( std::is_same<decltype(r7), X>::value, "" );
auto r8 = atomic_exchange(&a, y);
static_assert( std::is_same<decltype(r8), Y>::value, "" );
auto r9 = atomic_exchange_explicit(&v, x, mo);
static_assert( std::is_same<decltype(r9), X>::value, "" );
auto r10 = atomic_exchange_explicit(&a, y, mo);
static_assert( std::is_same<decltype(r10), Y>::value, "" );
auto r11 = atomic_compare_exchange_weak(&v, &x, x);
static_assert( std::is_same<decltype(r11), bool>::value, "" );
auto r12 = atomic_compare_exchange_weak(&a, &y, y);
static_assert( std::is_same<decltype(r12), bool>::value, "" );
auto r13 = atomic_compare_exchange_strong(&v, &x, x);
static_assert( std::is_same<decltype(r13), bool>::value, "" );
auto r14 = atomic_compare_exchange_strong(&a, &y, y);
static_assert( std::is_same<decltype(r14), bool>::value, "" );
auto r15 = atomic_compare_exchange_weak_explicit(&v, &x, x, mo, mo);
static_assert( std::is_same<decltype(r15), bool>::value, "" );
auto r16 = atomic_compare_exchange_weak_explicit(&a, &y, y, mo, mo);
static_assert( std::is_same<decltype(r16), bool>::value, "" );
auto r17 = atomic_compare_exchange_strong_explicit(&v, &x, x, mo, mo);
static_assert( std::is_same<decltype(r17), bool>::value, "" );
auto r18 = atomic_compare_exchange_strong_explicit(&a, &y, y, mo, mo);
static_assert( std::is_same<decltype(r18), bool>::value, "" );
}
void
test02()
{
// Specialization for bool
volatile std::atomic<bool> v;
std::atomic<bool> a;
const std::memory_order mo = std::memory_order_seq_cst;
bool b = false;
auto r1 = atomic_is_lock_free(&v);
static_assert( std::is_same<decltype(r1), bool>::value, "" );
auto r2 = atomic_is_lock_free(&a);
static_assert( std::is_same<decltype(r2), bool>::value, "" );
atomic_init(&v, b);
atomic_init(&a, b);
atomic_store(&v, b);
atomic_store(&a, b);
atomic_store_explicit(&v, b, mo);
atomic_store_explicit(&a, b, mo);
auto r3 = atomic_load(&v);
static_assert( std::is_same<decltype(r3), bool>::value, "" );
auto r4 = atomic_load(&a);
static_assert( std::is_same<decltype(r4), bool>::value, "" );
auto r5 = atomic_load_explicit(&v, mo);
static_assert( std::is_same<decltype(r5), bool>::value, "" );
auto r6 = atomic_load_explicit(&a, mo);
static_assert( std::is_same<decltype(r6), bool>::value, "" );
auto r7 = atomic_exchange(&v, b);
static_assert( std::is_same<decltype(r7), bool>::value, "" );
auto r8 = atomic_exchange(&a, b);
static_assert( std::is_same<decltype(r8), bool>::value, "" );
auto r9 = atomic_exchange_explicit(&v, b, mo);
static_assert( std::is_same<decltype(r9), bool>::value, "" );
auto r10 = atomic_exchange_explicit(&a, b, mo);
static_assert( std::is_same<decltype(r10), bool>::value, "" );
auto r11 = atomic_compare_exchange_weak(&v, &b, b);
static_assert( std::is_same<decltype(r11), bool>::value, "" );
auto r12 = atomic_compare_exchange_weak(&a, &b, b);
static_assert( std::is_same<decltype(r12), bool>::value, "" );
auto r13 = atomic_compare_exchange_strong(&v, &b, b);
static_assert( std::is_same<decltype(r13), bool>::value, "" );
auto r14 = atomic_compare_exchange_strong(&a, &b, b);
static_assert( std::is_same<decltype(r14), bool>::value, "" );
auto r15 = atomic_compare_exchange_weak_explicit(&v, &b, b, mo, mo);
static_assert( std::is_same<decltype(r15), bool>::value, "" );
auto r16 = atomic_compare_exchange_weak_explicit(&a, &b, b, mo, mo);
static_assert( std::is_same<decltype(r16), bool>::value, "" );
auto r17 = atomic_compare_exchange_strong_explicit(&v, &b, b, mo, mo);
static_assert( std::is_same<decltype(r17), bool>::value, "" );
auto r18 = atomic_compare_exchange_strong_explicit(&a, &b, b, mo, mo);
static_assert( std::is_same<decltype(r18), bool>::value, "" );
}
void
test03()
{
// Partial specialization for pointers
volatile std::atomic<int*> v;
std::atomic<long*> a;
const std::memory_order mo = std::memory_order_seq_cst;
int* i = nullptr;
long* l = nullptr;
auto r1 = atomic_is_lock_free(&v);
static_assert( std::is_same<decltype(r1), bool>::value, "" );
auto r2 = atomic_is_lock_free(&a);
static_assert( std::is_same<decltype(r2), bool>::value, "" );
atomic_init(&v, i);
atomic_init(&a, l);
atomic_store(&v, i);
atomic_store(&a, l);
atomic_store_explicit(&v, i, mo);
atomic_store_explicit(&a, l, mo);
auto r3 = atomic_load(&v);
static_assert( std::is_same<decltype(r3), int*>::value, "" );
auto r4 = atomic_load(&a);
static_assert( std::is_same<decltype(r4), long*>::value, "" );
auto r5 = atomic_load_explicit(&v, mo);
static_assert( std::is_same<decltype(r5), int*>::value, "" );
auto r6 = atomic_load_explicit(&a, mo);
static_assert( std::is_same<decltype(r6), long*>::value, "" );
auto r7 = atomic_exchange(&v, i);
static_assert( std::is_same<decltype(r7), int*>::value, "" );
auto r8 = atomic_exchange(&a, l);
static_assert( std::is_same<decltype(r8), long*>::value, "" );
auto r9 = atomic_exchange_explicit(&v, i, mo);
static_assert( std::is_same<decltype(r9), int*>::value, "" );
auto r10 = atomic_exchange_explicit(&a, l, mo);
static_assert( std::is_same<decltype(r10), long*>::value, "" );
auto r11 = atomic_compare_exchange_weak(&v, &i, i);
static_assert( std::is_same<decltype(r11), bool>::value, "" );
auto r12 = atomic_compare_exchange_weak(&a, &l, l);
static_assert( std::is_same<decltype(r12), bool>::value, "" );
auto r13 = atomic_compare_exchange_strong(&v, &i, i);
static_assert( std::is_same<decltype(r13), bool>::value, "" );
auto r14 = atomic_compare_exchange_strong(&a, &l, l);
static_assert( std::is_same<decltype(r14), bool>::value, "" );
auto r15 = atomic_compare_exchange_weak_explicit(&v, &i, i, mo, mo);
static_assert( std::is_same<decltype(r15), bool>::value, "" );
auto r16 = atomic_compare_exchange_weak_explicit(&a, &l, l, mo, mo);
static_assert( std::is_same<decltype(r16), bool>::value, "" );
auto r17 = atomic_compare_exchange_strong_explicit(&v, &i, i, mo, mo);
static_assert( std::is_same<decltype(r17), bool>::value, "" );
auto r18 = atomic_compare_exchange_strong_explicit(&a, &l, l, mo, mo);
static_assert( std::is_same<decltype(r18), bool>::value, "" );
auto r19 = atomic_fetch_add(&v, 1);
static_assert( std::is_same<decltype(r19), int*>::value, "" );
auto r20 = atomic_fetch_add(&a, 1);
static_assert( std::is_same<decltype(r20), long*>::value, "" );
auto r21 = atomic_fetch_add_explicit(&v, 1, mo);
static_assert( std::is_same<decltype(r21), int*>::value, "" );
auto r22 = atomic_fetch_add_explicit(&a, 1, mo);
static_assert( std::is_same<decltype(r22), long*>::value, "" );
auto r23 = atomic_fetch_sub(&v, 1);
static_assert( std::is_same<decltype(r23), int*>::value, "" );
auto r24 = atomic_fetch_sub(&a, 1);
static_assert( std::is_same<decltype(r24), long*>::value, "" );
auto r25 = atomic_fetch_sub_explicit(&v, 1, mo);
static_assert( std::is_same<decltype(r25), int*>::value, "" );
auto r26 = atomic_fetch_sub_explicit(&a, 1, mo);
static_assert( std::is_same<decltype(r26), long*>::value, "" );
}
void
test04()
{
struct base { };
struct derived : base { };
// Partial specialization for pointers
volatile std::atomic<base*> v;
std::atomic<base*> a;
const std::memory_order mo = std::memory_order_seq_cst;
// Repeat tests with arguments of type different to value_type.
derived* const p = nullptr;
base* b = nullptr;
atomic_init(&v, p);
atomic_init(&a, p);
atomic_store(&v, p);
atomic_store(&a, p);
atomic_store_explicit(&v, p, mo);
atomic_store_explicit(&a, p, mo);
atomic_exchange(&v, p);
atomic_exchange(&a, p);
atomic_exchange_explicit(&v, p, mo);
atomic_exchange_explicit(&a, p, mo);
atomic_compare_exchange_weak(&v, &b, p);
atomic_compare_exchange_weak(&a, &b, p);
atomic_compare_exchange_strong(&v, &b, p);
atomic_compare_exchange_strong(&a, &b, p);
atomic_compare_exchange_weak_explicit(&v, &b, p, mo, mo);
atomic_compare_exchange_weak_explicit(&a, &b, p, mo, mo);
atomic_compare_exchange_strong_explicit(&v, &b, p, mo, mo);
atomic_compare_exchange_strong_explicit(&a, &b, p, mo, mo);
}