Merge remote-tracking branch 'origin/master' into macos-stack-traces

16 files changed, 44 insertions, 51 deletions

diff --git a/std/event/fs.zig b/std/event/fs.zig
index ac99f13c9b..5e7e24ff43 100644
--- a/std/event/fs.zig
+++ b/std/event/fs.zig
@@ -638,10 +638,7 @@ pub async fn readFile(loop: *Loop, file_path: []const u8, max_size: usize) ![]u8
     var close_op = try CloseOperation.start(loop);
     defer close_op.finish();
 
-    const path_with_null = try std.cstr.addNullByte(loop.allocator, file_path);
-    defer loop.allocator.free(path_with_null);
-
-    const fd = try await (async openRead(loop, path_with_null[0..file_path.len]) catch unreachable);
+    const fd = try await (async openRead(loop, file_path) catch unreachable);
     close_op.setHandle(fd);
 
     var list = std.ArrayList(u8).init(loop.allocator);
diff --git a/std/fmt/errol/index.zig b/std/fmt/errol/index.zig
index 3222913107..8b1ffa3622 100644
--- a/std/fmt/errol/index.zig
+++ b/std/fmt/errol/index.zig
@@ -253,11 +253,7 @@ fn gethi(in: f64) f64 {
 /// Normalize the number by factoring in the error.
 ///   @hp: The float pair.
 fn hpNormalize(hp: *HP) void {
-    // Required to avoid segfaults causing buffer overrun during errol3 digit output termination.
-    @setFloatMode(this, @import("builtin").FloatMode.Strict);
-
     const val = hp.val;
-
     hp.val += hp.off;
     hp.off += val - hp.val;
 }
diff --git a/std/math/ceil.zig b/std/math/ceil.zig
index 1c429504e8..8a5221d862 100644
--- a/std/math/ceil.zig
+++ b/std/math/ceil.zig
@@ -61,10 +61,8 @@ fn ceil64(x: f64) f64 {
     }
 
     if (u >> 63 != 0) {
-        @setFloatMode(this, builtin.FloatMode.Strict);
         y = x - math.f64_toint + math.f64_toint - x;
     } else {
-        @setFloatMode(this, builtin.FloatMode.Strict);
         y = x + math.f64_toint - math.f64_toint - x;
     }
 
diff --git a/std/math/complex/exp.zig b/std/math/complex/exp.zig
index 48fb132d97..e696ee42b4 100644
--- a/std/math/complex/exp.zig
+++ b/std/math/complex/exp.zig
@@ -17,8 +17,6 @@ pub fn exp(z: var) @typeOf(z) {
 }
 
 fn exp32(z: Complex(f32)) Complex(f32) {
-    @setFloatMode(this, @import("builtin").FloatMode.Strict);
-
     const exp_overflow = 0x42b17218; // max_exp * ln2 ~= 88.72283955
     const cexp_overflow = 0x43400074; // (max_exp - min_denom_exp) * ln2
 
diff --git a/std/math/cos.zig b/std/math/cos.zig
index 71d5e4a8f6..b6a2fbffe6 100644
--- a/std/math/cos.zig
+++ b/std/math/cos.zig
@@ -37,8 +37,6 @@ const C5 = 4.16666666666665929218E-2;
 //
 // This may have slight differences on some edge cases and may need to replaced if so.
 fn cos32(x_: f32) f32 {
-    @setFloatMode(this, @import("builtin").FloatMode.Strict);
-
     const pi4a = 7.85398125648498535156e-1;
     const pi4b = 3.77489470793079817668E-8;
     const pi4c = 2.69515142907905952645E-15;
diff --git a/std/math/exp.zig b/std/math/exp.zig
index d6185d4f0b..cf8fd62d80 100644
--- a/std/math/exp.zig
+++ b/std/math/exp.zig
@@ -18,8 +18,6 @@ pub fn exp(x: var) @typeOf(x) {
 }
 
 fn exp32(x_: f32) f32 {
-    @setFloatMode(this, builtin.FloatMode.Strict);
-
     const half = []f32{ 0.5, -0.5 };
     const ln2hi = 6.9314575195e-1;
     const ln2lo = 1.4286067653e-6;
@@ -95,8 +93,6 @@ fn exp32(x_: f32) f32 {
 }
 
 fn exp64(x_: f64) f64 {
-    @setFloatMode(this, builtin.FloatMode.Strict);
-
     const half = []const f64{ 0.5, -0.5 };
     const ln2hi: f64 = 6.93147180369123816490e-01;
     const ln2lo: f64 = 1.90821492927058770002e-10;
diff --git a/std/math/exp2.zig b/std/math/exp2.zig
index d590b0b60b..3d8e5d692e 100644
--- a/std/math/exp2.zig
+++ b/std/math/exp2.zig
@@ -36,8 +36,6 @@ const exp2ft = []const f64{
 };
 
 fn exp2_32(x: f32) f32 {
-    @setFloatMode(this, @import("builtin").FloatMode.Strict);
-
     const tblsiz = @intCast(u32, exp2ft.len);
     const redux: f32 = 0x1.8p23 / @intToFloat(f32, tblsiz);
     const P1: f32 = 0x1.62e430p-1;
@@ -353,8 +351,6 @@ const exp2dt = []f64{
 };
 
 fn exp2_64(x: f64) f64 {
-    @setFloatMode(this, @import("builtin").FloatMode.Strict);
-
     const tblsiz = @intCast(u32, exp2dt.len / 2);
     const redux: f64 = 0x1.8p52 / @intToFloat(f64, tblsiz);
     const P1: f64 = 0x1.62e42fefa39efp-1;
diff --git a/std/math/expm1.zig b/std/math/expm1.zig
index 6fa0194b32..6729417f60 100644
--- a/std/math/expm1.zig
+++ b/std/math/expm1.zig
@@ -19,8 +19,6 @@ pub fn expm1(x: var) @typeOf(x) {
 }
 
 fn expm1_32(x_: f32) f32 {
-    @setFloatMode(this, builtin.FloatMode.Strict);
-
     if (math.isNan(x_))
         return math.nan(f32);
 
@@ -149,8 +147,6 @@ fn expm1_32(x_: f32) f32 {
 }
 
 fn expm1_64(x_: f64) f64 {
-    @setFloatMode(this, builtin.FloatMode.Strict);
-
     if (math.isNan(x_))
         return math.nan(f64);
 
diff --git a/std/math/floor.zig b/std/math/floor.zig
index 0858598eea..6ce462b10f 100644
--- a/std/math/floor.zig
+++ b/std/math/floor.zig
@@ -97,10 +97,8 @@ fn floor64(x: f64) f64 {
     }
 
     if (u >> 63 != 0) {
-        @setFloatMode(this, builtin.FloatMode.Strict);
         y = x - math.f64_toint + math.f64_toint - x;
     } else {
-        @setFloatMode(this, builtin.FloatMode.Strict);
         y = x + math.f64_toint - math.f64_toint - x;
     }
 
diff --git a/std/math/ln.zig b/std/math/ln.zig
index e78cc379e0..a560fee8ec 100644
--- a/std/math/ln.zig
+++ b/std/math/ln.zig
@@ -35,8 +35,6 @@ pub fn ln(x: var) @typeOf(x) {
 }
 
 pub fn ln_32(x_: f32) f32 {
-    @setFloatMode(this, @import("builtin").FloatMode.Strict);
-
     const ln2_hi: f32 = 6.9313812256e-01;
     const ln2_lo: f32 = 9.0580006145e-06;
     const Lg1: f32 = 0xaaaaaa.0p-24;
@@ -89,8 +87,6 @@ pub fn ln_32(x_: f32) f32 {
 }
 
 pub fn ln_64(x_: f64) f64 {
-    @setFloatMode(this, @import("builtin").FloatMode.Strict);
-
     const ln2_hi: f64 = 6.93147180369123816490e-01;
     const ln2_lo: f64 = 1.90821492927058770002e-10;
     const Lg1: f64 = 6.666666666666735130e-01;
diff --git a/std/math/pow.zig b/std/math/pow.zig
index 7fc334c06b..c764b58182 100644
--- a/std/math/pow.zig
+++ b/std/math/pow.zig
@@ -28,8 +28,6 @@ const assert = std.debug.assert;
 
 // This implementation is taken from the go stlib, musl is a bit more complex.
 pub fn pow(comptime T: type, x: T, y: T) T {
-    @setFloatMode(this, @import("builtin").FloatMode.Strict);
-
     if (T != f32 and T != f64) {
         @compileError("pow not implemented for " ++ @typeName(T));
     }
diff --git a/std/math/round.zig b/std/math/round.zig
index c8d9eb4fd4..4fe35365c8 100644
--- a/std/math/round.zig
+++ b/std/math/round.zig
@@ -35,11 +35,7 @@ fn round32(x_: f32) f32 {
         return 0 * @bitCast(f32, u);
     }
 
-    {
-        @setFloatMode(this, builtin.FloatMode.Strict);
-        y = x + math.f32_toint - math.f32_toint - x;
-    }
-
+    y = x + math.f32_toint - math.f32_toint - x;
     if (y > 0.5) {
         y = y + x - 1;
     } else if (y <= -0.5) {
@@ -72,11 +68,7 @@ fn round64(x_: f64) f64 {
         return 0 * @bitCast(f64, u);
     }
 
-    {
-        @setFloatMode(this, builtin.FloatMode.Strict);
-        y = x + math.f64_toint - math.f64_toint - x;
-    }
-
+    y = x + math.f64_toint - math.f64_toint - x;
     if (y > 0.5) {
         y = y + x - 1;
     } else if (y <= -0.5) {
diff --git a/std/math/sin.zig b/std/math/sin.zig
index 3796d74812..15b2f9f17a 100644
--- a/std/math/sin.zig
+++ b/std/math/sin.zig
@@ -38,8 +38,6 @@ const C5 = 4.16666666666665929218E-2;
 //
 // This may have slight differences on some edge cases and may need to replaced if so.
 fn sin32(x_: f32) f32 {
-    @setFloatMode(this, @import("builtin").FloatMode.Strict);
-
     const pi4a = 7.85398125648498535156e-1;
     const pi4b = 3.77489470793079817668E-8;
     const pi4c = 2.69515142907905952645E-15;
diff --git a/std/math/sinh.zig b/std/math/sinh.zig
index bb3af280ab..3105b9a26e 100644
--- a/std/math/sinh.zig
+++ b/std/math/sinh.zig
@@ -54,8 +54,6 @@ fn sinh32(x: f32) f32 {
 }
 
 fn sinh64(x: f64) f64 {
-    @setFloatMode(this, @import("builtin").FloatMode.Strict);
-
     const u = @bitCast(u64, x);
     const w = @intCast(u32, u >> 32);
     const ax = @bitCast(f64, u & (@maxValue(u64) >> 1));
diff --git a/std/math/tan.zig b/std/math/tan.zig
index ff3ed06186..a71a17e625 100644
--- a/std/math/tan.zig
+++ b/std/math/tan.zig
@@ -31,8 +31,6 @@ const Tq4 = -5.38695755929454629881E7;
 //
 // This may have slight differences on some edge cases and may need to replaced if so.
 fn tan32(x_: f32) f32 {
-    @setFloatMode(this, @import("builtin").FloatMode.Strict);
-
     const pi4a = 7.85398125648498535156e-1;
     const pi4b = 3.77489470793079817668E-8;
     const pi4c = 2.69515142907905952645E-15;
diff --git a/std/mem.zig b/std/mem.zig
index 1ba5b3b73e..4390f8ad5b 100644
--- a/std/mem.zig
+++ b/std/mem.zig
@@ -679,10 +679,38 @@ test "testWriteInt" {
     comptime testWriteIntImpl();
 }
 fn testWriteIntImpl() void {
-    var bytes: [4]u8 = undefined;
+    var bytes: [8]u8 = undefined;
+
+    writeInt(bytes[0..], u64(0x12345678CAFEBABE), builtin.Endian.Big);
+    assert(eql(u8, bytes, []u8{
+        0x12,
+        0x34,
+        0x56,
+        0x78,
+        0xCA,
+        0xFE,
+        0xBA,
+        0xBE,
+    }));
+
+    writeInt(bytes[0..], u64(0xBEBAFECA78563412), builtin.Endian.Little);
+    assert(eql(u8, bytes, []u8{
+        0x12,
+        0x34,
+        0x56,
+        0x78,
+        0xCA,
+        0xFE,
+        0xBA,
+        0xBE,
+    }));
 
     writeInt(bytes[0..], u32(0x12345678), builtin.Endian.Big);
     assert(eql(u8, bytes, []u8{
+        0x00,
+        0x00,
+        0x00,
+        0x00,
         0x12,
         0x34,
         0x56,
@@ -695,12 +723,20 @@ fn testWriteIntImpl() void {
         0x34,
         0x56,
         0x78,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
     }));
 
     writeInt(bytes[0..], u16(0x1234), builtin.Endian.Big);
     assert(eql(u8, bytes, []u8{
         0x00,
         0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
         0x12,
         0x34,
     }));
@@ -711,6 +747,10 @@ fn testWriteIntImpl() void {
         0x12,
         0x00,
         0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
     }));
 }