Commit 061ff11b2b8aca33fec0d5d381855d5bd3aa6ff9 | zig

lib/std/array_hash_map.zig-3

...	@@ -930,9 +930,6 @@ test "basic hash map usage" {	...	@@ -930,9 +930,6 @@ test "basic hash map usage" {
930	}	930	}
931		931
932	test "iterator hash map" {	932	test "iterator hash map" {
933	// https://github.com/ziglang/zig/issues/5127
934	if (std.Target.current.cpu.arch == .mips) return error.SkipZigTest;
935
936	var reset_map = AutoArrayHashMap(i32, i32).init(std.testing.allocator);	933	var reset_map = AutoArrayHashMap(i32, i32).init(std.testing.allocator);
937	defer reset_map.deinit();	934	defer reset_map.deinit();
938		935

lib/std/io/test.zig-3

...	@@ -140,9 +140,6 @@ test "File seek ops" {	...	@@ -140,9 +140,6 @@ test "File seek ops" {
140	}	140	}
141		141
142	test "setEndPos" {	142	test "setEndPos" {
143	// https://github.com/ziglang/zig/issues/5127
144	if (std.Target.current.cpu.arch == .mips) return error.SkipZigTest;
145
146	var tmp = tmpDir(.{});	143	var tmp = tmpDir(.{});
147	defer tmp.cleanup();	144	defer tmp.cleanup();
148		145

lib/std/json.zig+11-13

 @@ -2125,7 +2125,11 @@ fn unescapeString(output: []u8, input: []const u8) !void {
                 const secondCodeUnit = std.fmt.parseInt(u16, input[inIndex + 8 .. inIndex + 12], 16) catch unreachable;
-                if (std.unicode.utf16leToUtf8(output[outIndex..], &[2]u16{ firstCodeUnit, secondCodeUnit })) |byteCount| {
+                const utf16le_seq = [2]u16{
+                    mem.littleToNative(u16, firstCodeUnit),
+                    mem.littleToNative(u16, secondCodeUnit),
+                };
+                if (std.unicode.utf16leToUtf8(output[outIndex..], &utf16le_seq)) |byteCount| {
                     outIndex += byteCount;
                     inIndex += 12;
                 } else |_| {
 @@ -2265,9 +2269,6 @@ test "integer after float has proper type" {
 }
 test "escaped characters" {
-    // https://github.com/ziglang/zig/issues/5127
-    if (std.Target.current.cpu.arch == .mips) return error.SkipZigTest;
     var arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator);
     defer arena_allocator.deinit();
     const input =
 @@ -2300,9 +2301,6 @@ test "escaped characters" {
 }
 test "string copy option" {
-    // https://github.com/ziglang/zig/issues/5127
-    if (std.Target.current.cpu.arch == .mips) return error.SkipZigTest;
     const input =
         \\{
         \\  "noescape": "aą😂",
 @@ -2721,9 +2719,9 @@ test "stringify struct with indentation" {
         \\}
     ,
         struct {
-                foo: u32,
+            foo: u32,
-                bar: [3]u32,
+            bar: [3]u32,
-            }{
+        }{
             .foo = 42,
             .bar = .{ 1, 2, 3 },
         },
 @@ -2734,9 +2732,9 @@ test "stringify struct with indentation" {
     try teststringify(
         "{\n\t\"foo\":42,\n\t\"bar\":[\n\t\t1,\n\t\t2,\n\t\t3\n\t]\n}",
         struct {
-                foo: u32,
+            foo: u32,
-                bar: [3]u32,
+            bar: [3]u32,
-            }{
+        }{
             .foo = 42,
             .bar = .{ 1, 2, 3 },
         },

lib/std/json/test.zig-69

 @@ -337,18 +337,12 @@ test "y_string_1_2_3_bytes_UTF-8_sequences" {
 }
 test "y_string_accepted_surrogate_pair" {
-    // https://github.com/ziglang/zig/issues/5127
-    if (std.Target.current.cpu.arch == .mips) return error.SkipZigTest;
     ok(
         \\["\uD801\udc37"]
     );
 }
 test "y_string_accepted_surrogate_pairs" {
-    // https://github.com/ziglang/zig/issues/5127
-    if (std.Target.current.cpu.arch == .mips) return error.SkipZigTest;
     ok(
         \\["\ud83d\ude39\ud83d\udc8d"]
     );
 @@ -415,9 +409,6 @@ test "y_string_in_array_with_leading_space" {
 }
 test "y_string_last_surrogates_1_and_2" {
-    // https://github.com/ziglang/zig/issues/5127
-    if (std.Target.current.cpu.arch == .mips) return error.SkipZigTest;
     ok(
         \\["\uDBFF\uDFFF"]
     );
 @@ -478,9 +469,6 @@ test "y_string_space" {
 }
 test "y_string_surrogates_U+1D11E_MUSICAL_SYMBOL_G_CLEF" {
-    // https://github.com/ziglang/zig/issues/5127
-    if (std.Target.current.cpu.arch == .mips) return error.SkipZigTest;
     ok(
         \\["\uD834\uDd1e"]
     );
 @@ -523,90 +511,60 @@ test "y_string_unescaped_char_delete" {
 }
 test "y_string_unicode_2" {
-    // https://github.com/ziglang/zig/issues/5127
-    if (std.Target.current.cpu.arch == .mips) return error.SkipZigTest;
     ok(
         \\["⍂㈴⍂"]
     );
 }
 test "y_string_unicodeEscapedBackslash" {
-    // https://github.com/ziglang/zig/issues/5127
-    if (std.Target.current.cpu.arch == .mips) return error.SkipZigTest;
     ok(
         \\["\u005C"]
     );
 }
 test "y_string_unicode_escaped_double_quote" {
-    // https://github.com/ziglang/zig/issues/5127
-    if (std.Target.current.cpu.arch == .mips) return error.SkipZigTest;
     ok(
         \\["\u0022"]
     );
 }
 test "y_string_unicode" {
-    // https://github.com/ziglang/zig/issues/5127
-    if (std.Target.current.cpu.arch == .mips) return error.SkipZigTest;
     ok(
         \\["\uA66D"]
     );
 }
 test "y_string_unicode_U+10FFFE_nonchar" {
-    // https://github.com/ziglang/zig/issues/5127
-    if (std.Target.current.cpu.arch == .mips) return error.SkipZigTest;
     ok(
         \\["\uDBFF\uDFFE"]
     );
 }
 test "y_string_unicode_U+1FFFE_nonchar" {
-    // https://github.com/ziglang/zig/issues/5127
-    if (std.Target.current.cpu.arch == .mips) return error.SkipZigTest;
     ok(
         \\["\uD83F\uDFFE"]
     );
 }
 test "y_string_unicode_U+200B_ZERO_WIDTH_SPACE" {
-    // https://github.com/ziglang/zig/issues/5127
-    if (std.Target.current.cpu.arch == .mips) return error.SkipZigTest;
     ok(
         \\["\u200B"]
     );
 }
 test "y_string_unicode_U+2064_invisible_plus" {
-    // https://github.com/ziglang/zig/issues/5127
-    if (std.Target.current.cpu.arch == .mips) return error.SkipZigTest;
     ok(
         \\["\u2064"]
     );
 }
 test "y_string_unicode_U+FDD0_nonchar" {
-    // https://github.com/ziglang/zig/issues/5127
-    if (std.Target.current.cpu.arch == .mips) return error.SkipZigTest;
     ok(
         \\["\uFDD0"]
     );
 }
 test "y_string_unicode_U+FFFE_nonchar" {
-    // https://github.com/ziglang/zig/issues/5127
-    if (std.Target.current.cpu.arch == .mips) return error.SkipZigTest;
     ok(
         \\["\uFFFE"]
     );
 @@ -1858,63 +1816,42 @@ test "i_object_key_lone_2nd_surrogate" {
 }
 test "i_string_1st_surrogate_but_2nd_missing" {
-    // https://github.com/ziglang/zig/issues/5127
-    if (std.Target.current.cpu.arch == .mips) return error.SkipZigTest;
     anyStreamingErrNonStreaming(
         \\["\uDADA"]
     );
 }
 test "i_string_1st_valid_surrogate_2nd_invalid" {
-    // https://github.com/ziglang/zig/issues/5127
-    if (std.Target.current.cpu.arch == .mips) return error.SkipZigTest;
     anyStreamingErrNonStreaming(
         \\["\uD888\u1234"]
     );
 }
 test "i_string_incomplete_surrogate_and_escape_valid" {
-    // https://github.com/ziglang/zig/issues/5127
-    if (std.Target.current.cpu.arch == .mips) return error.SkipZigTest;
     anyStreamingErrNonStreaming(
         \\["\uD800\n"]
     );
 }
 test "i_string_incomplete_surrogate_pair" {
-    // https://github.com/ziglang/zig/issues/5127
-    if (std.Target.current.cpu.arch == .mips) return error.SkipZigTest;
     anyStreamingErrNonStreaming(
         \\["\uDd1ea"]
     );
 }
 test "i_string_incomplete_surrogates_escape_valid" {
-    // https://github.com/ziglang/zig/issues/5127
-    if (std.Target.current.cpu.arch == .mips) return error.SkipZigTest;
     anyStreamingErrNonStreaming(
         \\["\uD800\uD800\n"]
     );
 }
 test "i_string_invalid_lonely_surrogate" {
-    // https://github.com/ziglang/zig/issues/5127
-    if (std.Target.current.cpu.arch == .mips) return error.SkipZigTest;
     anyStreamingErrNonStreaming(
         \\["\ud800"]
     );
 }
 test "i_string_invalid_surrogate" {
-    // https://github.com/ziglang/zig/issues/5127
-    if (std.Target.current.cpu.arch == .mips) return error.SkipZigTest;
     anyStreamingErrNonStreaming(
         \\["\ud800abc"]
     );
 @@ -1927,9 +1864,6 @@ test "i_string_invalid_utf-8" {
 }
 test "i_string_inverted_surrogates_U+1D11E" {
-    // https://github.com/ziglang/zig/issues/5127
-    if (std.Target.current.cpu.arch == .mips) return error.SkipZigTest;
     anyStreamingErrNonStreaming(
         \\["\uDd1e\uD834"]
     );
 @@ -1942,9 +1876,6 @@ test "i_string_iso_latin_1" {
 }
 test "i_string_lone_second_surrogate" {
-    // https://github.com/ziglang/zig/issues/5127
-    if (std.Target.current.cpu.arch == .mips) return error.SkipZigTest;
     anyStreamingErrNonStreaming(
         \\["\uDFAA"]
     );

lib/std/os/linux.zig+46-22

 @@ -48,13 +48,27 @@ pub fn getauxval(index: usize) usize {
     return 0;
 }
-// Some architectures require 64bit parameters for some syscalls to be passed in
+// Some architectures (and some syscalls) require 64bit parameters to be passed
-// even-aligned register pair
+// in a even-aligned register pair.
 const require_aligned_register_pair = //
     std.Target.current.cpu.arch.isMIPS() or
     std.Target.current.cpu.arch.isARM() or
     std.Target.current.cpu.arch.isThumb();
+// Split a 64bit value into a {LSB,MSB} pair.
+fn splitValue64(val: u64) [2]u32 {
+    switch (builtin.endian) {
+        .Little => return [2]u32{
+            @truncate(u32, val),
+            @truncate(u32, val >> 32),
+        },
+        .Big => return [2]u32{
+            @truncate(u32, val >> 32),
+            @truncate(u32, val),
+        },
+    }
+}
 /// Get the errno from a syscall return value, or 0 for no error.
 pub fn getErrno(r: usize) u12 {
     const signed_r = @bitCast(isize, r);
 @@ -263,24 +277,26 @@ pub fn read(fd: i32, buf: [*]u8, count: usize) usize {
 }
 pub fn preadv(fd: i32, iov: [*]const iovec, count: usize, offset: u64) usize {
+    const offset_halves = splitValue64(offset);
     return syscall5(
         .preadv,
         @bitCast(usize, @as(isize, fd)),
         @ptrToInt(iov),
         count,
-        @truncate(usize, offset),
+        offset_halves[0],
-        @truncate(usize, offset >> 32),
+        offset_halves[1],
     );
 }
 pub fn preadv2(fd: i32, iov: [*]const iovec, count: usize, offset: u64, flags: kernel_rwf) usize {
+    const offset_halves = splitValue64(offset);
     return syscall6(
         .preadv2,
         @bitCast(usize, @as(isize, fd)),
         @ptrToInt(iov),
         count,
-        @truncate(usize, offset),
+        offset_halves[0],
-        @truncate(usize, offset >> 32),
+        offset_halves[1],
         flags,
     );
 }
 @@ -294,24 +310,26 @@ pub fn writev(fd: i32, iov: [*]const iovec_const, count: usize) usize {
 }
 pub fn pwritev(fd: i32, iov: [*]const iovec_const, count: usize, offset: u64) usize {
+    const offset_halves = splitValue64(offset);
     return syscall5(
         .pwritev,
         @bitCast(usize, @as(isize, fd)),
         @ptrToInt(iov),
         count,
-        @truncate(usize, offset),
+        offset_halves[0],
-        @truncate(usize, offset >> 32),
+        offset_halves[1],
     );
 }
 pub fn pwritev2(fd: i32, iov: [*]const iovec_const, count: usize, offset: u64, flags: kernel_rwf) usize {
+    const offset_halves = splitValue64(offset);
     return syscall6(
         .pwritev2,
         @bitCast(usize, @as(isize, fd)),
         @ptrToInt(iov),
         count,
-        @truncate(usize, offset),
+        offset_halves[0],
-        @truncate(usize, offset >> 32),
+        offset_halves[1],
         flags,
     );
 }
 @@ -338,6 +356,7 @@ pub fn symlinkat(existing: [*:0]const u8, newfd: i32, newpath: [*:0]const u8) us
 pub fn pread(fd: i32, buf: [*]u8, count: usize, offset: u64) usize {
     if (@hasField(SYS, "pread64")) {
+        const offset_halves = splitValue64(offset);
         if (require_aligned_register_pair) {
             return syscall6(
                 .pread64,
 @@ -345,8 +364,8 @@ pub fn pread(fd: i32, buf: [*]u8, count: usize, offset: u64) usize {
                 @ptrToInt(buf),
                 count,
                 0,
-                @truncate(usize, offset),
+                offset_halves[0],
-                @truncate(usize, offset >> 32),
+                offset_halves[1],
             );
         } else {
             return syscall5(
 @@ -354,8 +373,8 @@ pub fn pread(fd: i32, buf: [*]u8, count: usize, offset: u64) usize {
                 @bitCast(usize, @as(isize, fd)),
                 @ptrToInt(buf),
                 count,
-                @truncate(usize, offset),
+                offset_halves[0],
-                @truncate(usize, offset >> 32),
+                offset_halves[1],
             );
         }
     } else {
 @@ -401,20 +420,21 @@ pub fn write(fd: i32, buf: [*]const u8, count: usize) usize {
 pub fn ftruncate(fd: i32, length: u64) usize {
     if (@hasField(SYS, "ftruncate64")) {
+        const length_halves = splitValue64(length);
         if (require_aligned_register_pair) {
             return syscall4(
                 .ftruncate64,
                 @bitCast(usize, @as(isize, fd)),
                 0,
-                @truncate(usize, length),
+                length_halves[0],
-                @truncate(usize, length >> 32),
+                length_halves[1],
             );
         } else {
             return syscall3(
                 .ftruncate64,
                 @bitCast(usize, @as(isize, fd)),
-                @truncate(usize, length),
+                length_halves[0],
-                @truncate(usize, length >> 32),
+                length_halves[1],
             );
         }
     } else {
 @@ -428,6 +448,8 @@ pub fn ftruncate(fd: i32, length: u64) usize {
 pub fn pwrite(fd: i32, buf: [*]const u8, count: usize, offset: u64) usize {
     if (@hasField(SYS, "pwrite64")) {
+        const offset_halves = splitValue64(offset);
         if (require_aligned_register_pair) {
             return syscall6(
                 .pwrite64,
 @@ -435,8 +457,8 @@ pub fn pwrite(fd: i32, buf: [*]const u8, count: usize, offset: u64) usize {
                 @ptrToInt(buf),
                 count,
                 0,
-                @truncate(usize, offset),
+                offset_halves[0],
-                @truncate(usize, offset >> 32),
+                offset_halves[1],
             );
         } else {
             return syscall5(
 @@ -444,8 +466,8 @@ pub fn pwrite(fd: i32, buf: [*]const u8, count: usize, offset: u64) usize {
                 @bitCast(usize, @as(isize, fd)),
                 @ptrToInt(buf),
                 count,
-                @truncate(usize, offset),
+                offset_halves[0],
-                @truncate(usize, offset >> 32),
+                offset_halves[1],
             );
         }
     } else {
 @@ -540,6 +562,8 @@ pub fn close(fd: i32) usize {
 /// Can only be called on 32 bit systems. For 64 bit see `lseek`.
 pub fn llseek(fd: i32, offset: u64, result: ?*u64, whence: usize) usize {
+    // NOTE: The offset parameter splitting is independent from the target
+    // endianness.
     return syscall5(
         ._llseek,
         @bitCast(usize, @as(isize, fd)),

lib/std/unicode.zig+20-9

 @@ -706,41 +706,52 @@ fn calcUtf16LeLen(utf8: []const u8) usize {
 }
 test "utf8ToUtf16LeStringLiteral" {
-    // https://github.com/ziglang/zig/issues/5127
-    if (std.Target.current.cpu.arch == .mips) return error.SkipZigTest;
     {
-        const bytes = [_:0]u16{0x41};
+        const bytes = [_:0]u16{
+            mem.nativeToLittle(u16, 0x41),
+        };
         const utf16 = utf8ToUtf16LeStringLiteral("A");
         testing.expectEqualSlices(u16, &bytes, utf16);
         testing.expect(utf16[1] == 0);
     }
     {
-        const bytes = [_:0]u16{ 0xD801, 0xDC37 };
+        const bytes = [_:0]u16{
+            mem.nativeToLittle(u16, 0xD801),
+            mem.nativeToLittle(u16, 0xDC37),
+        };
         const utf16 = utf8ToUtf16LeStringLiteral("𐐷");
         testing.expectEqualSlices(u16, &bytes, utf16);
         testing.expect(utf16[2] == 0);
     }
     {
-        const bytes = [_:0]u16{0x02FF};
+        const bytes = [_:0]u16{
+            mem.nativeToLittle(u16, 0x02FF),
+        };
         const utf16 = utf8ToUtf16LeStringLiteral("\u{02FF}");
         testing.expectEqualSlices(u16, &bytes, utf16);
         testing.expect(utf16[1] == 0);
     }
     {
-        const bytes = [_:0]u16{0x7FF};
+        const bytes = [_:0]u16{
+            mem.nativeToLittle(u16, 0x7FF),
+        };
         const utf16 = utf8ToUtf16LeStringLiteral("\u{7FF}");
         testing.expectEqualSlices(u16, &bytes, utf16);
         testing.expect(utf16[1] == 0);
     }
     {
-        const bytes = [_:0]u16{0x801};
+        const bytes = [_:0]u16{
+            mem.nativeToLittle(u16, 0x801),
+        };
         const utf16 = utf8ToUtf16LeStringLiteral("\u{801}");
         testing.expectEqualSlices(u16, &bytes, utf16);
         testing.expect(utf16[1] == 0);
     }
     {
-        const bytes = [_:0]u16{ 0xDBFF, 0xDFFF };
+        const bytes = [_:0]u16{
+            mem.nativeToLittle(u16, 0xDBFF),
+            mem.nativeToLittle(u16, 0xDFFF),
+        };
         const utf16 = utf8ToUtf16LeStringLiteral("\u{10FFFF}");
         testing.expectEqualSlices(u16, &bytes, utf16);
         testing.expect(utf16[2] == 0);

test/stage1/behavior/union.zig-3

 @@ -623,9 +623,6 @@ test "0-sized extern union definition" {
 }
 test "union initializer generates padding only if needed" {
-    // https://github.com/ziglang/zig/issues/5127
-    if (std.Target.current.cpu.arch == .mips) return error.SkipZigTest;
     const U = union(enum) {
         A: u24,
     };

author	Andrew Kelley <andrew@ziglang.org> 2020-11-02 13:37:24-05:00
committer	GitHub <noreply@github.com> 2020-11-02 13:37:24-05:00
log	061ff11b2b8aca33fec0d5d381855d5bd3aa6ff9
tree	43488e010c69f136e7d7a91535ad477ecafcc6fb
parent	ecdd6366052ec815466db0c64b2a5abe59267393
parent	dc872a221d8301cfac4b9ead09196c5b18cf63b2
signature	Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #6927 from LemonBoy/mipsbe-std