SIL: allow atomic operations in @_noLocks functions

#74407

lib/SIL/Utils/InstructionUtils.cpp

@@ -728,8 +728,7 @@ RuntimeEffect swift::getRuntimeEffect(SILInstruction *inst, SILType &impactType)
   case SILInstructionKind::AllocStackInst:
   case SILInstructionKind::AllocVectorInst:
   case SILInstructionKind::ProjectBoxInst:
-    if (!cast<SingleValueInstruction>(inst)->getType().
-          isLoadable(*inst->getFunction())) {
+    if (cast<SingleValueInstruction>(inst)->getType().hasArchetype()) {
       impactType = cast<SingleValueInstruction>(inst)->getType();
       return RuntimeEffect::MetaData;
     }
@@ -1028,7 +1027,7 @@ RuntimeEffect swift::getRuntimeEffect(SILInstruction *inst, SILType &impactType)
     case BuiltinValueKind::AtomicLoad:
     case BuiltinValueKind::AtomicStore:
     case BuiltinValueKind::AtomicRMW:
-      return RuntimeEffect::Locking;
+      return RuntimeEffect::NoEffect;
     case BuiltinValueKind::DestroyArray:
       return RuntimeEffect::Releasing;
     case BuiltinValueKind::CopyArray:

test/SILOptimizer/performance-annotations-atomics.swift

@@ -0,0 +1,30 @@
+// RUN: %target-swift-frontend -parse-as-library -disable-availability-checking -emit-sil %s -o /dev/null
+
+// REQUIRES: synchronization
+
+import Synchronization
+
+// Check that atomics work in no-locks mode.
+
+@_noLocks
+func testFence() {
+  atomicMemoryFence(ordering: .acquiring)
+  atomicMemoryFence(ordering: .releasing)
+  atomicMemoryFence(ordering: .acquiringAndReleasing)
+  atomicMemoryFence(ordering: .sequentiallyConsistent)
+}
+
+@_noLocks
+func testLoadStore() -> Int {
+  let x = Atomic(0)
+  x.store(27, ordering: .relaxed)
+  x.compareExchange(expected: 27, desired: 42, successOrdering: .relaxed, failureOrdering: .relaxed)
+  return x.load(ordering: .acquiring)
+}
+
+@_noLocks
+func testRMW(_ b: Bool) -> (Bool, Bool) {
+  let x = Atomic(false)
+  return x.logicalOr(true, ordering: .relaxed)
+}
+