authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2023-04-23 15:26:57-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2023-04-25 11:23:41-07:00
log7c56145a7651124dafdc87176ba85c814cd97d2d
tree8941c49bbcb2ec4b126d9ed75d98f0706b2768d5
parent482a0f648c90e8a61dac3a95313e0519bc5f4b5f

add behavior test for `@memset` on slices

and avoid new language feature in std.ArrayList for now, until x86_64 self-hosted backend can implement it.

2 files changed, 64 insertions(+), 2 deletions(-)

lib/std/array_list.zig+14-2
......@@ -121,7 +121,13 @@ pub fn ArrayListAligned(comptime T: type, comptime alignment: ?u29) type {
121121
122122 const new_memory = try allocator.alignedAlloc(T, alignment, self.items.len);
123123 mem.copy(T, new_memory, self.items);
124 @memset(self.items, undefined);
124
125 // TODO: write like this instead:
126 //@memset(self.items, undefined);
127 // first we need to implement memset with element ABI size > 1 in
128 // the x86_64 selfhosted backend.
129 @memset(@ptrCast([*]u8, self.items.ptr)[0..self.items.len * @sizeOf(T)], undefined);
130
125131 self.clearAndFree();
126132 return new_memory;
127133 }
......@@ -597,7 +603,13 @@ pub fn ArrayListAlignedUnmanaged(comptime T: type, comptime alignment: ?u29) typ
597603
598604 const new_memory = try allocator.alignedAlloc(T, alignment, self.items.len);
599605 mem.copy(T, new_memory, self.items);
600 @memset(self.items, undefined);
606
607 // TODO: write like this instead:
608 //@memset(self.items, undefined);
609 // first we need to implement memset with element ABI size > 1 in
610 // the x86_64 selfhosted backend.
611 @memset(@ptrCast([*]u8, self.items.ptr)[0..self.items.len * @sizeOf(T)], undefined);
612
601613 self.clearAndFree(allocator);
602614 return new_memory;
603615 }
test/behavior/basic.zig+50
......@@ -357,6 +357,14 @@ test "@memset on array pointers" {
357357 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
358358 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
359359 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
360 if (builtin.zig_backend == .stage2_wasm) {
361 // TODO: implement memset when element ABI size > 1
362 return error.SkipZigTest;
363 }
364 if (builtin.zig_backend == .stage2_x86_64) {
365 // TODO: implement memset when element ABI size > 1
366 return error.SkipZigTest;
367 }
360368
361369 try testMemsetArray();
362370 try comptime testMemsetArray();
......@@ -381,6 +389,48 @@ fn testMemsetArray() !void {
381389 }
382390}
383391
392test "@memset on slices" {
393 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
394 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
395 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
396 if (builtin.zig_backend == .stage2_wasm) {
397 // TODO: implement memset when element ABI size > 1
398 // TODO: implement memset on slices
399 return error.SkipZigTest;
400 }
401 if (builtin.zig_backend == .stage2_x86_64) {
402 // TODO: implement memset when element ABI size > 1
403 // TODO: implement memset on slices
404 return error.SkipZigTest;
405 }
406
407 try testMemsetSlice();
408 try comptime testMemsetSlice();
409}
410
411fn testMemsetSlice() !void {
412 {
413 // memset slice to non-undefined, ABI size == 1
414 var array: [20]u8 = undefined;
415 var len = array.len;
416 var slice = array[0..len];
417 @memset(slice, 'A');
418 try expect(slice[0] == 'A');
419 try expect(slice[11] == 'A');
420 try expect(slice[19] == 'A');
421 }
422 {
423 // memset slice to non-undefined, ABI size > 1
424 var array: [20]u32 = undefined;
425 var len = array.len;
426 var slice = array[0..len];
427 @memset(slice, 1234);
428 try expect(slice[0] == 1234);
429 try expect(slice[11] == 1234);
430 try expect(slice[19] == 1234);
431 }
432}
433
384434test "memcpy and memset intrinsics" {
385435 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
386436 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;