Commit 9fa723ee5043a9d2cb017e417f2e27041f671146 | zig

src/AstGen.zig+1-1

...	@@ -2118,7 +2118,6 @@ fn unusedResultExpr(gz: GenZir, scope: Scope, statement: Ast.Node.Index) Inner	...	@@ -2118,7 +2118,6 @@ fn unusedResultExpr(gz: GenZir, scope: Scope, statement: Ast.Node.Index) Inner
2118	.select,	2118	.select,
2119	.atomic_load,	2119	.atomic_load,
2120	.atomic_rmw,	2120	.atomic_rmw,
2121	.atomic_store,
2122	.mul_add,	2121	.mul_add,
2123	.builtin_call,	2122	.builtin_call,
2124	.field_ptr_type,	2123	.field_ptr_type,
...	@@ -2164,6 +2163,7 @@ fn unusedResultExpr(gz: GenZir, scope: Scope, statement: Ast.Node.Index) Inner	...	@@ -2164,6 +2163,7 @@ fn unusedResultExpr(gz: GenZir, scope: Scope, statement: Ast.Node.Index) Inner
2164	.@"export",	2163	.@"export",
2165	.set_eval_branch_quota,	2164	.set_eval_branch_quota,
2166	.ensure_err_payload_void,	2165	.ensure_err_payload_void,
		2166	.atomic_store,
2167	.store,	2167	.store,
2168	.store_node,	2168	.store_node,
2169	.store_to_block_ptr,	2169	.store_to_block_ptr,

src/Sema.zig+60-10

 @@ -314,7 +314,6 @@ pub fn analyzeBody(
             .select                       => try sema.zirSelect(block, inst),
             .atomic_load                  => try sema.zirAtomicLoad(block, inst),
             .atomic_rmw                   => try sema.zirAtomicRmw(block, inst),
-            .atomic_store                 => try sema.zirAtomicStore(block, inst),
             .mul_add                      => try sema.zirMulAdd(block, inst),
             .builtin_call                 => try sema.zirBuiltinCall(block, inst),
             .field_ptr_type               => try sema.zirFieldPtrType(block, inst),
 @@ -413,6 +412,11 @@ pub fn analyzeBody(
                 i += 1;
                 continue;
             },
+            .atomic_store => {
+                try sema.zirAtomicStore(block, inst);
+                i += 1;
+                continue;
+            },
             .store => {
                 try sema.zirStore(block, inst);
                 i += 1;
 @@ -7669,6 +7673,8 @@ fn zirCmpxchg(
         if (try sema.resolveMaybeUndefVal(block, expected_src, expected_value)) |expected_val| {
             if (try sema.resolveMaybeUndefVal(block, new_value_src, new_value)) |new_val| {
                 if (expected_val.isUndef() or new_val.isUndef()) {
+                    // TODO: this should probably cause the memory stored at the pointer
+                    // to become undef as well
                     return sema.addConstUndef(result_ty);
                 }
                 const stored_val = (try ptr_val.pointerDeref(sema.arena)) orelse break :rs ptr_src;
 @@ -7830,10 +7836,38 @@ fn zirAtomicRmw(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileE
     });
 }
-fn zirAtomicStore(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
+fn zirAtomicStore(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!void {
     const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
+    const extra = sema.code.extraData(Zir.Inst.AtomicStore, inst_data.payload_index).data;
     const src = inst_data.src();
-    return sema.mod.fail(&block.base, src, "TODO: Sema.zirAtomicStore", .{});
+    // zig fmt: off
+    const operand_ty_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = inst_data.src_node };
+    const ptr_src       : LazySrcLoc = .{ .node_offset_builtin_call_arg1 = inst_data.src_node };
+    const operand_src   : LazySrcLoc = .{ .node_offset_builtin_call_arg2 = inst_data.src_node };
+    const order_src     : LazySrcLoc = .{ .node_offset_builtin_call_arg3 = inst_data.src_node };
+    // zig fmt: on
+    const ptr = sema.resolveInst(extra.ptr);
+    const operand_ty = sema.typeOf(ptr).elemType();
+    try sema.checkAtomicOperandType(block, operand_ty_src, operand_ty);
+    const operand = try sema.coerce(block, operand_ty, sema.resolveInst(extra.operand), operand_src);
+    const order = try sema.resolveAtomicOrder(block, order_src, extra.ordering);
+    const air_tag: Air.Inst.Tag = switch (order) {
+        .Acquire, .AcqRel => {
+            return sema.mod.fail(
+                &block.base,
+                order_src,
+                "@atomicStore atomic ordering must not be Acquire or AcqRel",
+                .{},
+            );
+        },
+        .Unordered => .atomic_store_unordered,
+        .Monotonic => .atomic_store_monotonic,
+        .Release => .atomic_store_release,
+        .SeqCst => .atomic_store_seq_cst,
+    };
+    return sema.storePtr2(block, src, ptr, ptr_src, operand, operand_src, air_tag);
 }
 fn zirMulAdd(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
 @@ -9310,25 +9344,39 @@ fn coerceVarArgParam(
     return inst;
 }
+// TODO migrate callsites to use storePtr2 instead.
 fn storePtr(
     sema: *Sema,
     block: *Scope.Block,
     src: LazySrcLoc,
     ptr: Air.Inst.Ref,
-    uncasted_value: Air.Inst.Ref,
+    uncasted_operand: Air.Inst.Ref,
+) !void {
+    return sema.storePtr2(block, src, ptr, src, uncasted_operand, src, .store);
+}
+fn storePtr2(
+    sema: *Sema,
+    block: *Scope.Block,
+    src: LazySrcLoc,
+    ptr: Air.Inst.Ref,
+    ptr_src: LazySrcLoc,
+    uncasted_operand: Air.Inst.Ref,
+    operand_src: LazySrcLoc,
+    air_tag: Air.Inst.Tag,
 ) !void {
     const ptr_ty = sema.typeOf(ptr);
     if (ptr_ty.isConstPtr())
         return sema.mod.fail(&block.base, src, "cannot assign to constant", .{});
     const elem_ty = ptr_ty.elemType();
-    const value = try sema.coerce(block, elem_ty, uncasted_value, src);
+    const operand = try sema.coerce(block, elem_ty, uncasted_operand, operand_src);
     if ((try sema.typeHasOnePossibleValue(block, src, elem_ty)) != null)
         return;
-    if (try sema.resolveDefinedValue(block, src, ptr)) |ptr_val| {
+    const runtime_src = if (try sema.resolveDefinedValue(block, ptr_src, ptr)) |ptr_val| rs: {
         if (ptr_val.castTag(.decl_ref_mut)) |decl_ref_mut| {
-            const const_val = (try sema.resolveMaybeUndefVal(block, src, value)) orelse
+            const const_val = (try sema.resolveMaybeUndefVal(block, operand_src, operand)) orelse
                 return sema.mod.fail(&block.base, src, "cannot store runtime value in compile time variable", .{});
             if (decl_ref_mut.data.runtime_index < block.runtime_index) {
 @@ -9365,11 +9413,13 @@ fn storePtr(
             old_arena.deinit();
             return;
         }
-    }
+        break :rs operand_src;
+    } else ptr_src;
     // TODO handle if the element type requires comptime
-    try sema.requireRuntimeBlock(block, src);
+    try sema.requireRuntimeBlock(block, runtime_src);
-    _ = try block.addBinOp(.store, ptr, value);
+    _ = try block.addBinOp(air_tag, ptr, operand);
 }
 fn bitcast(

src/Zir.zig+15-4

 @@ -3058,7 +3058,6 @@ const Writer = struct {
             .shuffle,
             .select,
             .atomic_rmw,
-            .atomic_store,
             .mul_add,
             .builtin_call,
             .field_parent_ptr,
 @@ -3071,9 +3070,8 @@ const Writer = struct {
             .struct_init_ref,
             => try self.writeStructInit(stream, inst),
-            .cmpxchg_strong,
+            .cmpxchg_strong, .cmpxchg_weak => try self.writeCmpxchg(stream, inst),
-            .cmpxchg_weak,
+            .atomic_store => try self.writeAtomicStore(stream, inst),
-            => try self.writeCmpxchg(stream, inst),
             .struct_init_anon,
             .struct_init_anon_ref,
 @@ -3493,6 +3491,19 @@ const Writer = struct {
         try self.writeSrc(stream, inst_data.src());
     }
+    fn writeAtomicStore(self: *Writer, stream: anytype, inst: Inst.Index) !void {
+        const inst_data = self.code.instructions.items(.data)[inst].pl_node;
+        const extra = self.code.extraData(Inst.AtomicStore, inst_data.payload_index).data;
+        try self.writeInstRef(stream, extra.ptr);
+        try stream.writeAll(", ");
+        try self.writeInstRef(stream, extra.operand);
+        try stream.writeAll(", ");
+        try self.writeInstRef(stream, extra.ordering);
+        try stream.writeAll(") ");
+        try self.writeSrc(stream, inst_data.src());
+    }
     fn writeStructInitAnon(self: *Writer, stream: anytype, inst: Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[inst].pl_node;
         const extra = self.code.extraData(Inst.StructInitAnon, inst_data.payload_index);

test/behavior/atomics.zig+8

...	@@ -130,3 +130,11 @@ test "atomic load and rmw with enum" {	...	@@ -130,3 +130,11 @@ test "atomic load and rmw with enum" {
130	try expect(@atomicLoad(Value, &x, .SeqCst) != .a);	130	try expect(@atomicLoad(Value, &x, .SeqCst) != .a);
131	try expect(@atomicLoad(Value, &x, .SeqCst) != .b);	131	try expect(@atomicLoad(Value, &x, .SeqCst) != .b);
132	}	132	}
		133
		134	test "atomic store" {
		135	var x: u32 = 0;
		136	@atomicStore(u32, &x, 1, .SeqCst);
		137	try expect(@atomicLoad(u32, &x, .SeqCst) == 1);
		138	@atomicStore(u32, &x, 12345678, .SeqCst);
		139	try expect(@atomicLoad(u32, &x, .SeqCst) == 12345678);
		140	}

test/behavior/atomics_stage1.zig-8

...	@@ -3,14 +3,6 @@ const expect = std.testing.expect;	...	@@ -3,14 +3,6 @@ const expect = std.testing.expect;
3	const expectEqual = std.testing.expectEqual;	3	const expectEqual = std.testing.expectEqual;
4	const builtin = @import("builtin");	4	const builtin = @import("builtin");
5		5
6	test "atomic store" {
7	var x: u32 = 0;
8	@atomicStore(u32, &x, 1, .SeqCst);
9	try expect(@atomicLoad(u32, &x, .SeqCst) == 1);
10	@atomicStore(u32, &x, 12345678, .SeqCst);
11	try expect(@atomicLoad(u32, &x, .SeqCst) == 12345678);
12	}
13
14	test "atomic store comptime" {	6	test "atomic store comptime" {
15	comptime try testAtomicStore();	7	comptime try testAtomicStore();
16	try testAtomicStore();	8	try testAtomicStore();

author	Andrew Kelley <andrew@ziglang.org> 2021-09-19 15:07:51-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2021-09-19 15:08:38-07:00
log	9fa723ee5043a9d2cb017e417f2e27041f671146
tree	d25613e4fcf60dbb5294946eb578de7ebe2c1be4
parent	2a0c44fff3506cdc072d67374e7ffca495cebdc7

stage2: implement `@atomicStore`