clang-tools-extra/test/clang-tidy/zircon-fbl-atomic.cpp

// RUN: %check_clang_tidy %s zircon-fbl-atomic %t -- -- -isystem %S/Inputs/zircon

#include <fbl/atomic.h>
// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: including fbl/atomic.h is deprecated
// CHECK-FIXES-NOT: #include <fbl/atomic.h>

namespace fbl {

enum memory_order : int {
  memory_order_relaxed = 0,
  memory_order_acquire = 1,
  memory_order_release = 2,
  memory_order_acq_rel = 3,
  memory_order_seq_cst = 4,
};

template <typename T> struct atomic {

  bool compare_exchange_weak(T *expected, T desired,
                             memory_order success_order,  
                             memory_order failure_order) {
    return true;
  }
  bool compare_exchange_strong(T *expected, T desired,
                               memory_order success_order,  
                               memory_order failure_order) {
    return true;
  }
};

template <class T> struct atomic<T *> {
  bool compare_exchange_weak(T **expected, T *desired,
                             memory_order success_order,  
                             memory_order failure_order) {
    return true;
  }

  bool compare_exchange_strong(T **expected, T *desired,
                               memory_order success_order,
                               memory_order failure_order) {
    return true;
  }
};

template <typename T>
void atomic_store(atomic<T> *atomic_ptr, T value,
                  memory_order order = memory_order_seq_cst) {} // NOLINT

template <typename T> void atomic_init(atomic<T> *atomic_ptr, T value) {}
void atomic_thread_fence(memory_order order = memory_order_seq_cst) {} // NOLINT
void atomic_signal_fence(memory_order order = memory_order_seq_cst) {} // NOLINT

using atomic_char = atomic<char>;

} // namespace fbl

namespace std {

typedef enum memory_order {
  memory_order_relaxed,
  memory_order_consume, // load-consume
  memory_order_acquire, // load-acquire
  memory_order_release, // store-release
  memory_order_acq_rel, // store-release load-acquire
  memory_order_seq_cst  // store-release load-acquire
} memory_order;

template <class T> struct atomic {
  bool compare_exchange_weak(T &expc, T desr, memory_order s, memory_order f) {
    return true;
  }
  bool compare_exchange_strong(T &expc, T desr, memory_order s,
                               memory_order f) {
    return true;
  }
};

template <class T> struct atomic<T *> {
  bool compare_exchange_weak(T *&expc, T *desr, memory_order s,
                             memory_order f) {
    return true;
  }
  bool compare_exchange_strong(T *&expc, T *desr, memory_order s,
                               memory_order f) {
    return true;
  }
};

template <class _Tp>
inline void atomic_store(atomic<_Tp> *__o, _Tp __d) {}
template <class _Tp>
inline void atomic_store_explicit(atomic<_Tp> *__o, _Tp __d, memory_order __m) {
}

template <class T> void atomic_init(atomic<T> *obj, T desr) {}
void atomic_thread_fence(memory_order m) {}
void atomic_signal_fence(memory_order m) {}

typedef atomic<char> atomic_char;

} // namespace std

int main() {
  int a = fbl::memory_order_relaxed;
  // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: use of fbl::memory_order_relaxed is deprecated, use std::memory_order_relaxed instead
  // CHECK-FIXES: int a = std::memory_order_relaxed;
  int b = std::memory_order_relaxed;

  int c = fbl::memory_order_acquire;
  // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: use of fbl::memory_order_acquire is deprecated, use std::memory_order_acquire instead
  // CHECK-FIXES: int c = std::memory_order_acquire;
  int d = std::memory_order_acquire;

  int e = fbl::memory_order_release;
  // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: use of fbl::memory_order_release is deprecated, use std::memory_order_release instead
  // CHECK-FIXES: int e = std::memory_order_release;
  int f = std::memory_order_release;

  int g = fbl::memory_order_acq_rel;
  // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: use of fbl::memory_order_acq_rel is deprecated, use std::memory_order_acq_rel instead
  // CHECK-FIXES: int g = std::memory_order_acq_rel;
  int h = std::memory_order_acq_rel;

  fbl::memory_order order = fbl::memory_order_seq_cst;
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use of fbl::memory_order is deprecated, use std::memory_order instead
  // CHECK-MESSAGES: :[[@LINE-2]]:29: warning: use of fbl::memory_order_seq_cst is deprecated, use std::memory_order_seq_cst instead
  // CHECK-FIXES: std::memory_order order = std::memory_order_seq_cst;
  std::memory_order order_std = std::memory_order_seq_cst;

  int expc = 1;
  int *expc_ptr = &expc;
  int desr = 2;

  fbl::atomic<int> k;
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use of fbl::atomic<int> is deprecated, use std::atomic<int> instead
  // CHECK-FIXES: std::atomic<int> k;
  std::atomic<int> l;

  bool weak_k = k.compare_exchange_weak(&expc, desr, order, order);
  // CHECK-MESSAGES: :[[@LINE-1]]:41: warning: std::atomic requires references instead of pointers
  // CHECK-FIXES: bool weak_k = k.compare_exchange_weak(expc, desr, order, order);
  bool weak_ptr_k = k.compare_exchange_weak(expc_ptr, desr, order, order);
  // CHECK-MESSAGES: :[[@LINE-1]]:45: warning: std::atomic requires references instead of pointers
  // CHECK-FIXES: bool weak_ptr_k = k.compare_exchange_weak(*expc_ptr, desr, order, order);

  bool strong_k = k.compare_exchange_strong(&expc, desr, order, order);
  // CHECK-MESSAGES: :[[@LINE-1]]:45: warning: std::atomic requires references instead of pointers
  // CHECK-FIXES: bool strong_k = k.compare_exchange_strong(expc, desr, order, order);
  bool strong_ptr_k = k.compare_exchange_strong(expc_ptr, desr, order, order);
  // CHECK-MESSAGES: :[[@LINE-1]]:49: warning: std::atomic requires references instead of pointers
  // CHECK-FIXES: bool strong_ptr_k = k.compare_exchange_strong(*expc_ptr, desr, order, order);

  bool weak_l = l.compare_exchange_weak(expc, desr, order_std, order_std);
  bool weak_ptr_l = l.compare_exchange_weak(*expc_ptr, desr, order_std, order_std);

  bool strong_l = l.compare_exchange_strong(expc, desr, order_std, order_std);
  bool strong_ptr_l = l.compare_exchange_strong(*expc_ptr, desr, order_std, order_std);

  int **expc_ptr_ptr = &expc_ptr;
  int *desr_ptr = &desr;

  fbl::atomic<int *> m;
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use of fbl::atomic<int *> is deprecated, use std::atomic<int *> instead
  // CHECK-FIXES: std::atomic<int *> m;
  std::atomic<int *> n;

  auto o = fbl::atomic<int *>();
  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use of fbl::atomic<int *> is deprecated, use std::atomic<int *> instead
  // CHECK-FIXES: auto o = std::atomic<int *>();
  auto p = std::atomic<int *>();

   bool weak_m = m.compare_exchange_weak(&expc_ptr, desr_ptr, order, order);
  // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: std::atomic requires references instead of pointers
  // CHECK-FIXES: bool weak_m = m.compare_exchange_weak(expc_ptr, desr_ptr, order, order);
  bool weak_ptr_m = m.compare_exchange_weak(expc_ptr_ptr, desr_ptr, order, order);
  // CHECK-MESSAGES: :[[@LINE-1]]:45: warning: std::atomic requires references instead of pointers
  // CHECK-FIXES: bool weak_ptr_m = m.compare_exchange_weak(*expc_ptr_ptr, desr_ptr, order, order);

  bool strong_m = m.compare_exchange_strong(&expc_ptr, desr_ptr, order, order);
  // CHECK-MESSAGES: :[[@LINE-1]]:45: warning: std::atomic requires references instead of pointers
  // CHECK-FIXES: bool strong_m = m.compare_exchange_strong(expc_ptr, desr_ptr, order, order);
  bool strong_ptr_m = m.compare_exchange_strong(expc_ptr_ptr, desr_ptr, order, order);
  // CHECK-MESSAGES: :[[@LINE-1]]:49: warning: std::atomic requires references instead of pointers
  // CHECK-FIXES: bool strong_ptr_m = m.compare_exchange_strong(*expc_ptr_ptr, desr_ptr, order, order);

  bool weak_n = n.compare_exchange_weak(expc_ptr, desr_ptr, order_std, order_std);
  bool weak_ptr_n = n.compare_exchange_weak(*expc_ptr_ptr, desr_ptr, order_std, order_std);

  bool strong_n = n.compare_exchange_strong(expc_ptr, desr_ptr, order_std, order_std);
  bool strong_ptr_n = n.compare_exchange_strong(*expc_ptr_ptr, desr_ptr, order_std, order_std);

  fbl::atomic_store(&m, expc_ptr);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use of fbl::atomic_store is deprecated, use std::atomic_store instead
  // CHECK-FIXES: std::atomic_store(&m, expc_ptr);
  fbl::atomic_store(&m, expc_ptr, order);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use of fbl::atomic_store is deprecated, use std::atomic_store_explicit instead
  // CHECK-FIXES: std::atomic_store_explicit(&m, expc_ptr, order);

  std::atomic_store(&n, expc_ptr);
  std::atomic_store_explicit(&n, expc_ptr, order_std);

  fbl::atomic_init(&m, expc_ptr);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use of fbl::atomic_init is deprecated, use std::atomic_init instead
  // CHECK-FIXES: std::atomic_init(&m, expc_ptr);

  std::atomic_store(&n, expc_ptr);

  fbl::atomic_thread_fence(order);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use of fbl::atomic_thread_fence is deprecated, use std::atomic_thread_fence instead
  // CHECK-FIXES: std::atomic_thread_fence(order);
  fbl::atomic_thread_fence();
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use of fbl::atomic_thread_fence is deprecated, use std::atomic_thread_fence instead
  // CHECK-FIXES: std::atomic_thread_fence(std::memory_order_seq_cst);

  std::atomic_thread_fence(order_std);

  fbl::atomic_char q;
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use of fbl::atomic_char is deprecated, use std::atomic_char instead
  // CHECK-FIXES: std::atomic_char q;
  std::atomic_char r;

  auto s = fbl::atomic_char();
  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use of fbl::atomic_char is deprecated, use std::atomic_char instead
  // CHECK-FIXES: auto s = std::atomic_char();
  auto t = std::atomic_char();
}