https://github.com/easyonaadit updated 
https://github.com/llvm/llvm-project/pull/230378

>From d3c7c2d6b96476379a1b26341a5d6e00c3d5ecce Mon Sep 17 00:00:00 2001
From: Aaditya <[email protected]>
Date: Fri, 9 Oct 2026 12:14:14 +0530
Subject: [PATCH 1/2] [Clang] Enable hip_atomic deprecation warning by default

---
 .../clang/Basic/DiagnosticSemaKinds.td        |   2 +-
 clang/test/SemaCUDA/atomic-ops.cu             | 128 +++++++++---------
 .../test/SemaCUDA/spirv-amdgcn-atomic-ops.cu  | 128 +++++++++---------
 3 files changed, 129 insertions(+), 129 deletions(-)

diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td 
b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index 9208aba1445d7e..6fa78e84a45dc4 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -6420,7 +6420,7 @@ def warn_deprecated_builtin : Warning<
   InGroup<DeprecatedBuiltins>;
 def warn_hip_deprecated_builtin : Warning<
   "builtin %0 is deprecated; use %1 instead">,
-  InGroup<HipDeprecatedBuiltins>, DefaultIgnore;
+  InGroup<HipDeprecatedBuiltins>;
 def warn_deprecated_builtin_no_suggestion : Warning<"builtin %0 is 
deprecated">,
   InGroup<DeprecatedBuiltins>;
 def err_unavailable : Error<"%0 is unavailable">;
diff --git a/clang/test/SemaCUDA/atomic-ops.cu 
b/clang/test/SemaCUDA/atomic-ops.cu
index 8ba3ca71b11571..8b9548a350ca31 100644
--- a/clang/test/SemaCUDA/atomic-ops.cu
+++ b/clang/test/SemaCUDA/atomic-ops.cu
@@ -8,24 +8,24 @@ __device__ int test_hip_atomic_load(int *pi32, unsigned int 
*pu32, long long *pl
   int val = __hip_atomic_load(0);      // expected-error {{too few arguments 
to function call, expected 3, have 1}}
   val = __hip_atomic_load(0, 0, 0, 0); // expected-error {{too many arguments 
to function call, expected 3, have 4}}
   val = __hip_atomic_load(0, 0, 0);    // expected-error {{address argument to 
atomic builtin must be a pointer ('int' invalid)}}
-  val = __hip_atomic_load(pi32, 0, 0); // expected-error {{synchronization 
scope argument to atomic operation is invalid}}
-  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_WAVEFRONT);
-  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_WORKGROUP);
-  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_CLUSTER);
-  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_AGENT);
-  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SYSTEM);
-  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, INVALID_HIP_MEMORY_SCOPE); 
// expected-error {{synchronization scope argument to atomic operation is 
invalid}}
-  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  val = __hip_atomic_load(pi32, __ATOMIC_SEQ_CST, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  val = __hip_atomic_load(pi32, __ATOMIC_CONSUME, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  val = __hip_atomic_load(pi32, __ATOMIC_ACQUIRE, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  val = __hip_atomic_load(pi32, __ATOMIC_ACQ_REL, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{memory order argument to 
atomic operation is invalid}}
-  val = __hip_atomic_load(pu32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  val = __hip_atomic_load(pll, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  val = __hip_atomic_load(pull, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  val = __hip_atomic_load(fp, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  val = __hip_atomic_load(dbl, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  val = __hip_atomic_load(pi32, 0, 0); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}} // 
expected-error {{synchronization scope argument to atomic operation is invalid}}
+  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
+  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_WAVEFRONT); // expected-warning{{builtin __hip_atomic_load 
is deprecated; use __scoped_atomic_load_n instead}}
+  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_WORKGROUP); // expected-warning{{builtin __hip_atomic_load 
is deprecated; use __scoped_atomic_load_n instead}}
+  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_CLUSTER); 
// expected-warning{{builtin __hip_atomic_load is deprecated; use 
__scoped_atomic_load_n instead}}
+  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_AGENT); 
// expected-warning{{builtin __hip_atomic_load is deprecated; use 
__scoped_atomic_load_n instead}}
+  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SYSTEM); 
// expected-warning{{builtin __hip_atomic_load is deprecated; use 
__scoped_atomic_load_n instead}}
+  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, INVALID_HIP_MEMORY_SCOPE); 
// expected-warning{{builtin __hip_atomic_load is deprecated; use 
__scoped_atomic_load_n instead}} // expected-error {{synchronization scope 
argument to atomic operation is invalid}}
+  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
+  val = __hip_atomic_load(pi32, __ATOMIC_SEQ_CST, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
+  val = __hip_atomic_load(pi32, __ATOMIC_CONSUME, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
+  val = __hip_atomic_load(pi32, __ATOMIC_ACQUIRE, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
+  val = __hip_atomic_load(pi32, __ATOMIC_ACQ_REL, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}} // 
expected-warning{{memory order argument to atomic operation is invalid}}
+  val = __hip_atomic_load(pu32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
+  val = __hip_atomic_load(pll, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
+  val = __hip_atomic_load(pull, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
+  val = __hip_atomic_load(fp, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
+  val = __hip_atomic_load(dbl, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
   return val;
 }
 
@@ -34,34 +34,34 @@ __device__ int test_hip_atomic_store(int *pi32, unsigned 
int *pu32, long long *p
   __hip_atomic_store(0);             // expected-error {{too few arguments to 
function call, expected 4, have 1}}
   __hip_atomic_store(0, 0, 0, 0, 0); // expected-error {{too many arguments to 
function call, expected 4, have 5}}
   __hip_atomic_store(0, 0, 0, 0);    // expected-error {{address argument to 
atomic builtin must be a pointer ('int' invalid)}}
-  __hip_atomic_store(pi32, 0, 0, 0); // expected-error {{synchronization scope 
argument to atomic operation is invalid}}
-  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_WAVEFRONT);
-  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_WORKGROUP);
-  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_CLUSTER);
-  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_AGENT);
-  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SYSTEM);
-  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, INVALID_HIP_MEMORY_SCOPE); // 
expected-error {{synchronization scope argument to atomic operation is invalid}}
-  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(pi32, 0, __ATOMIC_SEQ_CST, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(pi32, 0, __ATOMIC_CONSUME, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{memory order argument to 
atomic operation is invalid}}
-  __hip_atomic_store(pi32, 0, __ATOMIC_ACQUIRE, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{memory order argument to 
atomic operation is invalid}}
-  __hip_atomic_store(pi32, 0, __ATOMIC_ACQ_REL, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{memory order argument to 
atomic operation is invalid}}
-  __hip_atomic_store(pi32, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(pi32, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(pu32, u32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(pll, i64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(pull, u64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(fp, f32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(dbl, f64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(pi32, u32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(pi32, i64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(pi32, u64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(pll, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(fp, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(fp, i64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(dbl, i64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(dbl, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(pi32, 0, 0, 0); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}} // 
expected-error {{synchronization scope argument to atomic operation is invalid}}
+  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_WAVEFRONT); 
// expected-warning{{builtin __hip_atomic_store is deprecated; use 
__scoped_atomic_store_n instead}}
+  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_WORKGROUP); 
// expected-warning{{builtin __hip_atomic_store is deprecated; use 
__scoped_atomic_store_n instead}}
+  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_CLUSTER); 
// expected-warning{{builtin __hip_atomic_store is deprecated; use 
__scoped_atomic_store_n instead}}
+  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_AGENT); // 
expected-warning{{builtin __hip_atomic_store is deprecated; use 
__scoped_atomic_store_n instead}}
+  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SYSTEM); // 
expected-warning{{builtin __hip_atomic_store is deprecated; use 
__scoped_atomic_store_n instead}}
+  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, INVALID_HIP_MEMORY_SCOPE); // 
expected-warning{{builtin __hip_atomic_store is deprecated; use 
__scoped_atomic_store_n instead}} // expected-error {{synchronization scope 
argument to atomic operation is invalid}}
+  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(pi32, 0, __ATOMIC_SEQ_CST, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(pi32, 0, __ATOMIC_CONSUME, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}} // 
expected-warning{{memory order argument to atomic operation is invalid}}
+  __hip_atomic_store(pi32, 0, __ATOMIC_ACQUIRE, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}} // 
expected-warning{{memory order argument to atomic operation is invalid}}
+  __hip_atomic_store(pi32, 0, __ATOMIC_ACQ_REL, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}} // 
expected-warning{{memory order argument to atomic operation is invalid}}
+  __hip_atomic_store(pi32, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(pi32, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(pu32, u32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(pll, i64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(pull, u64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(fp, f32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(dbl, f64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(pi32, u32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(pi32, i64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(pi32, u64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(pll, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(fp, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(fp, i64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(dbl, i64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(dbl, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
   return 0;
 }
 
@@ -69,23 +69,23 @@ __device__ bool test_hip_atomic_cmpxchg_weak(int *ptr, int 
val, int desired) {
   bool flag = __hip_atomic_compare_exchange_weak(0);                           
          // expected-error {{too few arguments to function call, expected 6, 
have 1}}
   flag = __hip_atomic_compare_exchange_weak(0, 0, 0, 0, 0, 0, 0);              
          // expected-error {{too many arguments to function call, expected 6, 
have 7}}
   flag = __hip_atomic_compare_exchange_weak(0, 0, 0, 0, 0, 0);                 
          // expected-error {{address argument to atomic builtin must be a 
pointer ('int' invalid)}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, 0, 0, 0, 0, 0);               
          // expected-error {{synchronization scope argument to atomic 
operation is invalid}}, expected-warning {{null passed to a callee that 
requires a non-null argument}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, 0, 0, 0, 0, 
__HIP_MEMORY_SCOPE_SYSTEM); // expected-warning {{null passed to a callee that 
requires a non-null argument}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SYSTEM);
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_CONSUME, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD);
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_WAVEFRONT);
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_WORKGROUP);
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_CLUSTER);
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_AGENT);
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD);
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_SEQ_CST, __HIP_MEMORY_SCOPE_SINGLETHREAD);
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_CONSUME, __HIP_MEMORY_SCOPE_SINGLETHREAD);
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_ACQUIRE, __HIP_MEMORY_SCOPE_SINGLETHREAD);
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_ACQ_REL, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning {{failure memory order argument to atomic operation is 
invalid}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD);
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_SEQ_CST, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD);
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_CONSUME, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD);
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_ACQUIRE, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD);
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_ACQ_REL, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD);
+  flag = __hip_atomic_compare_exchange_weak(ptr, 0, 0, 0, 0, 0);               
          // expected-warning{{builtin __hip_atomic_compare_exchange_weak is 
deprecated; use __scoped_atomic_compare_exchange instead}} // expected-error 
{{synchronization scope argument to atomic operation is invalid}}, 
expected-warning {{null passed to a callee that requires a non-null argument}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, 0, 0, 0, 0, 
__HIP_MEMORY_SCOPE_SYSTEM); // expected-warning{{builtin 
__hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}} // expected-warning {{null passed to 
a callee that requires a non-null argument}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SYSTEM); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_CONSUME, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_WAVEFRONT); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_WORKGROUP); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_CLUSTER); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_AGENT); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_SEQ_CST, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_CONSUME, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_ACQUIRE, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_ACQ_REL, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}} // expected-warning {{failure memory 
order argument to atomic operation is invalid}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_SEQ_CST, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_CONSUME, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_ACQUIRE, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_ACQ_REL, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
   return flag;
 }
diff --git a/clang/test/SemaCUDA/spirv-amdgcn-atomic-ops.cu 
b/clang/test/SemaCUDA/spirv-amdgcn-atomic-ops.cu
index 503e786877819d..e0fe1453245ffb 100644
--- a/clang/test/SemaCUDA/spirv-amdgcn-atomic-ops.cu
+++ b/clang/test/SemaCUDA/spirv-amdgcn-atomic-ops.cu
@@ -8,24 +8,24 @@ __device__ int test_hip_atomic_load(int *pi32, unsigned int 
*pu32, long long *pl
   int val = __hip_atomic_load(0);      // expected-error {{too few arguments 
to function call, expected 3, have 1}}
   val = __hip_atomic_load(0, 0, 0, 0); // expected-error {{too many arguments 
to function call, expected 3, have 4}}
   val = __hip_atomic_load(0, 0, 0);    // expected-error {{address argument to 
atomic builtin must be a pointer ('int' invalid)}}
-  val = __hip_atomic_load(pi32, 0, 0); // expected-error {{synchronization 
scope argument to atomic operation is invalid}}
-  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_WAVEFRONT);
-  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_WORKGROUP);
-  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_CLUSTER);
-  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_AGENT);
-  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SYSTEM);
-  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, INVALID_HIP_MEMORY_SCOPE); 
// expected-error {{synchronization scope argument to atomic operation is 
invalid}}
-  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  val = __hip_atomic_load(pi32, __ATOMIC_SEQ_CST, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  val = __hip_atomic_load(pi32, __ATOMIC_CONSUME, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  val = __hip_atomic_load(pi32, __ATOMIC_ACQUIRE, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  val = __hip_atomic_load(pi32, __ATOMIC_ACQ_REL, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{memory order argument to 
atomic operation is invalid}}
-  val = __hip_atomic_load(pu32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  val = __hip_atomic_load(pll, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  val = __hip_atomic_load(pull, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  val = __hip_atomic_load(fp, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  val = __hip_atomic_load(dbl, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  val = __hip_atomic_load(pi32, 0, 0); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}} // 
expected-error {{synchronization scope argument to atomic operation is invalid}}
+  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
+  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_WAVEFRONT); // expected-warning{{builtin __hip_atomic_load 
is deprecated; use __scoped_atomic_load_n instead}}
+  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_WORKGROUP); // expected-warning{{builtin __hip_atomic_load 
is deprecated; use __scoped_atomic_load_n instead}}
+  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_CLUSTER); 
// expected-warning{{builtin __hip_atomic_load is deprecated; use 
__scoped_atomic_load_n instead}}
+  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_AGENT); 
// expected-warning{{builtin __hip_atomic_load is deprecated; use 
__scoped_atomic_load_n instead}}
+  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SYSTEM); 
// expected-warning{{builtin __hip_atomic_load is deprecated; use 
__scoped_atomic_load_n instead}}
+  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, INVALID_HIP_MEMORY_SCOPE); 
// expected-warning{{builtin __hip_atomic_load is deprecated; use 
__scoped_atomic_load_n instead}} // expected-error {{synchronization scope 
argument to atomic operation is invalid}}
+  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
+  val = __hip_atomic_load(pi32, __ATOMIC_SEQ_CST, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
+  val = __hip_atomic_load(pi32, __ATOMIC_CONSUME, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
+  val = __hip_atomic_load(pi32, __ATOMIC_ACQUIRE, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
+  val = __hip_atomic_load(pi32, __ATOMIC_ACQ_REL, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}} // 
expected-warning{{memory order argument to atomic operation is invalid}}
+  val = __hip_atomic_load(pu32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
+  val = __hip_atomic_load(pll, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
+  val = __hip_atomic_load(pull, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
+  val = __hip_atomic_load(fp, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
+  val = __hip_atomic_load(dbl, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
   return val;
 }
 
@@ -34,34 +34,34 @@ __device__ int test_hip_atomic_store(int *pi32, unsigned 
int *pu32, long long *p
   __hip_atomic_store(0);             // expected-error {{too few arguments to 
function call, expected 4, have 1}}
   __hip_atomic_store(0, 0, 0, 0, 0); // expected-error {{too many arguments to 
function call, expected 4, have 5}}
   __hip_atomic_store(0, 0, 0, 0);    // expected-error {{address argument to 
atomic builtin must be a pointer ('int' invalid)}}
-  __hip_atomic_store(pi32, 0, 0, 0); // expected-error {{synchronization scope 
argument to atomic operation is invalid}}
-  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_WAVEFRONT);
-  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_WORKGROUP);
-  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_CLUSTER);
-  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_AGENT);
-  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SYSTEM);
-  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, INVALID_HIP_MEMORY_SCOPE); // 
expected-error {{synchronization scope argument to atomic operation is invalid}}
-  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(pi32, 0, __ATOMIC_SEQ_CST, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(pi32, 0, __ATOMIC_CONSUME, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{memory order argument to 
atomic operation is invalid}}
-  __hip_atomic_store(pi32, 0, __ATOMIC_ACQUIRE, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{memory order argument to 
atomic operation is invalid}}
-  __hip_atomic_store(pi32, 0, __ATOMIC_ACQ_REL, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{memory order argument to 
atomic operation is invalid}}
-  __hip_atomic_store(pi32, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(pi32, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(pu32, u32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(pll, i64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(pull, u64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(fp, f32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(dbl, f64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(pi32, u32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(pi32, i64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(pi32, u64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(pll, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(fp, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(fp, i64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(dbl, i64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
-  __hip_atomic_store(dbl, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(pi32, 0, 0, 0); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}} // 
expected-error {{synchronization scope argument to atomic operation is invalid}}
+  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_WAVEFRONT); 
// expected-warning{{builtin __hip_atomic_store is deprecated; use 
__scoped_atomic_store_n instead}}
+  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_WORKGROUP); 
// expected-warning{{builtin __hip_atomic_store is deprecated; use 
__scoped_atomic_store_n instead}}
+  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_CLUSTER); 
// expected-warning{{builtin __hip_atomic_store is deprecated; use 
__scoped_atomic_store_n instead}}
+  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_AGENT); // 
expected-warning{{builtin __hip_atomic_store is deprecated; use 
__scoped_atomic_store_n instead}}
+  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SYSTEM); // 
expected-warning{{builtin __hip_atomic_store is deprecated; use 
__scoped_atomic_store_n instead}}
+  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, INVALID_HIP_MEMORY_SCOPE); // 
expected-warning{{builtin __hip_atomic_store is deprecated; use 
__scoped_atomic_store_n instead}} // expected-error {{synchronization scope 
argument to atomic operation is invalid}}
+  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);// expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}} 
+  __hip_atomic_store(pi32, 0, __ATOMIC_SEQ_CST, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);// expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}} 
+  __hip_atomic_store(pi32, 0, __ATOMIC_CONSUME, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);// expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}  // 
expected-warning{{memory order argument to atomic operation is invalid}}
+  __hip_atomic_store(pi32, 0, __ATOMIC_ACQUIRE, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);// expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}  // 
expected-warning{{memory order argument to atomic operation is invalid}}
+  __hip_atomic_store(pi32, 0, __ATOMIC_ACQ_REL, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);// expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}  // 
expected-warning{{memory order argument to atomic operation is invalid}}
+  __hip_atomic_store(pi32, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(pi32, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(pu32, u32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(pll, i64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(pull, u64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(fp, f32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(dbl, f64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(pi32, u32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(pi32, i64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(pi32, u64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(pll, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(fp, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(fp, i64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(dbl, i64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(dbl, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
   return 0;
 }
 
@@ -69,23 +69,23 @@ __device__ bool test_hip_atomic_cmpxchg_weak(int *ptr, int 
val, int desired) {
   bool flag = __hip_atomic_compare_exchange_weak(0);                           
          // expected-error {{too few arguments to function call, expected 6, 
have 1}}
   flag = __hip_atomic_compare_exchange_weak(0, 0, 0, 0, 0, 0, 0);              
          // expected-error {{too many arguments to function call, expected 6, 
have 7}}
   flag = __hip_atomic_compare_exchange_weak(0, 0, 0, 0, 0, 0);                 
          // expected-error {{address argument to atomic builtin must be a 
pointer ('int' invalid)}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, 0, 0, 0, 0, 0);               
          // expected-error {{synchronization scope argument to atomic 
operation is invalid}}, expected-warning {{null passed to a callee that 
requires a non-null argument}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, 0, 0, 0, 0, 
__HIP_MEMORY_SCOPE_SYSTEM); // expected-warning {{null passed to a callee that 
requires a non-null argument}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SYSTEM);
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_CONSUME, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD);
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_WAVEFRONT);
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_WORKGROUP);
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_CLUSTER);
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_AGENT);
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD);
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_SEQ_CST, __HIP_MEMORY_SCOPE_SINGLETHREAD);
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_CONSUME, __HIP_MEMORY_SCOPE_SINGLETHREAD);
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_ACQUIRE, __HIP_MEMORY_SCOPE_SINGLETHREAD);
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_ACQ_REL, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning {{failure memory order argument to atomic operation is 
invalid}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD);
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_SEQ_CST, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD);
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_CONSUME, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD);
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_ACQUIRE, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD);
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_ACQ_REL, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD);
+  flag = __hip_atomic_compare_exchange_weak(ptr, 0, 0, 0, 0, 0);               
          // expected-warning{{builtin __hip_atomic_compare_exchange_weak is 
deprecated; use __scoped_atomic_compare_exchange instead}} // expected-error 
{{synchronization scope argument to atomic operation is invalid}}, 
expected-warning {{null passed to a callee that requires a non-null argument}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, 0, 0, 0, 0, 
__HIP_MEMORY_SCOPE_SYSTEM); // expected-warning{{builtin 
__hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}} // expected-warning {{null passed to 
a callee that requires a non-null argument}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SYSTEM); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_CONSUME, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_WAVEFRONT); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_WORKGROUP); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_CLUSTER); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_AGENT); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_SEQ_CST, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_CONSUME, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_ACQUIRE, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_ACQ_REL, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}} // expected-warning {{failure memory 
order argument to atomic operation is invalid}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_SEQ_CST, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_CONSUME, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_ACQUIRE, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_ACQ_REL, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
   return flag;
 }

>From 035df7484cc0d3fbded72c95bba2280f4d312634 Mon Sep 17 00:00:00 2001
From: Aaditya <[email protected]>
Date: Thu, 15 Oct 2026 13:54:50 +0530
Subject: [PATCH 2/2] Modify test run-lines

---
 clang/test/SemaCUDA/atomic-ops.cu             | 130 +++++++++---------
 .../test/SemaCUDA/spirv-amdgcn-atomic-ops.cu  | 130 +++++++++---------
 clang/test/SemaHIP/atomic-deprecated.hip      |   4 +-
 3 files changed, 132 insertions(+), 132 deletions(-)

diff --git a/clang/test/SemaCUDA/atomic-ops.cu 
b/clang/test/SemaCUDA/atomic-ops.cu
index 8b9548a350ca31..bfe828109f2b0b 100644
--- a/clang/test/SemaCUDA/atomic-ops.cu
+++ b/clang/test/SemaCUDA/atomic-ops.cu
@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 -x hip -std=c++11 -triple amdgpu -fcuda-is-device -verify 
-fsyntax-only %s
+// RUN: %clang_cc1 -x hip -std=c++11 -triple amdgpu -fcuda-is-device -verify 
-fsyntax-only -Wno-hip-deprecated-builtins %s
 
 #include "Inputs/cuda.h"
 
@@ -8,24 +8,24 @@ __device__ int test_hip_atomic_load(int *pi32, unsigned int 
*pu32, long long *pl
   int val = __hip_atomic_load(0);      // expected-error {{too few arguments 
to function call, expected 3, have 1}}
   val = __hip_atomic_load(0, 0, 0, 0); // expected-error {{too many arguments 
to function call, expected 3, have 4}}
   val = __hip_atomic_load(0, 0, 0);    // expected-error {{address argument to 
atomic builtin must be a pointer ('int' invalid)}}
-  val = __hip_atomic_load(pi32, 0, 0); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}} // 
expected-error {{synchronization scope argument to atomic operation is invalid}}
-  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
-  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_WAVEFRONT); // expected-warning{{builtin __hip_atomic_load 
is deprecated; use __scoped_atomic_load_n instead}}
-  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_WORKGROUP); // expected-warning{{builtin __hip_atomic_load 
is deprecated; use __scoped_atomic_load_n instead}}
-  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_CLUSTER); 
// expected-warning{{builtin __hip_atomic_load is deprecated; use 
__scoped_atomic_load_n instead}}
-  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_AGENT); 
// expected-warning{{builtin __hip_atomic_load is deprecated; use 
__scoped_atomic_load_n instead}}
-  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SYSTEM); 
// expected-warning{{builtin __hip_atomic_load is deprecated; use 
__scoped_atomic_load_n instead}}
-  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, INVALID_HIP_MEMORY_SCOPE); 
// expected-warning{{builtin __hip_atomic_load is deprecated; use 
__scoped_atomic_load_n instead}} // expected-error {{synchronization scope 
argument to atomic operation is invalid}}
-  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
-  val = __hip_atomic_load(pi32, __ATOMIC_SEQ_CST, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
-  val = __hip_atomic_load(pi32, __ATOMIC_CONSUME, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
-  val = __hip_atomic_load(pi32, __ATOMIC_ACQUIRE, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
-  val = __hip_atomic_load(pi32, __ATOMIC_ACQ_REL, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}} // 
expected-warning{{memory order argument to atomic operation is invalid}}
-  val = __hip_atomic_load(pu32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
-  val = __hip_atomic_load(pll, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
-  val = __hip_atomic_load(pull, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
-  val = __hip_atomic_load(fp, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
-  val = __hip_atomic_load(dbl, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
+  val = __hip_atomic_load(pi32, 0, 0); // expected-error {{synchronization 
scope argument to atomic operation is invalid}}
+  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_WAVEFRONT);
+  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_WORKGROUP);
+  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_CLUSTER);
+  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_AGENT);
+  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SYSTEM);
+  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, INVALID_HIP_MEMORY_SCOPE); 
// expected-error {{synchronization scope argument to atomic operation is 
invalid}}
+  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  val = __hip_atomic_load(pi32, __ATOMIC_SEQ_CST, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  val = __hip_atomic_load(pi32, __ATOMIC_CONSUME, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  val = __hip_atomic_load(pi32, __ATOMIC_ACQUIRE, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  val = __hip_atomic_load(pi32, __ATOMIC_ACQ_REL, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{memory order argument to 
atomic operation is invalid}}
+  val = __hip_atomic_load(pu32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  val = __hip_atomic_load(pll, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  val = __hip_atomic_load(pull, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  val = __hip_atomic_load(fp, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  val = __hip_atomic_load(dbl, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
   return val;
 }
 
@@ -34,34 +34,34 @@ __device__ int test_hip_atomic_store(int *pi32, unsigned 
int *pu32, long long *p
   __hip_atomic_store(0);             // expected-error {{too few arguments to 
function call, expected 4, have 1}}
   __hip_atomic_store(0, 0, 0, 0, 0); // expected-error {{too many arguments to 
function call, expected 4, have 5}}
   __hip_atomic_store(0, 0, 0, 0);    // expected-error {{address argument to 
atomic builtin must be a pointer ('int' invalid)}}
-  __hip_atomic_store(pi32, 0, 0, 0); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}} // 
expected-error {{synchronization scope argument to atomic operation is invalid}}
-  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
-  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_WAVEFRONT); 
// expected-warning{{builtin __hip_atomic_store is deprecated; use 
__scoped_atomic_store_n instead}}
-  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_WORKGROUP); 
// expected-warning{{builtin __hip_atomic_store is deprecated; use 
__scoped_atomic_store_n instead}}
-  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_CLUSTER); 
// expected-warning{{builtin __hip_atomic_store is deprecated; use 
__scoped_atomic_store_n instead}}
-  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_AGENT); // 
expected-warning{{builtin __hip_atomic_store is deprecated; use 
__scoped_atomic_store_n instead}}
-  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SYSTEM); // 
expected-warning{{builtin __hip_atomic_store is deprecated; use 
__scoped_atomic_store_n instead}}
-  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, INVALID_HIP_MEMORY_SCOPE); // 
expected-warning{{builtin __hip_atomic_store is deprecated; use 
__scoped_atomic_store_n instead}} // expected-error {{synchronization scope 
argument to atomic operation is invalid}}
-  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
-  __hip_atomic_store(pi32, 0, __ATOMIC_SEQ_CST, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
-  __hip_atomic_store(pi32, 0, __ATOMIC_CONSUME, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}} // 
expected-warning{{memory order argument to atomic operation is invalid}}
-  __hip_atomic_store(pi32, 0, __ATOMIC_ACQUIRE, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}} // 
expected-warning{{memory order argument to atomic operation is invalid}}
-  __hip_atomic_store(pi32, 0, __ATOMIC_ACQ_REL, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}} // 
expected-warning{{memory order argument to atomic operation is invalid}}
-  __hip_atomic_store(pi32, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
-  __hip_atomic_store(pi32, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
-  __hip_atomic_store(pu32, u32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
-  __hip_atomic_store(pll, i64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
-  __hip_atomic_store(pull, u64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
-  __hip_atomic_store(fp, f32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
-  __hip_atomic_store(dbl, f64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
-  __hip_atomic_store(pi32, u32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
-  __hip_atomic_store(pi32, i64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
-  __hip_atomic_store(pi32, u64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
-  __hip_atomic_store(pll, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
-  __hip_atomic_store(fp, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
-  __hip_atomic_store(fp, i64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
-  __hip_atomic_store(dbl, i64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
-  __hip_atomic_store(dbl, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(pi32, 0, 0, 0); // expected-error {{synchronization scope 
argument to atomic operation is invalid}}
+  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_WAVEFRONT);
+  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_WORKGROUP);
+  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_CLUSTER);
+  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_AGENT);
+  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SYSTEM);
+  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, INVALID_HIP_MEMORY_SCOPE); // 
expected-error {{synchronization scope argument to atomic operation is invalid}}
+  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(pi32, 0, __ATOMIC_SEQ_CST, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(pi32, 0, __ATOMIC_CONSUME, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{memory order argument to 
atomic operation is invalid}}
+  __hip_atomic_store(pi32, 0, __ATOMIC_ACQUIRE, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{memory order argument to 
atomic operation is invalid}}
+  __hip_atomic_store(pi32, 0, __ATOMIC_ACQ_REL, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{memory order argument to 
atomic operation is invalid}}
+  __hip_atomic_store(pi32, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(pi32, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(pu32, u32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(pll, i64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(pull, u64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(fp, f32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(dbl, f64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(pi32, u32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(pi32, i64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(pi32, u64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(pll, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(fp, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(fp, i64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(dbl, i64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(dbl, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
   return 0;
 }
 
@@ -69,23 +69,23 @@ __device__ bool test_hip_atomic_cmpxchg_weak(int *ptr, int 
val, int desired) {
   bool flag = __hip_atomic_compare_exchange_weak(0);                           
          // expected-error {{too few arguments to function call, expected 6, 
have 1}}
   flag = __hip_atomic_compare_exchange_weak(0, 0, 0, 0, 0, 0, 0);              
          // expected-error {{too many arguments to function call, expected 6, 
have 7}}
   flag = __hip_atomic_compare_exchange_weak(0, 0, 0, 0, 0, 0);                 
          // expected-error {{address argument to atomic builtin must be a 
pointer ('int' invalid)}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, 0, 0, 0, 0, 0);               
          // expected-warning{{builtin __hip_atomic_compare_exchange_weak is 
deprecated; use __scoped_atomic_compare_exchange instead}} // expected-error 
{{synchronization scope argument to atomic operation is invalid}}, 
expected-warning {{null passed to a callee that requires a non-null argument}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, 0, 0, 0, 0, 
__HIP_MEMORY_SCOPE_SYSTEM); // expected-warning{{builtin 
__hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}} // expected-warning {{null passed to 
a callee that requires a non-null argument}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SYSTEM); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_CONSUME, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_WAVEFRONT); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_WORKGROUP); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_CLUSTER); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_AGENT); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_SEQ_CST, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_CONSUME, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_ACQUIRE, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_ACQ_REL, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}} // expected-warning {{failure memory 
order argument to atomic operation is invalid}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_SEQ_CST, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_CONSUME, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_ACQUIRE, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_ACQ_REL, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, 0, 0, 0, 0, 0);               
          // expected-error {{synchronization scope argument to atomic 
operation is invalid}}, expected-warning {{null passed to a callee that 
requires a non-null argument}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, 0, 0, 0, 0, 
__HIP_MEMORY_SCOPE_SYSTEM); // expected-warning {{null passed to a callee that 
requires a non-null argument}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SYSTEM);
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_CONSUME, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD);
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_WAVEFRONT);
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_WORKGROUP);
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_CLUSTER);
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_AGENT);
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD);
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_SEQ_CST, __HIP_MEMORY_SCOPE_SINGLETHREAD);
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_CONSUME, __HIP_MEMORY_SCOPE_SINGLETHREAD);
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_ACQUIRE, __HIP_MEMORY_SCOPE_SINGLETHREAD);
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_ACQ_REL, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning {{failure memory order argument to atomic operation is 
invalid}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD);
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_SEQ_CST, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD);
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_CONSUME, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD);
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_ACQUIRE, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD);
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_ACQ_REL, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD);
   return flag;
 }
diff --git a/clang/test/SemaCUDA/spirv-amdgcn-atomic-ops.cu 
b/clang/test/SemaCUDA/spirv-amdgcn-atomic-ops.cu
index e0fe1453245ffb..06b7f902438594 100644
--- a/clang/test/SemaCUDA/spirv-amdgcn-atomic-ops.cu
+++ b/clang/test/SemaCUDA/spirv-amdgcn-atomic-ops.cu
@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 -x hip -std=c++11 -triple spirv64-amd-amdhsa 
-fcuda-is-device -verify -fsyntax-only %s
+// RUN: %clang_cc1 -x hip -std=c++11 -triple spirv64-amd-amdhsa 
-fcuda-is-device -verify -fsyntax-only -Wno-hip-deprecated-builtins %s
 
 #include "Inputs/cuda.h"
 
@@ -8,24 +8,24 @@ __device__ int test_hip_atomic_load(int *pi32, unsigned int 
*pu32, long long *pl
   int val = __hip_atomic_load(0);      // expected-error {{too few arguments 
to function call, expected 3, have 1}}
   val = __hip_atomic_load(0, 0, 0, 0); // expected-error {{too many arguments 
to function call, expected 3, have 4}}
   val = __hip_atomic_load(0, 0, 0);    // expected-error {{address argument to 
atomic builtin must be a pointer ('int' invalid)}}
-  val = __hip_atomic_load(pi32, 0, 0); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}} // 
expected-error {{synchronization scope argument to atomic operation is invalid}}
-  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
-  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_WAVEFRONT); // expected-warning{{builtin __hip_atomic_load 
is deprecated; use __scoped_atomic_load_n instead}}
-  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_WORKGROUP); // expected-warning{{builtin __hip_atomic_load 
is deprecated; use __scoped_atomic_load_n instead}}
-  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_CLUSTER); 
// expected-warning{{builtin __hip_atomic_load is deprecated; use 
__scoped_atomic_load_n instead}}
-  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_AGENT); 
// expected-warning{{builtin __hip_atomic_load is deprecated; use 
__scoped_atomic_load_n instead}}
-  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SYSTEM); 
// expected-warning{{builtin __hip_atomic_load is deprecated; use 
__scoped_atomic_load_n instead}}
-  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, INVALID_HIP_MEMORY_SCOPE); 
// expected-warning{{builtin __hip_atomic_load is deprecated; use 
__scoped_atomic_load_n instead}} // expected-error {{synchronization scope 
argument to atomic operation is invalid}}
-  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
-  val = __hip_atomic_load(pi32, __ATOMIC_SEQ_CST, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
-  val = __hip_atomic_load(pi32, __ATOMIC_CONSUME, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
-  val = __hip_atomic_load(pi32, __ATOMIC_ACQUIRE, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
-  val = __hip_atomic_load(pi32, __ATOMIC_ACQ_REL, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}} // 
expected-warning{{memory order argument to atomic operation is invalid}}
-  val = __hip_atomic_load(pu32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
-  val = __hip_atomic_load(pll, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
-  val = __hip_atomic_load(pull, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
-  val = __hip_atomic_load(fp, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
-  val = __hip_atomic_load(dbl, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_load is deprecated; use __scoped_atomic_load_n instead}}
+  val = __hip_atomic_load(pi32, 0, 0); // expected-error {{synchronization 
scope argument to atomic operation is invalid}}
+  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_WAVEFRONT);
+  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_WORKGROUP);
+  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_CLUSTER);
+  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_AGENT);
+  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SYSTEM);
+  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, INVALID_HIP_MEMORY_SCOPE); 
// expected-error {{synchronization scope argument to atomic operation is 
invalid}}
+  val = __hip_atomic_load(pi32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  val = __hip_atomic_load(pi32, __ATOMIC_SEQ_CST, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  val = __hip_atomic_load(pi32, __ATOMIC_CONSUME, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  val = __hip_atomic_load(pi32, __ATOMIC_ACQUIRE, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  val = __hip_atomic_load(pi32, __ATOMIC_ACQ_REL, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{memory order argument to 
atomic operation is invalid}}
+  val = __hip_atomic_load(pu32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  val = __hip_atomic_load(pll, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  val = __hip_atomic_load(pull, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  val = __hip_atomic_load(fp, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  val = __hip_atomic_load(dbl, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
   return val;
 }
 
@@ -34,34 +34,34 @@ __device__ int test_hip_atomic_store(int *pi32, unsigned 
int *pu32, long long *p
   __hip_atomic_store(0);             // expected-error {{too few arguments to 
function call, expected 4, have 1}}
   __hip_atomic_store(0, 0, 0, 0, 0); // expected-error {{too many arguments to 
function call, expected 4, have 5}}
   __hip_atomic_store(0, 0, 0, 0);    // expected-error {{address argument to 
atomic builtin must be a pointer ('int' invalid)}}
-  __hip_atomic_store(pi32, 0, 0, 0); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}} // 
expected-error {{synchronization scope argument to atomic operation is invalid}}
-  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
-  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_WAVEFRONT); 
// expected-warning{{builtin __hip_atomic_store is deprecated; use 
__scoped_atomic_store_n instead}}
-  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_WORKGROUP); 
// expected-warning{{builtin __hip_atomic_store is deprecated; use 
__scoped_atomic_store_n instead}}
-  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_CLUSTER); 
// expected-warning{{builtin __hip_atomic_store is deprecated; use 
__scoped_atomic_store_n instead}}
-  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_AGENT); // 
expected-warning{{builtin __hip_atomic_store is deprecated; use 
__scoped_atomic_store_n instead}}
-  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SYSTEM); // 
expected-warning{{builtin __hip_atomic_store is deprecated; use 
__scoped_atomic_store_n instead}}
-  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, INVALID_HIP_MEMORY_SCOPE); // 
expected-warning{{builtin __hip_atomic_store is deprecated; use 
__scoped_atomic_store_n instead}} // expected-error {{synchronization scope 
argument to atomic operation is invalid}}
-  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);// expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}} 
-  __hip_atomic_store(pi32, 0, __ATOMIC_SEQ_CST, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);// expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}} 
-  __hip_atomic_store(pi32, 0, __ATOMIC_CONSUME, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);// expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}  // 
expected-warning{{memory order argument to atomic operation is invalid}}
-  __hip_atomic_store(pi32, 0, __ATOMIC_ACQUIRE, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);// expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}  // 
expected-warning{{memory order argument to atomic operation is invalid}}
-  __hip_atomic_store(pi32, 0, __ATOMIC_ACQ_REL, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);// expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}  // 
expected-warning{{memory order argument to atomic operation is invalid}}
-  __hip_atomic_store(pi32, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
-  __hip_atomic_store(pi32, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
-  __hip_atomic_store(pu32, u32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
-  __hip_atomic_store(pll, i64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
-  __hip_atomic_store(pull, u64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
-  __hip_atomic_store(fp, f32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
-  __hip_atomic_store(dbl, f64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
-  __hip_atomic_store(pi32, u32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
-  __hip_atomic_store(pi32, i64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
-  __hip_atomic_store(pi32, u64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
-  __hip_atomic_store(pll, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
-  __hip_atomic_store(fp, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
-  __hip_atomic_store(fp, i64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
-  __hip_atomic_store(dbl, i64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
-  __hip_atomic_store(dbl, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{builtin 
__hip_atomic_store is deprecated; use __scoped_atomic_store_n instead}}
+  __hip_atomic_store(pi32, 0, 0, 0); // expected-error {{synchronization scope 
argument to atomic operation is invalid}}
+  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_WAVEFRONT);
+  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_WORKGROUP);
+  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_CLUSTER);
+  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_AGENT);
+  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SYSTEM);
+  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, INVALID_HIP_MEMORY_SCOPE); // 
expected-error {{synchronization scope argument to atomic operation is invalid}}
+  __hip_atomic_store(pi32, 0, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(pi32, 0, __ATOMIC_SEQ_CST, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(pi32, 0, __ATOMIC_CONSUME, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{memory order argument to 
atomic operation is invalid}}
+  __hip_atomic_store(pi32, 0, __ATOMIC_ACQUIRE, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{memory order argument to 
atomic operation is invalid}}
+  __hip_atomic_store(pi32, 0, __ATOMIC_ACQ_REL, 
__HIP_MEMORY_SCOPE_SINGLETHREAD); // expected-warning{{memory order argument to 
atomic operation is invalid}}
+  __hip_atomic_store(pi32, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(pi32, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(pu32, u32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(pll, i64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(pull, u64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(fp, f32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(dbl, f64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(pi32, u32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(pi32, i64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(pi32, u64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(pll, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(fp, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(fp, i64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(dbl, i64, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
+  __hip_atomic_store(dbl, i32, __ATOMIC_RELAXED, 
__HIP_MEMORY_SCOPE_SINGLETHREAD);
   return 0;
 }
 
@@ -69,23 +69,23 @@ __device__ bool test_hip_atomic_cmpxchg_weak(int *ptr, int 
val, int desired) {
   bool flag = __hip_atomic_compare_exchange_weak(0);                           
          // expected-error {{too few arguments to function call, expected 6, 
have 1}}
   flag = __hip_atomic_compare_exchange_weak(0, 0, 0, 0, 0, 0, 0);              
          // expected-error {{too many arguments to function call, expected 6, 
have 7}}
   flag = __hip_atomic_compare_exchange_weak(0, 0, 0, 0, 0, 0);                 
          // expected-error {{address argument to atomic builtin must be a 
pointer ('int' invalid)}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, 0, 0, 0, 0, 0);               
          // expected-warning{{builtin __hip_atomic_compare_exchange_weak is 
deprecated; use __scoped_atomic_compare_exchange instead}} // expected-error 
{{synchronization scope argument to atomic operation is invalid}}, 
expected-warning {{null passed to a callee that requires a non-null argument}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, 0, 0, 0, 0, 
__HIP_MEMORY_SCOPE_SYSTEM); // expected-warning{{builtin 
__hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}} // expected-warning {{null passed to 
a callee that requires a non-null argument}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SYSTEM); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_CONSUME, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_WAVEFRONT); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_WORKGROUP); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_CLUSTER); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_AGENT); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_SEQ_CST, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_CONSUME, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_ACQUIRE, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_ACQ_REL, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}} // expected-warning {{failure memory 
order argument to atomic operation is invalid}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_SEQ_CST, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_CONSUME, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_ACQUIRE, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
-  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_ACQ_REL, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning{{builtin __hip_atomic_compare_exchange_weak is deprecated; use 
__scoped_atomic_compare_exchange instead}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, 0, 0, 0, 0, 0);               
          // expected-error {{synchronization scope argument to atomic 
operation is invalid}}, expected-warning {{null passed to a callee that 
requires a non-null argument}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, 0, 0, 0, 0, 
__HIP_MEMORY_SCOPE_SYSTEM); // expected-warning {{null passed to a callee that 
requires a non-null argument}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SYSTEM);
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_CONSUME, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD);
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_WAVEFRONT);
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_WORKGROUP);
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_CLUSTER);
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_AGENT);
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD);
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_SEQ_CST, __HIP_MEMORY_SCOPE_SINGLETHREAD);
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_CONSUME, __HIP_MEMORY_SCOPE_SINGLETHREAD);
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_ACQUIRE, __HIP_MEMORY_SCOPE_SINGLETHREAD);
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_ACQ_REL, __HIP_MEMORY_SCOPE_SINGLETHREAD); // 
expected-warning {{failure memory order argument to atomic operation is 
invalid}}
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD);
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_SEQ_CST, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD);
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_CONSUME, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD);
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_ACQUIRE, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD);
+  flag = __hip_atomic_compare_exchange_weak(ptr, &val, desired, 
__ATOMIC_ACQ_REL, __ATOMIC_RELAXED, __HIP_MEMORY_SCOPE_SINGLETHREAD);
   return flag;
 }
diff --git a/clang/test/SemaHIP/atomic-deprecated.hip 
b/clang/test/SemaHIP/atomic-deprecated.hip
index b2d5baf9e9d456..45658ed79699be 100644
--- a/clang/test/SemaHIP/atomic-deprecated.hip
+++ b/clang/test/SemaHIP/atomic-deprecated.hip
@@ -1,5 +1,5 @@
-// RUN: %clang_cc1 -x hip -triple amdgpu -fcuda-is-device -verify 
-fsyntax-only -Whip-deprecated-builtins %s
-// RUN: %clang_cc1 -x hip -triple amdgpu -fcuda-is-device 
-fdiagnostics-parseable-fixits -Whip-deprecated-builtins %s 2>&1 | FileCheck %s
+// RUN: %clang_cc1 -x hip -triple amdgpu -fcuda-is-device -verify 
-fsyntax-only %s
+// RUN: %clang_cc1 -x hip -triple amdgpu -fcuda-is-device 
-fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s
 
 #define __device__ __attribute__((device))
 

_______________________________________________
cfe-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

Reply via email to