authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2020-04-05 11:13:31-04:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2020-04-05 11:13:31-04:00
log607b2661a0e39fd3d03bba2fa27f02ffc27518bc
tree31a3feea1ae419cee283b696fc37ddc6bcd49f70
parent4daec63aead9da8ee9934975623db990e05303ed
parente9e43ed0d39f623d424f87fbd035f949cf5a3227
signaturebadge-question-mark Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #4942 from daurnimator/tidy-atomics

Tidy up compiler_rt/atomics

1 files changed, 66 insertions(+), 65 deletions(-)

lib/std/special/compiler_rt/atomics.zig+66-65
...@@ -106,7 +106,7 @@ const largest_atomic_size = switch (builtin.arch) {...@@ -106,7 +106,7 @@ const largest_atomic_size = switch (builtin.arch) {
106 else => @sizeOf(usize),106 else => @sizeOf(usize),
107};107};
108108
109fn makeAtomicLoadFn(comptime T: type) type {109fn atomicLoadFn(comptime T: type) fn (*T, i32) callconv(.C) T {
110 return struct {110 return struct {
111 fn atomic_load_N(src: *T, model: i32) callconv(.C) T {111 fn atomic_load_N(src: *T, model: i32) callconv(.C) T {
112 if (@sizeOf(T) > largest_atomic_size) {112 if (@sizeOf(T) > largest_atomic_size) {
...@@ -117,17 +117,17 @@ fn makeAtomicLoadFn(comptime T: type) type {...@@ -117,17 +117,17 @@ fn makeAtomicLoadFn(comptime T: type) type {
117 return @atomicLoad(T, src, .SeqCst);117 return @atomicLoad(T, src, .SeqCst);
118 }118 }
119 }119 }
120 };120 }.atomic_load_N;
121}121}
122122
123comptime {123comptime {
124 @export(makeAtomicLoadFn(u8).atomic_load_N, .{ .name = "__atomic_load_1", .linkage = linkage });124 @export(atomicLoadFn(u8), .{ .name = "__atomic_load_1", .linkage = linkage });
125 @export(makeAtomicLoadFn(u16).atomic_load_N, .{ .name = "__atomic_load_2", .linkage = linkage });125 @export(atomicLoadFn(u16), .{ .name = "__atomic_load_2", .linkage = linkage });
126 @export(makeAtomicLoadFn(u32).atomic_load_N, .{ .name = "__atomic_load_4", .linkage = linkage });126 @export(atomicLoadFn(u32), .{ .name = "__atomic_load_4", .linkage = linkage });
127 @export(makeAtomicLoadFn(u64).atomic_load_N, .{ .name = "__atomic_load_8", .linkage = linkage });127 @export(atomicLoadFn(u64), .{ .name = "__atomic_load_8", .linkage = linkage });
128}128}
129129
130fn makeAtomicStoreFn(comptime T: type) type {130fn atomicStoreFn(comptime T: type) fn (*T, T, i32) callconv(.C) void {
131 return struct {131 return struct {
132 fn atomic_store_N(dst: *T, value: T, model: i32) callconv(.C) void {132 fn atomic_store_N(dst: *T, value: T, model: i32) callconv(.C) void {
133 if (@sizeOf(T) > largest_atomic_size) {133 if (@sizeOf(T) > largest_atomic_size) {
...@@ -138,50 +138,51 @@ fn makeAtomicStoreFn(comptime T: type) type {...@@ -138,50 +138,51 @@ fn makeAtomicStoreFn(comptime T: type) type {
138 @atomicStore(T, dst, value, .SeqCst);138 @atomicStore(T, dst, value, .SeqCst);
139 }139 }
140 }140 }
141 };141 }.atomic_store_N;
142}142}
143143
144comptime {144comptime {
145 @export(makeAtomicStoreFn(u8).atomic_store_N, .{ .name = "__atomic_store_1", .linkage = linkage });145 @export(atomicStoreFn(u8), .{ .name = "__atomic_store_1", .linkage = linkage });
146 @export(makeAtomicStoreFn(u16).atomic_store_N, .{ .name = "__atomic_store_2", .linkage = linkage });146 @export(atomicStoreFn(u16), .{ .name = "__atomic_store_2", .linkage = linkage });
147 @export(makeAtomicStoreFn(u32).atomic_store_N, .{ .name = "__atomic_store_4", .linkage = linkage });147 @export(atomicStoreFn(u32), .{ .name = "__atomic_store_4", .linkage = linkage });
148 @export(makeAtomicStoreFn(u64).atomic_store_N, .{ .name = "__atomic_store_8", .linkage = linkage });148 @export(atomicStoreFn(u64), .{ .name = "__atomic_store_8", .linkage = linkage });
149}149}
150150
151fn makeAtomicExchangeFn(comptime T: type) type {151fn atomicExchangeFn(comptime T: type) fn (*T, T, i32) callconv(.C) T {
152 return struct {152 return struct {
153 fn atomic_exchange_N(ptr: *T, val: T, model: i32) callconv(.C) T {153 fn atomic_exchange_N(ptr: *T, val: T, model: i32) callconv(.C) T {
154 if (@sizeOf(T) > largest_atomic_size) {154 if (@sizeOf(T) > largest_atomic_size) {
155 var sl = spinlocks.get(@ptrToInt(ptr));155 var sl = spinlocks.get(@ptrToInt(ptr));
156 defer sl.release();156 defer sl.release();
157 var value = ptr.*;157 const value = ptr.*;
158 ptr.* = val;158 ptr.* = val;
159 return value;159 return value;
160 } else {160 } else {
161 return @atomicRmw(T, ptr, .Xchg, val, .SeqCst);161 return @atomicRmw(T, ptr, .Xchg, val, .SeqCst);
162 }162 }
163 }163 }
164 };164 }.atomic_exchange_N;
165}165}
166166
167comptime {167comptime {
168 @export(makeAtomicExchangeFn(u8).atomic_exchange_N, .{ .name = "__atomic_exchange_1", .linkage = linkage });168 @export(atomicExchangeFn(u8), .{ .name = "__atomic_exchange_1", .linkage = linkage });
169 @export(makeAtomicExchangeFn(u16).atomic_exchange_N, .{ .name = "__atomic_exchange_2", .linkage = linkage });169 @export(atomicExchangeFn(u16), .{ .name = "__atomic_exchange_2", .linkage = linkage });
170 @export(makeAtomicExchangeFn(u32).atomic_exchange_N, .{ .name = "__atomic_exchange_4", .linkage = linkage });170 @export(atomicExchangeFn(u32), .{ .name = "__atomic_exchange_4", .linkage = linkage });
171 @export(makeAtomicExchangeFn(u64).atomic_exchange_N, .{ .name = "__atomic_exchange_8", .linkage = linkage });171 @export(atomicExchangeFn(u64), .{ .name = "__atomic_exchange_8", .linkage = linkage });
172}172}
173173
174fn makeAtomicCompareExchangeFn(comptime T: type) type {174fn atomicCompareExchangeFn(comptime T: type) fn (*T, *T, T, i32, i32) callconv(.C) i32 {
175 return struct {175 return struct {
176 fn atomic_compare_exchange_N(ptr: *T, expected: *T, desired: T, success: i32, failure: i32) callconv(.C) i32 {176 fn atomic_compare_exchange_N(ptr: *T, expected: *T, desired: T, success: i32, failure: i32) callconv(.C) i32 {
177 if (@sizeOf(T) > largest_atomic_size) {177 if (@sizeOf(T) > largest_atomic_size) {
178 var sl = spinlocks.get(@ptrToInt(ptr));178 var sl = spinlocks.get(@ptrToInt(ptr));
179 defer sl.release();179 defer sl.release();
180 if (ptr.* == expected.*) {180 const value = ptr.*;
181 if (value == expected.*) {
181 ptr.* = desired;182 ptr.* = desired;
182 return 1;183 return 1;
183 }184 }
184 expected.* = ptr.*;185 expected.* = value;
185 return 0;186 return 0;
186 } else {187 } else {
187 if (@cmpxchgStrong(T, ptr, expected.*, desired, .SeqCst, .SeqCst)) |old_value| {188 if (@cmpxchgStrong(T, ptr, expected.*, desired, .SeqCst, .SeqCst)) |old_value| {
...@@ -191,31 +192,31 @@ fn makeAtomicCompareExchangeFn(comptime T: type) type {...@@ -191,31 +192,31 @@ fn makeAtomicCompareExchangeFn(comptime T: type) type {
191 return 1;192 return 1;
192 }193 }
193 }194 }
194 };195 }.atomic_compare_exchange_N;
195}196}
196197
197comptime {198comptime {
198 @export(makeAtomicCompareExchangeFn(u8).atomic_compare_exchange_N, .{ .name = "__atomic_compare_exchange_1", .linkage = linkage });199 @export(atomicCompareExchangeFn(u8), .{ .name = "__atomic_compare_exchange_1", .linkage = linkage });
199 @export(makeAtomicCompareExchangeFn(u16).atomic_compare_exchange_N, .{ .name = "__atomic_compare_exchange_2", .linkage = linkage });200 @export(atomicCompareExchangeFn(u16), .{ .name = "__atomic_compare_exchange_2", .linkage = linkage });
200 @export(makeAtomicCompareExchangeFn(u32).atomic_compare_exchange_N, .{ .name = "__atomic_compare_exchange_4", .linkage = linkage });201 @export(atomicCompareExchangeFn(u32), .{ .name = "__atomic_compare_exchange_4", .linkage = linkage });
201 @export(makeAtomicCompareExchangeFn(u64).atomic_compare_exchange_N, .{ .name = "__atomic_compare_exchange_8", .linkage = linkage });202 @export(atomicCompareExchangeFn(u64), .{ .name = "__atomic_compare_exchange_8", .linkage = linkage });
202}203}
203204
204fn makeFetchFn(comptime T: type, comptime op: builtin.AtomicRmwOp) type {205fn fetchFn(comptime T: type, comptime op: builtin.AtomicRmwOp) fn (*T, T, i32) callconv(.C) T {
205 return struct {206 return struct {
206 pub fn fetch_op_N(ptr: *T, val: T, model: i32) callconv(.C) T {207 pub fn fetch_op_N(ptr: *T, val: T, model: i32) callconv(.C) T {
207 if (@sizeOf(T) > largest_atomic_size) {208 if (@sizeOf(T) > largest_atomic_size) {
208 var sl = spinlocks.get(@ptrToInt(ptr));209 var sl = spinlocks.get(@ptrToInt(ptr));
209 defer sl.release();210 defer sl.release();
210211
211 var value = ptr.*;212 const value = ptr.*;
212 ptr.* = switch (op) {213 ptr.* = switch (op) {
213 .Add => ptr.* +% val,214 .Add => value +% val,
214 .Sub => ptr.* -% val,215 .Sub => value -% val,
215 .And => ptr.* & val,216 .And => value & val,
216 .Nand => ~(ptr.* & val),217 .Nand => ~(value & val),
217 .Or => ptr.* | val,218 .Or => value | val,
218 .Xor => ptr.* ^ val,219 .Xor => value ^ val,
219 else => @compileError("unsupported atomic op"),220 else => @compileError("unsupported atomic op"),
220 };221 };
221222
...@@ -224,37 +225,37 @@ fn makeFetchFn(comptime T: type, comptime op: builtin.AtomicRmwOp) type {...@@ -224,37 +225,37 @@ fn makeFetchFn(comptime T: type, comptime op: builtin.AtomicRmwOp) type {
224225
225 return @atomicRmw(T, ptr, op, val, .SeqCst);226 return @atomicRmw(T, ptr, op, val, .SeqCst);
226 }227 }
227 };228 }.fetch_op_N;
228}229}
229230
230comptime {231comptime {
231 @export(makeFetchFn(u8, .Add).fetch_op_N, .{ .name = "__atomic_fetch_add_1", .linkage = linkage });232 @export(fetchFn(u8, .Add), .{ .name = "__atomic_fetch_add_1", .linkage = linkage });
232 @export(makeFetchFn(u16, .Add).fetch_op_N, .{ .name = "__atomic_fetch_add_2", .linkage = linkage });233 @export(fetchFn(u16, .Add), .{ .name = "__atomic_fetch_add_2", .linkage = linkage });
233 @export(makeFetchFn(u32, .Add).fetch_op_N, .{ .name = "__atomic_fetch_add_4", .linkage = linkage });234 @export(fetchFn(u32, .Add), .{ .name = "__atomic_fetch_add_4", .linkage = linkage });
234 @export(makeFetchFn(u64, .Add).fetch_op_N, .{ .name = "__atomic_fetch_add_8", .linkage = linkage });235 @export(fetchFn(u64, .Add), .{ .name = "__atomic_fetch_add_8", .linkage = linkage });
235236
236 @export(makeFetchFn(u8, .Sub).fetch_op_N, .{ .name = "__atomic_fetch_sub_1", .linkage = linkage });237 @export(fetchFn(u8, .Sub), .{ .name = "__atomic_fetch_sub_1", .linkage = linkage });
237 @export(makeFetchFn(u16, .Sub).fetch_op_N, .{ .name = "__atomic_fetch_sub_2", .linkage = linkage });238 @export(fetchFn(u16, .Sub), .{ .name = "__atomic_fetch_sub_2", .linkage = linkage });
238 @export(makeFetchFn(u32, .Sub).fetch_op_N, .{ .name = "__atomic_fetch_sub_4", .linkage = linkage });239 @export(fetchFn(u32, .Sub), .{ .name = "__atomic_fetch_sub_4", .linkage = linkage });
239 @export(makeFetchFn(u64, .Sub).fetch_op_N, .{ .name = "__atomic_fetch_sub_8", .linkage = linkage });240 @export(fetchFn(u64, .Sub), .{ .name = "__atomic_fetch_sub_8", .linkage = linkage });
240241
241 @export(makeFetchFn(u8, .And).fetch_op_N, .{ .name = "__atomic_fetch_and_1", .linkage = linkage });242 @export(fetchFn(u8, .And), .{ .name = "__atomic_fetch_and_1", .linkage = linkage });
242 @export(makeFetchFn(u16, .And).fetch_op_N, .{ .name = "__atomic_fetch_and_2", .linkage = linkage });243 @export(fetchFn(u16, .And), .{ .name = "__atomic_fetch_and_2", .linkage = linkage });
243 @export(makeFetchFn(u32, .And).fetch_op_N, .{ .name = "__atomic_fetch_and_4", .linkage = linkage });244 @export(fetchFn(u32, .And), .{ .name = "__atomic_fetch_and_4", .linkage = linkage });
244 @export(makeFetchFn(u64, .And).fetch_op_N, .{ .name = "__atomic_fetch_and_8", .linkage = linkage });245 @export(fetchFn(u64, .And), .{ .name = "__atomic_fetch_and_8", .linkage = linkage });
245246
246 @export(makeFetchFn(u8, .Or).fetch_op_N, .{ .name = "__atomic_fetch_or_1", .linkage = linkage });247 @export(fetchFn(u8, .Or), .{ .name = "__atomic_fetch_or_1", .linkage = linkage });
247 @export(makeFetchFn(u16, .Or).fetch_op_N, .{ .name = "__atomic_fetch_or_2", .linkage = linkage });248 @export(fetchFn(u16, .Or), .{ .name = "__atomic_fetch_or_2", .linkage = linkage });
248 @export(makeFetchFn(u32, .Or).fetch_op_N, .{ .name = "__atomic_fetch_or_4", .linkage = linkage });249 @export(fetchFn(u32, .Or), .{ .name = "__atomic_fetch_or_4", .linkage = linkage });
249 @export(makeFetchFn(u64, .Or).fetch_op_N, .{ .name = "__atomic_fetch_or_8", .linkage = linkage });250 @export(fetchFn(u64, .Or), .{ .name = "__atomic_fetch_or_8", .linkage = linkage });
250251
251 @export(makeFetchFn(u8, .Xor).fetch_op_N, .{ .name = "__atomic_fetch_xor_1", .linkage = linkage });252 @export(fetchFn(u8, .Xor), .{ .name = "__atomic_fetch_xor_1", .linkage = linkage });
252 @export(makeFetchFn(u16, .Xor).fetch_op_N, .{ .name = "__atomic_fetch_xor_2", .linkage = linkage });253 @export(fetchFn(u16, .Xor), .{ .name = "__atomic_fetch_xor_2", .linkage = linkage });
253 @export(makeFetchFn(u32, .Xor).fetch_op_N, .{ .name = "__atomic_fetch_xor_4", .linkage = linkage });254 @export(fetchFn(u32, .Xor), .{ .name = "__atomic_fetch_xor_4", .linkage = linkage });
254 @export(makeFetchFn(u64, .Xor).fetch_op_N, .{ .name = "__atomic_fetch_xor_8", .linkage = linkage });255 @export(fetchFn(u64, .Xor), .{ .name = "__atomic_fetch_xor_8", .linkage = linkage });
255256
256 @export(makeFetchFn(u8, .Nand).fetch_op_N, .{ .name = "__atomic_fetch_nand_1", .linkage = linkage });257 @export(fetchFn(u8, .Nand), .{ .name = "__atomic_fetch_nand_1", .linkage = linkage });
257 @export(makeFetchFn(u16, .Nand).fetch_op_N, .{ .name = "__atomic_fetch_nand_2", .linkage = linkage });258 @export(fetchFn(u16, .Nand), .{ .name = "__atomic_fetch_nand_2", .linkage = linkage });
258 @export(makeFetchFn(u32, .Nand).fetch_op_N, .{ .name = "__atomic_fetch_nand_4", .linkage = linkage });259 @export(fetchFn(u32, .Nand), .{ .name = "__atomic_fetch_nand_4", .linkage = linkage });
259 @export(makeFetchFn(u64, .Nand).fetch_op_N, .{ .name = "__atomic_fetch_nand_8", .linkage = linkage });260 @export(fetchFn(u64, .Nand), .{ .name = "__atomic_fetch_nand_8", .linkage = linkage });
260}261}