Revert r276506 - Diagnose invalid memory order arguments in <atomic>.

There is a bug in Clang 3.6 and earlier that causes compile failures.
I suspect it's due to the usage of member function parameter names in the
attributes.

llvm-svn: 276507

1 files changed, 0 insertions, 125 deletions

diff --git a/libcxx/test/libcxx/atomics/diagnose_invalid_memory_order.fail.cpp b/libcxx/test/libcxx/atomics/diagnose_invalid_memory_order.fail.cpp
deleted file mode 100644
index 58fc684e049..00000000000
--- a/libcxx/test/libcxx/atomics/diagnose_invalid_memory_order.fail.cpp
+++ /dev/null
@@ -1,125 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-// The attributes used to diagnose incorrect memory order inputs is clang
-// specific.
-// UNSUPPORTED: gcc
-
-// <atomic>
-
-// Test that invalid memory order arguments are diagnosed where possible.
-
-#include <atomic>
-
-int main() {
-    std::atomic<int> x(42);
-    volatile std::atomic<int>& vx = x;
-    int val1 = 1;
-    int val2 = 2;
-    // load operations
-    {
-        x.load(std::memory_order_release); // expected-error {{operation is invalid}}
-        x.load(std::memory_order_acq_rel); // expected-error {{operation is invalid}}
-        vx.load(std::memory_order_release); // expected-error {{operation is invalid}}
-        vx.load(std::memory_order_acq_rel); // expected-error {{operation is invalid}}
-        // valid memory orders
-        x.load(std::memory_order_relaxed);
-        x.load(std::memory_order_consume);
-        x.load(std::memory_order_acquire);
-        x.load(std::memory_order_seq_cst);
-    }
-    {
-        std::atomic_load_explicit(&x, std::memory_order_release); // expected-error {{operation is invalid}}
-        std::atomic_load_explicit(&x, std::memory_order_acq_rel); // expected-error {{operation is invalid}}
-        std::atomic_load_explicit(&vx, std::memory_order_release); // expected-error {{operation is invalid}}
-        std::atomic_load_explicit(&vx, std::memory_order_acq_rel); // expected-error {{operation is invalid}}
-        // valid memory orders
-        std::atomic_load_explicit(&x, std::memory_order_relaxed);
-        std::atomic_load_explicit(&x, std::memory_order_consume);
-        std::atomic_load_explicit(&x, std::memory_order_acquire);
-        std::atomic_load_explicit(&x, std::memory_order_seq_cst);
-    }
-    // store operations
-    {
-        x.store(42, std::memory_order_consume); // expected-error {{operation is invalid}}
-        x.store(42, std::memory_order_acquire); // expected-error {{operation is invalid}}
-        x.store(42, std::memory_order_acq_rel); // expected-error {{operation is invalid}}
-        vx.store(42, std::memory_order_consume); // expected-error {{operation is invalid}}
-        vx.store(42, std::memory_order_acquire); // expected-error {{operation is invalid}}
-        vx.store(42, std::memory_order_acq_rel); // expected-error {{operation is invalid}}
-        // valid memory orders
-        x.store(42, std::memory_order_relaxed);
-        x.store(42, std::memory_order_release);
-        x.store(42, std::memory_order_seq_cst);
-    }
-    {
-        std::atomic_store_explicit(&x, 42, std::memory_order_consume); // expected-error {{operation is invalid}}
-        std::atomic_store_explicit(&x, 42, std::memory_order_acquire); // expected-error {{operation is invalid}}
-        std::atomic_store_explicit(&x, 42, std::memory_order_acq_rel); // expected-error {{operation is invalid}}
-        std::atomic_store_explicit(&vx, 42, std::memory_order_consume); // expected-error {{operation is invalid}}
-        std::atomic_store_explicit(&vx, 42, std::memory_order_acquire); // expected-error {{operation is invalid}}
-        std::atomic_store_explicit(&vx, 42, std::memory_order_acq_rel); // expected-error {{operation is invalid}}
-        // valid memory orders
-        std::atomic_store_explicit(&x, 42, std::memory_order_relaxed);
-        std::atomic_store_explicit(&x, 42, std::memory_order_release);
-        std::atomic_store_explicit(&x, 42, std::memory_order_seq_cst);
-    }
-    // compare exchange weak
-    {
-        x.compare_exchange_weak(val1, val2, std::memory_order_seq_cst, std::memory_order_release); // expected-error {{operation is invalid}}
-        x.compare_exchange_weak(val1, val2, std::memory_order_seq_cst, std::memory_order_acq_rel); // expected-error {{operation is invalid}}
-        vx.compare_exchange_weak(val1, val2, std::memory_order_seq_cst, std::memory_order_release); // expected-error {{operation is invalid}}
-        vx.compare_exchange_weak(val1, val2, std::memory_order_seq_cst, std::memory_order_acq_rel); // expected-error {{operation is invalid}}
-        // valid memory orders
-        x.compare_exchange_weak(val1, val2, std::memory_order_seq_cst, std::memory_order_relaxed);
-        x.compare_exchange_weak(val1, val2, std::memory_order_seq_cst, std::memory_order_consume);
-        x.compare_exchange_weak(val1, val2, std::memory_order_seq_cst, std::memory_order_acquire);
-        x.compare_exchange_weak(val1, val2, std::memory_order_seq_cst, std::memory_order_seq_cst);
-        // Test that the cmpxchg overload with only one memory order argument
-        // does not generate any diagnostics.
-        x.compare_exchange_weak(val1, val2, std::memory_order_release);
-    }
-    {
-        std::atomic_compare_exchange_weak_explicit(&x, &val1, val2, std::memory_order_seq_cst, std::memory_order_release); // expected-error {{operation is invalid}}
-        std::atomic_compare_exchange_weak_explicit(&x, &val1, val2, std::memory_order_seq_cst, std::memory_order_acq_rel); // expected-error {{operation is invalid}}
-        std::atomic_compare_exchange_weak_explicit(&vx, &val1, val2, std::memory_order_seq_cst, std::memory_order_release); // expected-error {{operation is invalid}}
-        std::atomic_compare_exchange_weak_explicit(&vx, &val1, val2, std::memory_order_seq_cst, std::memory_order_acq_rel); // expected-error {{operation is invalid}}
-        // valid memory orders
-        std::atomic_compare_exchange_weak_explicit(&x, &val1, val2, std::memory_order_seq_cst, std::memory_order_relaxed);
-        std::atomic_compare_exchange_weak_explicit(&x, &val1, val2, std::memory_order_seq_cst, std::memory_order_consume);
-        std::atomic_compare_exchange_weak_explicit(&x, &val1, val2, std::memory_order_seq_cst, std::memory_order_acquire);
-        std::atomic_compare_exchange_weak_explicit(&x, &val1, val2, std::memory_order_seq_cst, std::memory_order_seq_cst);
-    }
-    // compare exchange strong
-    {
-        x.compare_exchange_strong(val1, val2, std::memory_order_seq_cst, std::memory_order_release); // expected-error {{operation is invalid}}
-        x.compare_exchange_strong(val1, val2, std::memory_order_seq_cst, std::memory_order_acq_rel); // expected-error {{operation is invalid}}
-        vx.compare_exchange_strong(val1, val2, std::memory_order_seq_cst, std::memory_order_release); // expected-error {{operation is invalid}}
-        vx.compare_exchange_strong(val1, val2, std::memory_order_seq_cst, std::memory_order_acq_rel); // expected-error {{operation is invalid}}
-        // valid memory orders
-        x.compare_exchange_strong(val1, val2, std::memory_order_seq_cst, std::memory_order_relaxed);
-        x.compare_exchange_strong(val1, val2, std::memory_order_seq_cst, std::memory_order_consume);
-        x.compare_exchange_strong(val1, val2, std::memory_order_seq_cst, std::memory_order_acquire);
-        x.compare_exchange_strong(val1, val2, std::memory_order_seq_cst, std::memory_order_seq_cst);
-        // Test that the cmpxchg overload with only one memory order argument
-        // does not generate any diagnostics.
-        x.compare_exchange_strong(val1, val2, std::memory_order_release);
-    }
-    {
-        std::atomic_compare_exchange_strong_explicit(&x, &val1, val2, std::memory_order_seq_cst, std::memory_order_release); // expected-error {{operation is invalid}}
-        std::atomic_compare_exchange_strong_explicit(&x, &val1, val2, std::memory_order_seq_cst, std::memory_order_acq_rel); // expected-error {{operation is invalid}}
-        std::atomic_compare_exchange_strong_explicit(&vx, &val1, val2, std::memory_order_seq_cst, std::memory_order_release); // expected-error {{operation is invalid}}
-        std::atomic_compare_exchange_strong_explicit(&vx, &val1, val2, std::memory_order_seq_cst, std::memory_order_acq_rel); // expected-error {{operation is invalid}}
-        // valid memory orders
-        std::atomic_compare_exchange_strong_explicit(&x, &val1, val2, std::memory_order_seq_cst, std::memory_order_relaxed);
-        std::atomic_compare_exchange_strong_explicit(&x, &val1, val2, std::memory_order_seq_cst, std::memory_order_consume);
-        std::atomic_compare_exchange_strong_explicit(&x, &val1, val2, std::memory_order_seq_cst, std::memory_order_acquire);
-        std::atomic_compare_exchange_strong_explicit(&x, &val1, val2, std::memory_order_seq_cst, std::memory_order_seq_cst);
-    }
-}