[CIR] Add syncscope support for atomic load operations

jiang1997 · jiang1997 · commit af464b61c73b · 2025-10-27T03:20:17.000+08:00
diff --git a/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h b/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h
@@ -175,8 +175,8 @@ class CIRBaseBuilderTy : public mlir::OpBuilder {
     return cir::LoadOp::create(*this, loc, ptr, /*isDeref=*/false, isVolatile,
                                isNontemporal,
                                /*alignment=*/alignmentAttr,
-                               /*mem_order=*/
-                               cir::MemOrderAttr{},
+                               /*syncscope=*/cir::MemScopeKindAttr{},
+                               /*mem_order=*/cir::MemOrderAttr{},
                                /*tbaa=*/cir::TBAAAttr{});
   }
 
diff --git a/clang/include/clang/CIR/Dialect/IR/CIROps.td b/clang/include/clang/CIR/Dialect/IR/CIROps.td
@@ -533,6 +533,15 @@ def CIR_MemOrder : CIR_I32EnumAttr<
     I32EnumAttrCase<"SequentiallyConsistent", 5, "seq_cst">
 ]>;
 
+//===----------------------------------------------------------------------===//
+// C/C++ sync scope definitions
+//===----------------------------------------------------------------------===//
+
+def CIR_MemScopeKind : CIR_I32EnumAttr<"MemScopeKind", "memory scope kind", [
+  I32EnumAttrCase<"SingleThread", 0, "single_thread">,
+  I32EnumAttrCase<"System", 1, "system">
+]>;
+
 //===----------------------------------------------------------------------===//
 // AllocaOp
 //===----------------------------------------------------------------------===//
@@ -670,17 +679,19 @@ def CIR_LoadOp : CIR_Op<"load", [
     %4 = cir.load volatile %0 : !cir.ptr<i32>, i32
 
     // Others
-    %x = cir.load align(16) atomic(seq_cst) %0 : !cir.ptr<i32>, i32
+    %x = cir.load align(16) syncscope(single_thread) atomic(seq_cst)
+      %0 : !cir.ptr<i32>, i32
     ```
   }];
 
   let arguments = (ins Arg<CIR_PointerType, "the address to load from",
                            [MemRead]>:$addr, UnitAttr:$isDeref,
                        UnitAttr:$is_volatile,
                        UnitAttr:$is_nontemporal,
-                       OptionalAttr<I64Attr>:$alignment,
-                       OptionalAttr<CIR_MemOrder>:$mem_order,
-                       OptionalAttr<CIR_AnyTBAAAttr>:$tbaa
+                      OptionalAttr<I64Attr>:$alignment,
+                      OptionalAttr<CIR_MemScopeKind>:$syncscope,
+                      OptionalAttr<CIR_MemOrder>:$mem_order,
+                      OptionalAttr<CIR_AnyTBAAAttr>:$tbaa
                        );
   let results = (outs CIR_AnyType:$result);
 
@@ -689,6 +700,7 @@ def CIR_LoadOp : CIR_Op<"load", [
     (`volatile` $is_volatile^)?
     (`nontemporal` $is_nontemporal^)?
     (`align` `(` $alignment^ `)`)?
+    (`syncscope` `(` $syncscope^ `)`)?
     (`atomic` `(` $mem_order^ `)`)?
     $addr `:` qualified(type($addr)) `,` type($result) attr-dict
     (`tbaa` `(` $tbaa^ `)`)?
@@ -698,7 +710,8 @@ def CIR_LoadOp : CIR_Op<"load", [
     // TODO(CIR): The final interface here should include an argument for the
     // SyncScope::ID.
     // This should be used over the ODS generated setMemOrder.
-    void setAtomic(cir::MemOrder order);
+    void setAtomic(cir::MemOrder order,
+                   cir::MemScopeKind scope);
   }];
 
   // FIXME: add verifier.
@@ -6012,11 +6025,6 @@ def CIR_AtomicXchg : CIR_Op<"atomic.xchg", [
   let hasVerifier = 1;
 }
 
-def CIR_MemScopeKind : CIR_I32EnumAttr<"MemScopeKind", "memory scope kind", [
-  I32EnumAttrCase<"SingleThread", 0, "single_thread">,
-  I32EnumAttrCase<"System", 1, "system">
-]>;
-
 def CIR_AtomicCmpXchg : CIR_Op<"atomic.cmp_xchg", [
   AllTypesMatch<["old", "expected", "desired"]>
 ]> {
diff --git a/clang/lib/CIR/CodeGen/CIRGenAtomic.cpp b/clang/lib/CIR/CodeGen/CIRGenAtomic.cpp
@@ -17,6 +17,7 @@
 #include "CIRGenOpenMPRuntime.h"
 #include "TargetInfo.h"
 #include "clang/AST/ASTContext.h"
+#include "clang/Basic/SyncScope.h"
 #include "clang/CIR/Dialect/IR/CIRAttrs.h"
 #include "clang/CIR/Dialect/IR/CIRDataLayout.h"
 #include "clang/CIR/Dialect/IR/CIRDialect.h"
@@ -350,6 +351,20 @@ static cir::IntAttr extractIntAttr(mlir::Value v) {
   return {};
 }
 
+// Maps SyncScope::SingleScope to MemScopeKind::SingleThread,
+// SyncScope::SystemScope to MemScopeKind::System,
+// and asserts (llvm_unreachable) for anything else.
+static cir::MemScopeKind convertSyncScopeToCIR(clang::SyncScope scope) {
+  switch (scope) {
+  case clang::SyncScope::SingleScope:
+    return cir::MemScopeKind::SingleThread;
+  case clang::SyncScope::SystemScope:
+    return cir::MemScopeKind::System;
+  default:
+    llvm_unreachable("NYI");
+  }
+}
+
 // Inspect a value that is the strong/weak flag for a compare-exchange.  If it
 // is a constant of intergral or boolean type, set `val` to the constant's
 // boolean value and return true.  Otherwise leave `val` unchanged and return
@@ -555,6 +570,10 @@ static void emitAtomicOp(CIRGenFunction &CGF, AtomicExpr *E, Address Dest,
   auto orderAttr = cir::MemOrderAttr::get(builder.getContext(), Order);
   cir::AtomicFetchKindAttr fetchAttr;
   bool fetchFirst = true;
+  auto scopeAttr = cir::MemScopeKindAttr::get(builder.getContext(), Scope);
+  std::optional<cir::MemScopeKind> scopeOpt;
+  if (Scope != cir::MemScopeKind::System)
+    scopeOpt = Scope;
 
   switch (E->getOp()) {
   case AtomicExpr::AO__c11_atomic_init:
@@ -594,9 +613,7 @@ static void emitAtomicOp(CIRGenFunction &CGF, AtomicExpr *E, Address Dest,
   case AtomicExpr::AO__scoped_atomic_load_n:
   case AtomicExpr::AO__scoped_atomic_load: {
     auto load = builder.createLoad(loc, Ptr);
-    // FIXME(cir): add scope information.
-    assert(!cir::MissingFeatures::syncScopeID());
-    load.setMemOrder(Order);
+    load.setAtomic(Order, Scope);
     load.setIsVolatile(E->isVolatile());
 
     // TODO(cir): this logic should be part of createStore, but doing so
@@ -818,9 +835,12 @@ static void emitAtomicOp(CIRGenFunction &CGF, AtomicExpr *Expr, Address Dest,
   }
 
   // Handle constant scope.
-  if (extractIntAttr(Scope)) {
+  if (auto scopeAttr = extractIntAttr(Scope)) {
     assert(!cir::MissingFeatures::syncScopeID());
-    llvm_unreachable("NYI");
+    auto mappedScope =
+        convertSyncScopeToCIR(ScopeModel->map(scopeAttr.getUInt()));
+    emitAtomicOp(CGF, Expr, Dest, Ptr, Val1, Val2, IsWeak, FailureOrder, Size,
+                 Order, mappedScope);
     return;
   }
 
diff --git a/clang/lib/CIR/CodeGen/CIRGenBuilder.h b/clang/lib/CIR/CodeGen/CIRGenBuilder.h
@@ -870,6 +870,7 @@ class CIRGenBuilderTy : public cir::CIRBaseBuilderTy {
     return cir::LoadOp::create(
         *this, loc, addr.getElementType(), addr.getPointer(), /*isDeref=*/false,
         /*is_volatile=*/isVolatile, /*is_nontemporal=*/isNontemporal, align,
+        /*syncscope=*/cir::MemScopeKindAttr{},
         /*mem_order=*/cir::MemOrderAttr{}, /*tbaa=*/cir::TBAAAttr{});
   }
 
diff --git a/clang/lib/CIR/CodeGen/CIRGenBuiltinAArch64.cpp b/clang/lib/CIR/CodeGen/CIRGenBuiltinAArch64.cpp
@@ -18,6 +18,7 @@
 #include "CIRGenFunction.h"
 #include "CIRGenModule.h"
 #include "TargetInfo.h"
+#include "clang/CIR/Dialect/IR/CIROpsEnums.h"
 #include "clang/CIR/MissingFeatures.h"
 
 // TODO(cir): once all builtins are covered, decide whether we still
@@ -4485,7 +4486,7 @@ CIRGenFunction::emitAArch64BuiltinExpr(unsigned BuiltinID, const CallExpr *E,
   case NEON::BI__builtin_neon_vldap1q_lane_s64: {
     cir::LoadOp Load = builder.createAlignedLoad(
         Ops[0].getLoc(), vTy.getElementType(), Ops[0], PtrOp0.getAlignment());
-    Load.setAtomic(cir::MemOrder::Acquire);
+    Load.setAtomic(cir::MemOrder::Acquire, cir::MemScopeKind::System);
     return builder.create<cir::VecInsertOp>(getLoc(E->getExprLoc()),
                                             builder.createBitcast(Ops[1], vTy),
                                             Load, Ops[2]);
diff --git a/clang/lib/CIR/Dialect/IR/CIRDialect.cpp b/clang/lib/CIR/Dialect/IR/CIRDialect.cpp
@@ -1012,12 +1012,9 @@ LogicalResult cir::ComplexImagPtrOp::verify() {
 // LoadOp
 //===----------------------------------------------------------------------===//
 
-// TODO(CIR): The final interface here should include an argument for the
-// SyncScope::ID.
-void cir::LoadOp::setAtomic(cir::MemOrder order) {
+void cir::LoadOp::setAtomic(cir::MemOrder order, cir::MemScopeKind scope) {
   setMemOrder(order);
-  if (cir::MissingFeatures::syncScopeID())
-    llvm_unreachable("NYI");
+  setSyncscope(scope);
 }
 
 //===----------------------------------------------------------------------===//
diff --git a/clang/lib/CIR/Dialect/Transforms/TargetLowering/ItaniumCXXABI.cpp b/clang/lib/CIR/Dialect/Transforms/TargetLowering/ItaniumCXXABI.cpp
@@ -383,7 +383,9 @@ void ItaniumCXXABI::lowerGetMethod(
     mlir::Value vtablePtr = rewriter.create<cir::LoadOp>(
         op.getLoc(), vtablePtrPtr, /*isDeref=*/false, /*isVolatile=*/false,
         /*isNontemporal=*/false,
-        /*alignment=*/mlir::IntegerAttr(), /*mem_order=*/cir::MemOrderAttr(),
+        /*alignment=*/mlir::IntegerAttr(),
+        /*syncscope=*/cir::MemScopeKindAttr{},
+        /*mem_order=*/cir::MemOrderAttr(),
         /*tbaa=*/mlir::ArrayAttr());
 
     // Get the vtable offset.
@@ -418,6 +420,7 @@ void ItaniumCXXABI::lowerGetMethod(
             op.getLoc(), vfpPtr, /*isDeref=*/false, /*isVolatile=*/false,
             /*isNontemporal=*/false,
             /*alignment=*/mlir::IntegerAttr(),
+            /*syncscope=*/cir::MemScopeKindAttr{},
             /*mem_order=*/cir::MemOrderAttr(),
             /*tbaa=*/mlir::ArrayAttr());
       }
diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp
@@ -1824,6 +1824,8 @@ mlir::LogicalResult CIRToLLVMLoadOpLowering::matchAndRewrite(
       op->getLoc(), llvmTy, adaptor.getAddr(), /* alignment */ alignment,
       op.getIsVolatile(), /* nontemporal */ op.getIsNontemporal(),
       /* invariant */ false, /* invariantGroup */ invariant, ordering);
+  if (auto scope = op.getSyncscope())
+    newLoad.setSyncscope(getLLVMSyncScope(scope));
 
   // Convert adapted result to its original type if needed.
   mlir::Value result =
diff --git a/clang/lib/CIR/Lowering/ThroughMLIR/LowerCIRLoopToSCF.cpp b/clang/lib/CIR/Lowering/ThroughMLIR/LowerCIRLoopToSCF.cpp
@@ -482,6 +482,7 @@ class CIRWhileOpLowering : public mlir::OpConversionPattern<cir::WhileOp> {
       auto cond = rewriter.create<LoadOp>(
           loc, boolTy, condAlloca, /*isDeref=*/false,
           /*volatile=*/false, /*nontemporal=*/false, alignment,
+          /*syncscope=*/cir::MemScopeKindAttr{},
           /*memorder=*/cir::MemOrderAttr{}, /*tbaa=*/cir::TBAAAttr{});
       auto ifnot =
           rewriter.create<IfOp>(loc, cond, /*withElseRegion=*/false,
diff --git a/clang/test/CIR/CodeGen/scoped-atomic-load-store.c b/clang/test/CIR/CodeGen/scoped-atomic-load-store.c
@@ -0,0 +1,16 @@
+// RUN: %clang_cc1 -x c -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o %t.cir
+// RUN: FileCheck --input-file=%t.cir %s
+
+// CHECK-LABEL: @scoped_load_thread
+// CHECK: %[[ATOMIC_LOAD:.*]] = cir.load align(4) syncscope(single_thread) atomic(relaxed) %{{.*}} : !cir.ptr<!s32i>, !s32i
+// CHECK: cir.store align(4) %[[ATOMIC_LOAD]], %{{.*}} : !s32i, !cir.ptr<!s32i>
+int scoped_load_thread(int *ptr) {
+  return __scoped_atomic_load_n(ptr, __ATOMIC_RELAXED, __MEMORY_SCOPE_SINGLE);
+}
+
+// CHECK-LABEL: @scoped_load_system
+// CHECK: cir.load align(4) syncscope(system) atomic(seq_cst) %{{.*}} : !cir.ptr<!s32i>, !s32i
+int scoped_load_system(int *ptr) {
+  return __scoped_atomic_load_n(ptr, __ATOMIC_SEQ_CST, __MEMORY_SCOPE_SYSTEM);
+}
+
diff --git a/clang/test/CIR/Lowering/syncscope.cir b/clang/test/CIR/Lowering/syncscope.cir
@@ -1,12 +1,29 @@
-// RUN: cir-translate %s -cir-to-llvmir --disable-cc-lowering -o -  | FileCheck %s -check-prefix=LLVM
-
-!s32i = !cir.int<s, 32>
-#fn_attr = #cir<extra({inline = #cir.inline<no>, nothrow = #cir.nothrow, optnone = #cir.optnone})>
-module {
-  cir.func @test(%ptr: !cir.ptr<!s32i>, %expected: !s32i, %desired: !s32i) -> !cir.bool extra(#fn_attr) {
-    %old, %cmp = cir.atomic.cmp_xchg(%ptr : !cir.ptr<!s32i>, %expected : !s32i, %desired : !s32i, success = acquire, failure = acquire) syncscope(single_thread) align(4) : (!s32i, !cir.bool)
-    cir.return %cmp: !cir.bool
-  }
-}
-
-// LLVM: {{%.*}} = cmpxchg ptr {{%.*}}, i32 {{%.*}}, i32 {{%.*}} syncscope("singlethread") acquire acquire, align 4
+// RUN: cir-translate %s -cir-to-llvmir --disable-cc-lowering -o -  | FileCheck %s -check-prefix=LLVM
+
+!s32i = !cir.int<s, 32>
+#fn_attr = #cir<extra({inline = #cir.inline<no>, nothrow = #cir.nothrow, optnone = #cir.optnone})>
+module {
+  cir.func @test(%ptr: !cir.ptr<!s32i>, %expected: !s32i, %desired: !s32i) -> !cir.bool extra(#fn_attr) {
+    %old, %cmp = cir.atomic.cmp_xchg(%ptr : !cir.ptr<!s32i>, %expected : !s32i, %desired : !s32i, success = acquire, failure = acquire) syncscope(single_thread) align(4) : (!s32i, !cir.bool)
+    cir.return %cmp: !cir.bool
+  }
+
+  cir.func @load(%ptr: !cir.ptr<!s32i>) -> !s32i extra(#fn_attr) {
+    %val = cir.load syncscope(single_thread) atomic(relaxed) %ptr : !cir.ptr<!s32i>, !s32i
+    cir.return %val : !s32i
+  }
+
+
+  // System scope should not materialize a syncscope attribute.
+  cir.func @system_load(%ptr: !cir.ptr<!s32i>) -> !s32i extra(#fn_attr) {
+    %val = cir.load atomic(seq_cst) %ptr : !cir.ptr<!s32i>, !s32i
+    cir.return %val : !s32i
+  }
+
+}
+
+// LLVM: {{%.*}} = cmpxchg ptr {{%.*}}, i32 {{%.*}}, i32 {{%.*}} syncscope("singlethread") acquire acquire, align 4
+// LLVM: load atomic i32, ptr {{%.*}} syncscope("singlethread") monotonic, align 4
+// LLVM-LABEL: @system_load
+// LLVM: load atomic i32, ptr {{%.*}} seq_cst, align 4
+// LLVM-NOT: syncscope(
diff --git a/clang/test/CIR/Transforms/lifetime-check-range-for-vector.cpp b/clang/test/CIR/Transforms/lifetime-check-range-for-vector.cpp
@@ -1,7 +1,5 @@
 // RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu -I%S/../Inputs -mconstructor-aliases -fclangir -fclangir-lifetime-check="history=all" -fclangir-skip-system-headers -clangir-verify-diagnostics -emit-cir %s -o %t.cir
 
-// XFAIL: *
-
 #include "std-cxx.h"
 
 // expected-no-diagnostics

Original file line number	Diff line number	Diff line change
`@@ -870,6 +870,7 @@ class CIRGenBuilderTy : public cir::CIRBaseBuilderTy {`
`870`	`870`	`return cir::LoadOp::create(`
`871`	`871`	`this, loc, addr.getElementType(), addr.getPointer(), /isDeref=*/false,`
`872`	`872`	`/is_volatile=/isVolatile, /is_nontemporal=/isNontemporal, align,`
	`873`	`+ /syncscope=/cir::MemScopeKindAttr{},`
`873`	`874`	`/mem_order=/cir::MemOrderAttr{}, /tbaa=/cir::TBAAAttr{});`
`874`	`875`	`}`
`875`	`876`