Commit f1f998e07124f141312289ff82e0ad8d99af1cf7 | zig

doc/langref.html.in+49-5

...	@@ -4065,16 +4065,60 @@ comptime {	...	@@ -4065,16 +4065,60 @@ comptime {
4065	</p>	4065	</p>
4066		4066
4067	{#header_close#}	4067	{#header_close#}
4068	{#header_open\|@cmpxchg#}	4068	{#header_open\|@cmpxchgStrong#}
4069	<pre><code class="zig">@cmpxchg(ptr: &T, cmp: T, new: T, success_order: AtomicOrder, fail_order: AtomicOrder) -> bool</code></pre>	4069	<pre><code class="zig">@cmpxchgStrong(comptime T: type, ptr: &T, expected_value: T, new_value: T, success_order: AtomicOrder, fail_order: AtomicOrder) -> ?T</code></pre>
4070	<p>	4070	<p>
4071	This function performs an atomic compare exchange operation.	4071	This function performs a strong atomic compare exchange operation. It's the equivalent of this code,
		4072	except atomic:
		4073	</p>
		4074	{#code_begin\|syntax#}
		4075	fn cmpxchgStrongButNotAtomic(comptime T: type, ptr: &T, expected_value: T, new_value: T) ?T {
		4076	const old_value = *ptr;
		4077	if (old_value == expected_value) {
		4078	*ptr = new_value;
		4079	return null;
		4080	} else {
		4081	return old_value;
		4082	}
		4083	}
		4084	{#code_end#}
		4085	<p>
		4086	If you are using cmpxchg in a loop, {#link\|@cmpxchgWeak#} is the better choice, because it can be implemented
		4087	more efficiently in machine instructions.
4072	</p>	4088	</p>
4073	<p>	4089	<p>
4074	<code>AtomicOrder</code> can be found with <code>@import("builtin").AtomicOrder</code>.	4090	<code>AtomicOrder</code> can be found with <code>@import("builtin").AtomicOrder</code>.
4075	</p>	4091	</p>
4076	<p><code>@typeOf(ptr).alignment</code> must be <code>>= @sizeOf(T).</code></p>	4092	<p><code>@typeOf(ptr).alignment</code> must be <code>>= @sizeOf(T).</code></p>
4077	{#see_also\|Compile Variables#}	4093	{#see_also\|Compile Variables\|cmpxchgWeak#}
		4094	{#header_close#}
		4095	{#header_open\|@cmpxchgWeak#}
		4096	<pre><code class="zig">@cmpxchgWeak(comptime T: type, ptr: &T, expected_value: T, new_value: T, success_order: AtomicOrder, fail_order: AtomicOrder) -> ?T</code></pre>
		4097	<p>
		4098	This function performs a weak atomic compare exchange operation. It's the equivalent of this code,
		4099	except atomic:
		4100	</p>
		4101	{#code_begin\|syntax#}
		4102	fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: &T, expected_value: T, new_value: T) ?T {
		4103	const old_value = *ptr;
		4104	if (old_value == expected_value and usuallyTrueButSometimesFalse()) {
		4105	*ptr = new_value;
		4106	return null;
		4107	} else {
		4108	return old_value;
		4109	}
		4110	}
		4111	{#code_end#}
		4112	<p>
		4113	If you are using cmpxchg in a loop, the sporadic failure will be no problem, and <code>cmpxchgWeak</code>
		4114	is the better choice, because it can be implemented more efficiently in machine instructions.
		4115	However if you need a stronger guarantee, use {#link\|@cmpxchgStrong#}.
		4116	</p>
		4117	<p>
		4118	<code>AtomicOrder</code> can be found with <code>@import("builtin").AtomicOrder</code>.
		4119	</p>
		4120	<p><code>@typeOf(ptr).alignment</code> must be <code>>= @sizeOf(T).</code></p>
		4121	{#see_also\|Compile Variables\|cmpxchgStrong#}
4078	{#header_close#}	4122	{#header_close#}
4079	{#header_open\|@compileError#}	4123	{#header_open\|@compileError#}
4080	<pre><code class="zig">@compileError(comptime msg: []u8)</code></pre>	4124	<pre><code class="zig">@compileError(comptime msg: []u8)</code></pre>
...	@@ -6020,7 +6064,7 @@ hljs.registerLanguage("zig", function(t) {	...	@@ -6020,7 +6064,7 @@ hljs.registerLanguage("zig", function(t) {
6020	a = t.IR + "\\s*\\(",	6064	a = t.IR + "\\s*\\(",
6021	c = {	6065	c = {
6022	keyword: "const align var extern stdcallcc nakedcc volatile export pub noalias inline struct packed enum union break return try catch test continue unreachable comptime and or asm defer errdefer if else switch while for fn use bool f32 f64 void type noreturn error i8 u8 i16 u16 i32 u32 i64 u64 isize usize i8w u8w i16w i32w u32w i64w u64w isizew usizew c_short c_ushort c_int c_uint c_long c_ulong c_longlong c_ulonglong",	6066	keyword: "const align var extern stdcallcc nakedcc volatile export pub noalias inline struct packed enum union break return try catch test continue unreachable comptime and or asm defer errdefer if else switch while for fn use bool f32 f64 void type noreturn error i8 u8 i16 u16 i32 u32 i64 u64 isize usize i8w u8w i16w i32w u32w i64w u64w isizew usizew c_short c_ushort c_int c_uint c_long c_ulong c_longlong c_ulonglong",
6023	built_in: "atomicLoad breakpoint returnAddress frameAddress fieldParentPtr setFloatMode IntType OpaqueType compileError compileLog setCold setRuntimeSafety setEvalBranchQuota offsetOf memcpy inlineCall setGlobalLinkage setGlobalSection divTrunc divFloor enumTagName intToPtr ptrToInt panic canImplicitCast ptrCast bitCast rem mod memset sizeOf alignOf alignCast maxValue minValue memberCount memberName memberType typeOf addWithOverflow subWithOverflow mulWithOverflow shlWithOverflow shlExact shrExact cInclude cDefine cUndef ctz clz import cImport errorName embedFile cmpxchg fence divExact truncate atomicRmw sqrt",	6067	built_in: "atomicLoad breakpoint returnAddress frameAddress fieldParentPtr setFloatMode IntType OpaqueType compileError compileLog setCold setRuntimeSafety setEvalBranchQuota offsetOf memcpy inlineCall setGlobalLinkage setGlobalSection divTrunc divFloor enumTagName intToPtr ptrToInt panic canImplicitCast ptrCast bitCast rem mod memset sizeOf alignOf alignCast maxValue minValue memberCount memberName memberType typeOf addWithOverflow subWithOverflow mulWithOverflow shlWithOverflow shlExact shrExact cInclude cDefine cUndef ctz clz import cImport errorName embedFile cmpxchgStrong cmpxchgWeak fence divExact truncate atomicRmw sqrt",
6024	literal: "true false null undefined"	6068	literal: "true false null undefined"
6025	},	6069	},
6026	n = [e, t.CLCM, t.CBCM, s, r];	6070	n = [e, t.CLCM, t.CBCM, s, r];

src/all_types.hpp+8-1

 @@ -1310,7 +1310,8 @@ enum BuiltinFnId {
     BuiltinFnIdReturnAddress,
     BuiltinFnIdFrameAddress,
     BuiltinFnIdEmbedFile,
-    BuiltinFnIdCmpExchange,
+    BuiltinFnIdCmpxchgWeak,
+    BuiltinFnIdCmpxchgStrong,
     BuiltinFnIdFence,
     BuiltinFnIdDivExact,
     BuiltinFnIdDivTrunc,
 @@ -2528,6 +2529,7 @@ struct IrInstructionEmbedFile {
 struct IrInstructionCmpxchg {
     IrInstruction base;
+    IrInstruction *type_value;
     IrInstruction *ptr;
     IrInstruction *cmp_value;
     IrInstruction *new_value;
 @@ -2535,8 +2537,13 @@ struct IrInstructionCmpxchg {
     IrInstruction *failure_order_value;
     // if this instruction gets to runtime then we know these values:
+    TypeTableEntry *type;
     AtomicOrder success_order;
     AtomicOrder failure_order;
+    bool is_weak;
+    LLVMValueRef tmp_ptr;
 };
 struct IrInstructionFence {

src/codegen.cpp+18-3

 @@ -3558,9 +3558,20 @@ static LLVMValueRef ir_render_cmpxchg(CodeGen *g, IrExecutable *executable, IrIn
     LLVMAtomicOrdering failure_order = to_LLVMAtomicOrdering(instruction->failure_order);
     LLVMValueRef result_val = ZigLLVMBuildCmpXchg(g->builder, ptr_val, cmp_val, new_val,
-            success_order, failure_order);
+            success_order, failure_order, instruction->is_weak);
-    return LLVMBuildExtractValue(g->builder, result_val, 1, "");
+    assert(instruction->tmp_ptr != nullptr);
+    assert(type_has_bits(instruction->type));
+    LLVMValueRef payload_val = LLVMBuildExtractValue(g->builder, result_val, 0, "");
+    LLVMValueRef val_ptr = LLVMBuildStructGEP(g->builder, instruction->tmp_ptr, maybe_child_index, "");
+    gen_assign_raw(g, val_ptr, get_pointer_to_type(g, instruction->type, false), payload_val);
+    LLVMValueRef success_bit = LLVMBuildExtractValue(g->builder, result_val, 1, "");
+    LLVMValueRef nonnull_bit = LLVMBuildNot(g->builder, success_bit, "");
+    LLVMValueRef maybe_ptr = LLVMBuildStructGEP(g->builder, instruction->tmp_ptr, maybe_null_index, "");
+    gen_store_untyped(g, nonnull_bit, maybe_ptr, 0, false);
+    return instruction->tmp_ptr;
 }
 static LLVMValueRef ir_render_fence(CodeGen *g, IrExecutable *executable, IrInstructionFence *instruction) {
 @@ -5588,6 +5599,9 @@ static void do_code_gen(CodeGen *g) {
             } else if (instruction->id == IrInstructionIdErrWrapCode) {
                 IrInstructionErrWrapCode *err_wrap_code_instruction = (IrInstructionErrWrapCode *)instruction;
                 slot = &err_wrap_code_instruction->tmp_ptr;
+            } else if (instruction->id == IrInstructionIdCmpxchg) {
+                IrInstructionCmpxchg *cmpxchg_instruction = (IrInstructionCmpxchg *)instruction;
+                slot = &cmpxchg_instruction->tmp_ptr;
             } else {
                 zig_unreachable();
             }
 @@ -6115,7 +6129,8 @@ static void define_builtin_fns(CodeGen *g) {
     create_builtin_fn(g, BuiltinFnIdTypeName, "typeName", 1);
     create_builtin_fn(g, BuiltinFnIdCanImplicitCast, "canImplicitCast", 2);
     create_builtin_fn(g, BuiltinFnIdEmbedFile, "embedFile", 1);
-    create_builtin_fn(g, BuiltinFnIdCmpExchange, "cmpxchg", 5);
+    create_builtin_fn(g, BuiltinFnIdCmpxchgWeak, "cmpxchgWeak", 6);
+    create_builtin_fn(g, BuiltinFnIdCmpxchgStrong, "cmpxchgStrong", 6);
     create_builtin_fn(g, BuiltinFnIdFence, "fence", 1);
     create_builtin_fn(g, BuiltinFnIdTruncate, "truncate", 2);
     create_builtin_fn(g, BuiltinFnIdCompileErr, "compileError", 1);

src/ir.cpp+45-40

 @@ -110,6 +110,7 @@ static IrInstruction *ir_analyze_container_field_ptr(IrAnalyze *ira, Buf *field_
     IrInstruction *source_instr, IrInstruction *container_ptr, TypeTableEntry *container_type);
 static IrInstruction *ir_get_var_ptr(IrAnalyze *ira, IrInstruction *instruction,
         VariableTableEntry *var, bool is_const_ptr, bool is_volatile_ptr);
+static TypeTableEntry *ir_resolve_atomic_operand_type(IrAnalyze *ira, IrInstruction *op);
 ConstExprValue *const_ptr_pointee(CodeGen *g, ConstExprValue *const_val) {
     assert(const_val->type->id == TypeTableEntryIdPointer);
 @@ -1832,38 +1833,34 @@ static IrInstruction *ir_build_embed_file(IrBuilder *irb, Scope *scope, AstNode
     return &instruction->base;
 }
-static IrInstruction *ir_build_cmpxchg(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *ptr,
+static IrInstruction *ir_build_cmpxchg(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *type_value,
-    IrInstruction *cmp_value, IrInstruction *new_value, IrInstruction *success_order_value, IrInstruction *failure_order_value,
+    IrInstruction *ptr, IrInstruction *cmp_value, IrInstruction *new_value,
-    AtomicOrder success_order, AtomicOrder failure_order)
+    IrInstruction *success_order_value, IrInstruction *failure_order_value,
+    bool is_weak,
+    TypeTableEntry *type, AtomicOrder success_order, AtomicOrder failure_order)
 {
     IrInstructionCmpxchg *instruction = ir_build_instruction<IrInstructionCmpxchg>(irb, scope, source_node);
+    instruction->type_value = type_value;
     instruction->ptr = ptr;
     instruction->cmp_value = cmp_value;
     instruction->new_value = new_value;
     instruction->success_order_value = success_order_value;
     instruction->failure_order_value = failure_order_value;
+    instruction->is_weak = is_weak;
+    instruction->type = type;
     instruction->success_order = success_order;
     instruction->failure_order = failure_order;
+    if (type_value != nullptr) ir_ref_instruction(type_value, irb->current_basic_block);
     ir_ref_instruction(ptr, irb->current_basic_block);
     ir_ref_instruction(cmp_value, irb->current_basic_block);
     ir_ref_instruction(new_value, irb->current_basic_block);
-    ir_ref_instruction(success_order_value, irb->current_basic_block);
+    if (type_value != nullptr) ir_ref_instruction(success_order_value, irb->current_basic_block);
-    ir_ref_instruction(failure_order_value, irb->current_basic_block);
+    if (type_value != nullptr) ir_ref_instruction(failure_order_value, irb->current_basic_block);
     return &instruction->base;
 }
-static IrInstruction *ir_build_cmpxchg_from(IrBuilder *irb, IrInstruction *old_instruction, IrInstruction *ptr,
-    IrInstruction *cmp_value, IrInstruction *new_value, IrInstruction *success_order_value, IrInstruction *failure_order_value,
-    AtomicOrder success_order, AtomicOrder failure_order)
-{
-    IrInstruction *new_instruction = ir_build_cmpxchg(irb, old_instruction->scope, old_instruction->source_node,
-        ptr, cmp_value, new_value, success_order_value, failure_order_value, success_order, failure_order);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
 static IrInstruction *ir_build_fence(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *order_value, AtomicOrder order) {
     IrInstructionFence *instruction = ir_build_instruction<IrInstructionFence>(irb, scope, source_node);
     instruction->order_value = order_value;
 @@ -3771,7 +3768,8 @@ static IrInstruction *ir_gen_builtin_fn_call(IrBuilder *irb, Scope *scope, AstNo
                 return ir_build_embed_file(irb, scope, node, arg0_value);
             }
-        case BuiltinFnIdCmpExchange:
+        case BuiltinFnIdCmpxchgWeak:
+        case BuiltinFnIdCmpxchgStrong:
             {
                 AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
                 IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
 @@ -3798,9 +3796,14 @@ static IrInstruction *ir_gen_builtin_fn_call(IrBuilder *irb, Scope *scope, AstNo
                 if (arg4_value == irb->codegen->invalid_instruction)
                     return arg4_value;
+                AstNode *arg5_node = node->data.fn_call_expr.params.at(5);
+                IrInstruction *arg5_value = ir_gen_node(irb, arg5_node, scope);
+                if (arg5_value == irb->codegen->invalid_instruction)
+                    return arg5_value;
                 return ir_build_cmpxchg(irb, scope, node, arg0_value, arg1_value,
-                    arg2_value, arg3_value, arg4_value,
+                    arg2_value, arg3_value, arg4_value, arg5_value, (builtin_fn->id == BuiltinFnIdCmpxchgWeak),
-                    AtomicOrderUnordered, AtomicOrderUnordered);
+                    nullptr, AtomicOrderUnordered, AtomicOrderUnordered);
             }
         case BuiltinFnIdFence:
             {
 @@ -15730,10 +15733,20 @@ static TypeTableEntry *ir_analyze_instruction_embed_file(IrAnalyze *ira, IrInstr
 }
 static TypeTableEntry *ir_analyze_instruction_cmpxchg(IrAnalyze *ira, IrInstructionCmpxchg *instruction) {
+    TypeTableEntry *operand_type = ir_resolve_atomic_operand_type(ira, instruction->type_value->other);
+    if (type_is_invalid(operand_type))
+        return ira->codegen->builtin_types.entry_invalid;
     IrInstruction *ptr = instruction->ptr->other;
     if (type_is_invalid(ptr->value.type))
         return ira->codegen->builtin_types.entry_invalid;
+    // TODO let this be volatile
+    TypeTableEntry *ptr_type = get_pointer_to_type(ira->codegen, operand_type, false);
+    IrInstruction *casted_ptr = ir_implicit_cast(ira, ptr, ptr_type);
+    if (type_is_invalid(casted_ptr->value.type))
+        return ira->codegen->builtin_types.entry_invalid;
     IrInstruction *cmp_value = instruction->cmp_value->other;
     if (type_is_invalid(cmp_value->value.type))
         return ira->codegen->builtin_types.entry_invalid;
 @@ -15758,28 +15771,11 @@ static TypeTableEntry *ir_analyze_instruction_cmpxchg(IrAnalyze *ira, IrInstruct
     if (!ir_resolve_atomic_order(ira, failure_order_value, &failure_order))
         return ira->codegen->builtin_types.entry_invalid;
-    if (ptr->value.type->id != TypeTableEntryIdPointer) {
+    IrInstruction *casted_cmp_value = ir_implicit_cast(ira, cmp_value, operand_type);
-        ir_add_error(ira, instruction->ptr,
-            buf_sprintf("expected pointer argument, found '%s'", buf_ptr(&ptr->value.type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
-    }
-    TypeTableEntry *child_type = ptr->value.type->data.pointer.child_type;
-    uint32_t align_bytes = ptr->value.type->data.pointer.alignment;
-    uint64_t size_bytes = type_size(ira->codegen, child_type);
-    if (align_bytes < size_bytes) {
-        ir_add_error(ira, instruction->ptr,
-            buf_sprintf("expected pointer alignment of at least %" ZIG_PRI_u64 ", found %" PRIu32,
-                size_bytes, align_bytes));
-        return ira->codegen->builtin_types.entry_invalid;
-    }
-    IrInstruction *casted_cmp_value = ir_implicit_cast(ira, cmp_value, child_type);
     if (type_is_invalid(casted_cmp_value->value.type))
         return ira->codegen->builtin_types.entry_invalid;
-    IrInstruction *casted_new_value = ir_implicit_cast(ira, new_value, child_type);
+    IrInstruction *casted_new_value = ir_implicit_cast(ira, new_value, operand_type);
     if (type_is_invalid(casted_new_value->value.type))
         return ira->codegen->builtin_types.entry_invalid;
 @@ -15804,9 +15800,17 @@ static TypeTableEntry *ir_analyze_instruction_cmpxchg(IrAnalyze *ira, IrInstruct
         return ira->codegen->builtin_types.entry_invalid;
     }
-    ir_build_cmpxchg_from(&ira->new_irb, &instruction->base, ptr, casted_cmp_value, casted_new_value,
+    if (instr_is_comptime(casted_ptr) && instr_is_comptime(casted_cmp_value) && instr_is_comptime(casted_new_value)) {
-        success_order_value, failure_order_value, success_order, failure_order);
+        zig_panic("TODO compile-time execution of cmpxchg");
-    return ira->codegen->builtin_types.entry_bool;
+    }
+    IrInstruction *result = ir_build_cmpxchg(&ira->new_irb, instruction->base.scope, instruction->base.source_node,
+            nullptr, casted_ptr, casted_cmp_value, casted_new_value, nullptr, nullptr, instruction->is_weak,
+            operand_type, success_order, failure_order);
+    result->value.type = get_maybe_type(ira->codegen, operand_type);
+    ir_link_new_instruction(result, &instruction->base);
+    ir_add_alloca(ira, result, result->value.type);
+    return result->value.type;
 }
 static TypeTableEntry *ir_analyze_instruction_fence(IrAnalyze *ira, IrInstructionFence *instruction) {
 @@ -17981,6 +17985,7 @@ static TypeTableEntry *ir_analyze_instruction_atomic_rmw(IrAnalyze *ira, IrInstr
     if (type_is_invalid(ptr_inst->value.type))
         return ira->codegen->builtin_types.entry_invalid;
+    // TODO let this be volatile
     TypeTableEntry *ptr_type = get_pointer_to_type(ira->codegen, operand_type, false);
     IrInstruction *casted_ptr = ir_implicit_cast(ira, ptr_inst, ptr_type);
     if (type_is_invalid(casted_ptr->value.type))

src/zig_llvm.cpp+5-3

 @@ -765,10 +765,12 @@ static AtomicOrdering mapFromLLVMOrdering(LLVMAtomicOrdering Ordering) {
 LLVMValueRef ZigLLVMBuildCmpXchg(LLVMBuilderRef builder, LLVMValueRef ptr, LLVMValueRef cmp,
         LLVMValueRef new_val, LLVMAtomicOrdering success_ordering,
-        LLVMAtomicOrdering failure_ordering)
+        LLVMAtomicOrdering failure_ordering, bool is_weak)
 {
-    return wrap(unwrap(builder)->CreateAtomicCmpXchg(unwrap(ptr), unwrap(cmp), unwrap(new_val),
+    AtomicCmpXchgInst *inst = unwrap(builder)->CreateAtomicCmpXchg(unwrap(ptr), unwrap(cmp),
-                mapFromLLVMOrdering(success_ordering), mapFromLLVMOrdering(failure_ordering)));
+                unwrap(new_val), mapFromLLVMOrdering(success_ordering), mapFromLLVMOrdering(failure_ordering));
+    inst->setWeak(is_weak);
+    return wrap(inst);
 }
 LLVMValueRef ZigLLVMBuildNSWShl(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS,

src/zig_llvm.h+1-1

...	@@ -66,7 +66,7 @@ ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildCall(LLVMBuilderRef B, LLVMValueRef Fn, LL	...	@@ -66,7 +66,7 @@ ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildCall(LLVMBuilderRef B, LLVMValueRef Fn, LL
66		66
67	ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildCmpXchg(LLVMBuilderRef builder, LLVMValueRef ptr, LLVMValueRef cmp,	67	ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildCmpXchg(LLVMBuilderRef builder, LLVMValueRef ptr, LLVMValueRef cmp,
68	LLVMValueRef new_val, LLVMAtomicOrdering success_ordering,	68	LLVMValueRef new_val, LLVMAtomicOrdering success_ordering,
69	LLVMAtomicOrdering failure_ordering);	69	LLVMAtomicOrdering failure_ordering, bool is_weak);
70		70
71	ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildNSWShl(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS,	71	ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildNSWShl(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS,
72	const char *name);	72	const char *name);

test/cases/atomics.zig+14-2

...	@@ -1,12 +1,24 @@	...	@@ -1,12 +1,24 @@
1	const assert = @import("std").debug.assert;	1	const std = @import("std");
		2	const assert = std.debug.assert;
2	const builtin = @import("builtin");	3	const builtin = @import("builtin");
3	const AtomicRmwOp = builtin.AtomicRmwOp;	4	const AtomicRmwOp = builtin.AtomicRmwOp;
4	const AtomicOrder = builtin.AtomicOrder;	5	const AtomicOrder = builtin.AtomicOrder;
5		6
6	test "cmpxchg" {	7	test "cmpxchg" {
7	var x: i32 = 1234;	8	var x: i32 = 1234;
8	while (!@cmpxchg(&x, 1234, 5678, AtomicOrder.SeqCst, AtomicOrder.SeqCst)) {}	9	if (@cmpxchgWeak(i32, &x, 99, 5678, AtomicOrder.SeqCst, AtomicOrder.SeqCst)) \|x1\| {
		10	assert(x1 == 1234);
		11	} else {
		12	@panic("cmpxchg should have failed");
		13	}
		14
		15	while (@cmpxchgWeak(i32, &x, 1234, 5678, AtomicOrder.SeqCst, AtomicOrder.SeqCst)) \|x1\| {
		16	assert(x1 == 1234);
		17	}
9	assert(x == 5678);	18	assert(x == 5678);
		19
		20	assert(@cmpxchgStrong(i32, &x, 5678, 42, AtomicOrder.SeqCst, AtomicOrder.SeqCst) == null);
		21	assert(x == 42);
10	}	22	}
11		23
12	test "fence" {	24	test "fence" {

test/compile_errors.zig+8-8

author	Andrew Kelley <andrew@ziglang.org> 2018-04-18 12:16:42-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2018-04-18 12:16:42-04:00
log	f1f998e07124f141312289ff82e0ad8d99af1cf7
tree	3c01eb14a0bd8e4cdd83f376097264f45efae2ff
parent	96ebd8b23b39e2d4019a8019a6774d7c3d20149d

...	@@ -1394,17 +1394,17 @@ pub fn addCases(cases: &tests.CompileErrorContext) void {	...	@@ -1394,17 +1394,17 @@ pub fn addCases(cases: &tests.CompileErrorContext) void {
1394	\\const AtomicOrder = @import("builtin").AtomicOrder;	1394	\\const AtomicOrder = @import("builtin").AtomicOrder;
1395	\\export fn f() void {	1395	\\export fn f() void {
1396	\\ var x: i32 = 1234;	1396	\\ var x: i32 = 1234;
1397	\\ while (!@cmpxchg(&x, 1234, 5678, AtomicOrder.Monotonic, AtomicOrder.SeqCst)) {}	1397	\\ while (!@cmpxchgWeak(i32, &x, 1234, 5678, AtomicOrder.Monotonic, AtomicOrder.SeqCst)) {}
1398	\\}	1398	\\}
1399	, ".tmp_source.zig:4:72: error: failure atomic ordering must be no stricter than success");	1399	, ".tmp_source.zig:4:81: error: failure atomic ordering must be no stricter than success");
1400		1400
1401	cases.add("atomic orderings of cmpxchg - success Monotonic or stricter",	1401	cases.add("atomic orderings of cmpxchg - success Monotonic or stricter",
1402	\\const AtomicOrder = @import("builtin").AtomicOrder;	1402	\\const AtomicOrder = @import("builtin").AtomicOrder;
1403	\\export fn f() void {	1403	\\export fn f() void {
1404	\\ var x: i32 = 1234;	1404	\\ var x: i32 = 1234;
1405	\\ while (!@cmpxchg(&x, 1234, 5678, AtomicOrder.Unordered, AtomicOrder.Unordered)) {}	1405	\\ while (!@cmpxchgWeak(i32, &x, 1234, 5678, AtomicOrder.Unordered, AtomicOrder.Unordered)) {}
1406	\\}	1406	\\}
1407	, ".tmp_source.zig:4:49: error: success atomic ordering must be Monotonic or stricter");	1407	, ".tmp_source.zig:4:58: error: success atomic ordering must be Monotonic or stricter");
1408		1408
1409	cases.add("negation overflow in function evaluation",	1409	cases.add("negation overflow in function evaluation",
1410	\\const y = neg(-128);	1410	\\const y = neg(-128);
...	@@ -2460,11 +2460,11 @@ pub fn addCases(cases: &tests.CompileErrorContext) void {	...	@@ -2460,11 +2460,11 @@ pub fn addCases(cases: &tests.CompileErrorContext) void {
2460	\\const AtomicOrder = @import("builtin").AtomicOrder;	2460	\\const AtomicOrder = @import("builtin").AtomicOrder;
2461	\\export fn entry() bool {	2461	\\export fn entry() bool {
2462	\\ var x: i32 align(1) = 1234;	2462	\\ var x: i32 align(1) = 1234;
2463	\\ while (!@cmpxchg(&x, 1234, 5678, AtomicOrder.SeqCst, AtomicOrder.SeqCst)) {}	2463	\\ while (!@cmpxchgWeak(i32, &x, 1234, 5678, AtomicOrder.SeqCst, AtomicOrder.SeqCst)) {}
2464	\\ return x == 5678;	2464	\\ return x == 5678;
2465	\\}	2465	\\}
2466	,	2466	,
2467	".tmp_source.zig:4:23: error: expected pointer alignment of at least 4, found 1");	2467	".tmp_source.zig:4:32: error: expected type '&i32', found '&align(1) i32'");
2468		2468
2469	cases.add("wrong size to an array literal",	2469	cases.add("wrong size to an array literal",
2470	\\comptime {	2470	\\comptime {
...	@@ -2534,10 +2534,10 @@ pub fn addCases(cases: &tests.CompileErrorContext) void {	...	@@ -2534,10 +2534,10 @@ pub fn addCases(cases: &tests.CompileErrorContext) void {
2534	cases.add("wrong types given to atomic order args in cmpxchg",	2534	cases.add("wrong types given to atomic order args in cmpxchg",
2535	\\export fn entry() void {	2535	\\export fn entry() void {
2536	\\ var x: i32 = 1234;	2536	\\ var x: i32 = 1234;
2537	\\ while (!@cmpxchg(&x, 1234, 5678, u32(1234), u32(1234))) {}	2537	\\ while (!@cmpxchgWeak(i32, &x, 1234, 5678, u32(1234), u32(1234))) {}
2538	\\}	2538	\\}
2539	,	2539	,
2540	".tmp_source.zig:3:41: error: expected type 'AtomicOrder', found 'u32'");	2540	".tmp_source.zig:3:50: error: expected type 'AtomicOrder', found 'u32'");
2541		2541
2542	cases.add("wrong types given to @export",	2542	cases.add("wrong types given to @export",
2543	\\extern fn entry() void { }	2543	\\extern fn entry() void { }

improve cmpxchg