================
@@ -815,6 +857,85 @@ RValue CIRGenFunction::emitAtomicExpr(AtomicExpr *e) {
e->getExprLoc());
}
+void CIRGenFunction::emitAtomicStore(RValue rvalue, LValue dest, bool isInit) {
+ bool isVolatile = dest.isVolatileQualified();
+ cir::MemOrder order;
+ if (dest.getType()->isAtomicType()) {
+ order = cir::MemOrder::SequentiallyConsistent;
+ } else {
+ order = cir::MemOrder::Release;
+ isVolatile = true;
+ }
+ return emitAtomicStore(rvalue, dest, order, isVolatile, isInit);
+}
+
+/// Emit a store to an l-value of atomic type.
+///
+/// Note that the r-value is expected to be an r-value of the atomic type; this
+/// means that for aggregate r-values, it should include storage for any
padding
+/// that was necessary.
+void CIRGenFunction::emitAtomicStore(RValue rvalue, LValue dest,
+ cir::MemOrder order, bool isVolatile,
+ bool isInit) {
+ // If this is an aggregate r-value, it should agree in type except
+ // maybe for address-space qualification.
+ auto loc = dest.getPointer().getLoc();
+ assert(!rvalue.isAggregate() ||
+ rvalue.getAggregateAddress().getElementType() ==
+ dest.getAddress().getElementType());
+
+ AtomicInfo atomics(*this, dest, loc);
+ LValue lvalue = atomics.getAtomicLValue();
+
+ // If this is an initialization, just put the value there normally.
+ if (lvalue.isSimple()) {
+ if (isInit) {
+ atomics.emitCopyIntoMemory(rvalue);
+ return;
+ }
+
+ // Check whether we should use a library call.
+ if (atomics.shouldUseLibCall()) {
+ assert(!cir::MissingFeatures::atomicUseLibCall());
+ cgm.errorNYI(loc, "emitAtomicStore: atomic store with library call");
+ return;
+ }
+
+ // Okay, we're doing this natively.
+ mlir::Value valueToStore = atomics.convertRValueToInt(rvalue);
+
+ // Do the atomic store.
+ Address addr = atomics.getAtomicAddress();
+ if (mlir::Value value = atomics.getScalarRValValueOrNull(rvalue)) {
+ if (shouldCastToInt(value.getType(), /*CmpXchg=*/false)) {
+ addr = atomics.castToAtomicIntPointer(addr);
+ valueToStore =
+ builder.createIntCast(valueToStore, addr.getElementType());
+ }
+ }
+ cir::StoreOp store = builder.createStore(loc, valueToStore, addr);
+
+ // Initializations don't need to be atomic.
+ if (!isInit) {
+ if (order == cir::MemOrder::Acquire)
+ order = cir::MemOrder::Relaxed; // Monotonic
+ else if (order == cir::MemOrder::AcquireRelease)
+ order = cir::MemOrder::Release;
+ store.setMemOrder(order);
----------------
Lancern wrote:
This should be related to OpenMP. Replaced it with a missing feature guard.
https://github.com/llvm/llvm-project/pull/165872
_______________________________________________
cfe-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
