Merge remote-tracking branch 'origin/master' into zir-memory-layout

Wanted to make sure those new test cases still pass.

Also grab that CI fix so we can get those green check marks.

13 files changed, 420 insertions, 368 deletions

diff --git a/lib/std/array_hash_map.zig b/lib/std/array_hash_map.zig
index 7b0d9ea4dd..83a061dfef 100644
--- a/lib/std/array_hash_map.zig
+++ b/lib/std/array_hash_map.zig
@@ -687,8 +687,9 @@ pub fn ArrayHashMapUnmanaged(
 
         /// Removes the last inserted `Entry` in the hash map and returns it.
         pub fn pop(self: *Self) Entry {
-            const top = self.entries.pop();
+            const top = self.entries.items[self.entries.items.len - 1];
             _ = self.removeWithHash(top.key, top.hash, .index_only);
+            self.entries.items.len -= 1;
             return top;
         }
 
@@ -1258,19 +1259,18 @@ test "pop" {
     var map = AutoArrayHashMap(i32, i32).init(std.testing.allocator);
     defer map.deinit();
 
-    testing.expect((try map.fetchPut(1, 11)) == null);
-    testing.expect((try map.fetchPut(2, 22)) == null);
-    testing.expect((try map.fetchPut(3, 33)) == null);
-    testing.expect((try map.fetchPut(4, 44)) == null);
+    // Insert just enough entries so that the map expands. Afterwards,
+    // pop all entries out of the map.
 
-    const pop1 = map.pop();
-    testing.expect(pop1.key == 4 and pop1.value == 44);
-    const pop2 = map.pop();
-    testing.expect(pop2.key == 3 and pop2.value == 33);
-    const pop3 = map.pop();
-    testing.expect(pop3.key == 2 and pop3.value == 22);
-    const pop4 = map.pop();
-    testing.expect(pop4.key == 1 and pop4.value == 11);
+    var i: i32 = 0;
+    while (i < 9) : (i += 1) {
+        testing.expect((try map.fetchPut(i, i)) == null);
+    }
+
+    while (i > 0) : (i -= 1) {
+        const pop = map.pop();
+        testing.expect(pop.key == i - 1 and pop.value == i - 1);
+    }
 }
 
 test "reIndex" {
diff --git a/lib/std/base64.zig b/lib/std/base64.zig
index e6a780c239..4e7c9a696f 100644
--- a/lib/std/base64.zig
+++ b/lib/std/base64.zig
@@ -8,454 +8,452 @@ const assert = std.debug.assert;
 const testing = std.testing;
 const mem = std.mem;
 
-pub const standard_alphabet_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-pub const standard_pad_char = '=';
-pub const standard_encoder = Base64Encoder.init(standard_alphabet_chars, standard_pad_char);
+pub const Error = error{
+    InvalidCharacter,
+    InvalidPadding,
+    NoSpaceLeft,
+};
+
+/// Base64 codecs
+pub const Codecs = struct {
+    alphabet_chars: [64]u8,
+    pad_char: ?u8,
+    decoderWithIgnore: fn (ignore: []const u8) Base64DecoderWithIgnore,
+    Encoder: Base64Encoder,
+    Decoder: Base64Decoder,
+};
+
+pub const standard_alphabet_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".*;
+fn standardBase64DecoderWithIgnore(ignore: []const u8) Base64DecoderWithIgnore {
+    return Base64DecoderWithIgnore.init(standard_alphabet_chars, '=', ignore);
+}
+
+/// Standard Base64 codecs, with padding
+pub const standard = Codecs{
+    .alphabet_chars = standard_alphabet_chars,
+    .pad_char = '=',
+    .decoderWithIgnore = standardBase64DecoderWithIgnore,
+    .Encoder = Base64Encoder.init(standard_alphabet_chars, '='),
+    .Decoder = Base64Decoder.init(standard_alphabet_chars, '='),
+};
+
+/// Standard Base64 codecs, without padding
+pub const standard_no_pad = Codecs{
+    .alphabet_chars = standard_alphabet_chars,
+    .pad_char = null,
+    .decoderWithIgnore = standardBase64DecoderWithIgnore,
+    .Encoder = Base64Encoder.init(standard_alphabet_chars, null),
+    .Decoder = Base64Decoder.init(standard_alphabet_chars, null),
+};
+
+pub const url_safe_alphabet_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_".*;
+fn urlSafeBase64DecoderWithIgnore(ignore: []const u8) Base64DecoderWithIgnore {
+    return Base64DecoderWithIgnore.init(url_safe_alphabet_chars, null, ignore);
+}
+
+/// URL-safe Base64 codecs, with padding
+pub const url_safe = Codecs{
+    .alphabet_chars = url_safe_alphabet_chars,
+    .pad_char = '=',
+    .decoderWithIgnore = urlSafeBase64DecoderWithIgnore,
+    .Encoder = Base64Encoder.init(url_safe_alphabet_chars, '='),
+    .Decoder = Base64Decoder.init(url_safe_alphabet_chars, '='),
+};
+
+/// URL-safe Base64 codecs, without padding
+pub const url_safe_no_pad = Codecs{
+    .alphabet_chars = url_safe_alphabet_chars,
+    .pad_char = null,
+    .decoderWithIgnore = urlSafeBase64DecoderWithIgnore,
+    .Encoder = Base64Encoder.init(url_safe_alphabet_chars, null),
+    .Decoder = Base64Decoder.init(url_safe_alphabet_chars, null),
+};
+
+// Backwards compatibility
+
+/// Deprecated - Use `standard.pad_char`
+pub const standard_pad_char = standard.pad_char;
+/// Deprecated - Use `standard.Encoder`
+pub const standard_encoder = standard.Encoder;
+/// Deprecated - Use `standard.Decoder`
+pub const standard_decoder = standard.Decoder;
 
 pub const Base64Encoder = struct {
-    alphabet_chars: []const u8,
-    pad_char: u8,
+    alphabet_chars: [64]u8,
+    pad_char: ?u8,
 
-    /// a bunch of assertions, then simply pass the data right through.
-    pub fn init(alphabet_chars: []const u8, pad_char: u8) Base64Encoder {
+    /// A bunch of assertions, then simply pass the data right through.
+    pub fn init(alphabet_chars: [64]u8, pad_char: ?u8) Base64Encoder {
         assert(alphabet_chars.len == 64);
         var char_in_alphabet = [_]bool{false} ** 256;
         for (alphabet_chars) |c| {
             assert(!char_in_alphabet[c]);
-            assert(c != pad_char);
+            assert(pad_char == null or c != pad_char.?);
             char_in_alphabet[c] = true;
         }
-
         return Base64Encoder{
             .alphabet_chars = alphabet_chars,
             .pad_char = pad_char,
         };
     }
 
-    /// ceil(source_len * 4/3)
-    pub fn calcSize(source_len: usize) usize {
-        return @divTrunc(source_len + 2, 3) * 4;
+    /// Compute the encoded length
+    pub fn calcSize(encoder: *const Base64Encoder, source_len: usize) usize {
+        if (encoder.pad_char != null) {
+            return @divTrunc(source_len + 2, 3) * 4;
+        } else {
+            const leftover = source_len % 3;
+            return @divTrunc(source_len, 3) * 4 + @divTrunc(leftover * 4 + 2, 3);
+        }
     }
 
-    /// dest.len must be what you get from ::calcSize.
+    /// dest.len must at least be what you get from ::calcSize.
     pub fn encode(encoder: *const Base64Encoder, dest: []u8, source: []const u8) []const u8 {
-        assert(dest.len >= Base64Encoder.calcSize(source.len));
-
-        var i: usize = 0;
-        var out_index: usize = 0;
-        while (i + 2 < source.len) : (i += 3) {
-            dest[out_index] = encoder.alphabet_chars[(source[i] >> 2) & 0x3f];
-            out_index += 1;
-
-            dest[out_index] = encoder.alphabet_chars[((source[i] & 0x3) << 4) | ((source[i + 1] & 0xf0) >> 4)];
-            out_index += 1;
-
-            dest[out_index] = encoder.alphabet_chars[((source[i + 1] & 0xf) << 2) | ((source[i + 2] & 0xc0) >> 6)];
-            out_index += 1;
-
-            dest[out_index] = encoder.alphabet_chars[source[i + 2] & 0x3f];
-            out_index += 1;
+        const out_len = encoder.calcSize(source.len);
+        assert(dest.len >= out_len);
+
+        const nibbles = source.len / 3;
+        const leftover = source.len - 3 * nibbles;
+
+        var acc: u12 = 0;
+        var acc_len: u4 = 0;
+        var out_idx: usize = 0;
+        for (source) |v| {
+            acc = (acc << 8) + v;
+            acc_len += 8;
+            while (acc_len >= 6) {
+                acc_len -= 6;
+                dest[out_idx] = encoder.alphabet_chars[@truncate(u6, (acc >> acc_len))];
+                out_idx += 1;
+            }
         }
-
-        if (i < source.len) {
-            dest[out_index] = encoder.alphabet_chars[(source[i] >> 2) & 0x3f];
-            out_index += 1;
-
-            if (i + 1 == source.len) {
-                dest[out_index] = encoder.alphabet_chars[(source[i] & 0x3) << 4];
-                out_index += 1;
-
-                dest[out_index] = encoder.pad_char;
-                out_index += 1;
-            } else {
-                dest[out_index] = encoder.alphabet_chars[((source[i] & 0x3) << 4) | ((source[i + 1] & 0xf0) >> 4)];
-                out_index += 1;
-
-                dest[out_index] = encoder.alphabet_chars[(source[i + 1] & 0xf) << 2];
-                out_index += 1;
+        if (acc_len > 0) {
+            dest[out_idx] = encoder.alphabet_chars[@truncate(u6, (acc << 6 - acc_len))];
+            out_idx += 1;
+        }
+        if (encoder.pad_char) |pad_char| {
+            for (dest[out_idx..]) |*pad| {
+                pad.* = pad_char;
             }
-
-            dest[out_index] = encoder.pad_char;
-            out_index += 1;
         }
-        return dest[0..out_index];
+        return dest[0..out_len];
     }
 };
 
-pub const standard_decoder = Base64Decoder.init(standard_alphabet_chars, standard_pad_char);
-
 pub const Base64Decoder = struct {
+    const invalid_char: u8 = 0xff;
+
     /// e.g. 'A' => 0.
-    /// undefined for any value not in the 64 alphabet chars.
+    /// `invalid_char` for any value not in the 64 alphabet chars.
     char_to_index: [256]u8,
+    pad_char: ?u8,
 
-    /// true only for the 64 chars in the alphabet, not the pad char.
-    char_in_alphabet: [256]bool,
-    pad_char: u8,
-
-    pub fn init(alphabet_chars: []const u8, pad_char: u8) Base64Decoder {
-        assert(alphabet_chars.len == 64);
-
+    pub fn init(alphabet_chars: [64]u8, pad_char: ?u8) Base64Decoder {
         var result = Base64Decoder{
-            .char_to_index = undefined,
-            .char_in_alphabet = [_]bool{false} ** 256,
+            .char_to_index = [_]u8{invalid_char} ** 256,
             .pad_char = pad_char,
         };
 
+        var char_in_alphabet = [_]bool{false} ** 256;
         for (alphabet_chars) |c, i| {
-            assert(!result.char_in_alphabet[c]);
-            assert(c != pad_char);
+            assert(!char_in_alphabet[c]);
+            assert(pad_char == null or c != pad_char.?);
 
             result.char_to_index[c] = @intCast(u8, i);
-            result.char_in_alphabet[c] = true;
+            char_in_alphabet[c] = true;
         }
+        return result;
+    }
 
+    /// Return the maximum possible decoded size for a given input length - The actual length may be less if the input includes padding.
+    /// `InvalidPadding` is returned if the input length is not valid.
+    pub fn calcSizeUpperBound(decoder: *const Base64Decoder, source_len: usize) Error!usize {
+        var result = source_len / 4 * 3;
+        const leftover = source_len % 4;
+        if (decoder.pad_char != null) {
+            if (leftover % 4 != 0) return error.InvalidPadding;
+        } else {
+            if (leftover % 4 == 1) return error.InvalidPadding;
+            result += leftover * 3 / 4;
+        }
         return result;
     }
 
-    /// If the encoded buffer is detected to be invalid, returns error.InvalidPadding.
-    pub fn calcSize(decoder: *const Base64Decoder, source: []const u8) !usize {
-        if (source.len % 4 != 0) return error.InvalidPadding;
-        return calcDecodedSizeExactUnsafe(source, decoder.pad_char);
+    /// Return the exact decoded size for a slice.
+    /// `InvalidPadding` is returned if the input length is not valid.
+    pub fn calcSizeForSlice(decoder: *const Base64Decoder, source: []const u8) Error!usize {
+        const source_len = source.len;
+        var result = try decoder.calcSizeUpperBound(source_len);
+        if (decoder.pad_char) |pad_char| {
+            if (source_len >= 1 and source[source_len - 1] == pad_char) result -= 1;
+            if (source_len >= 2 and source[source_len - 2] == pad_char) result -= 1;
+        }
+        return result;
     }
 
     /// dest.len must be what you get from ::calcSize.
     /// invalid characters result in error.InvalidCharacter.
     /// invalid padding results in error.InvalidPadding.
-    pub fn decode(decoder: *const Base64Decoder, dest: []u8, source: []const u8) !void {
-        assert(dest.len == (decoder.calcSize(source) catch unreachable));
-        assert(source.len % 4 == 0);
-
-        var src_cursor: usize = 0;
-        var dest_cursor: usize = 0;
-
-        while (src_cursor < source.len) : (src_cursor += 4) {
-            if (!decoder.char_in_alphabet[source[src_cursor + 0]]) return error.InvalidCharacter;
-            if (!decoder.char_in_alphabet[source[src_cursor + 1]]) return error.InvalidCharacter;
-            if (src_cursor < source.len - 4 or source[src_cursor + 3] != decoder.pad_char) {
-                // common case
-                if (!decoder.char_in_alphabet[source[src_cursor + 2]]) return error.InvalidCharacter;
-                if (!decoder.char_in_alphabet[source[src_cursor + 3]]) return error.InvalidCharacter;
-                dest[dest_cursor + 0] = decoder.char_to_index[source[src_cursor + 0]] << 2 | decoder.char_to_index[source[src_cursor + 1]] >> 4;
-                dest[dest_cursor + 1] = decoder.char_to_index[source[src_cursor + 1]] << 4 | decoder.char_to_index[source[src_cursor + 2]] >> 2;
-                dest[dest_cursor + 2] = decoder.char_to_index[source[src_cursor + 2]] << 6 | decoder.char_to_index[source[src_cursor + 3]];
-                dest_cursor += 3;
-            } else if (source[src_cursor + 2] != decoder.pad_char) {
-                // one pad char
-                if (!decoder.char_in_alphabet[source[src_cursor + 2]]) return error.InvalidCharacter;
-                dest[dest_cursor + 0] = decoder.char_to_index[source[src_cursor + 0]] << 2 | decoder.char_to_index[source[src_cursor + 1]] >> 4;
-                dest[dest_cursor + 1] = decoder.char_to_index[source[src_cursor + 1]] << 4 | decoder.char_to_index[source[src_cursor + 2]] >> 2;
-                if (decoder.char_to_index[source[src_cursor + 2]] << 6 != 0) return error.InvalidPadding;
-                dest_cursor += 2;
-            } else {
-                // two pad chars
-                dest[dest_cursor + 0] = decoder.char_to_index[source[src_cursor + 0]] << 2 | decoder.char_to_index[source[src_cursor + 1]] >> 4;
-                if (decoder.char_to_index[source[src_cursor + 1]] << 4 != 0) return error.InvalidPadding;
-                dest_cursor += 1;
+    pub fn decode(decoder: *const Base64Decoder, dest: []u8, source: []const u8) Error!void {
+        if (decoder.pad_char != null and source.len % 4 != 0) return error.InvalidPadding;
+        var acc: u12 = 0;
+        var acc_len: u4 = 0;
+        var dest_idx: usize = 0;
+        var leftover_idx: ?usize = null;
+        for (source) |c, src_idx| {
+            const d = decoder.char_to_index[c];
+            if (d == invalid_char) {
+                if (decoder.pad_char == null or c != decoder.pad_char.?) return error.InvalidCharacter;
+                leftover_idx = src_idx;
+                break;
+            }
+            acc = (acc << 6) + d;
+            acc_len += 6;
+            if (acc_len >= 8) {
+                acc_len -= 8;
+                dest[dest_idx] = @truncate(u8, acc >> acc_len);
+                dest_idx += 1;
             }
         }
-
-        assert(src_cursor == source.len);
-        assert(dest_cursor == dest.len);
+        if (acc_len > 4 or (acc & (@as(u12, 1) << acc_len) - 1) != 0) {
+            return error.InvalidPadding;
+        }
+        if (leftover_idx == null) return;
+        var leftover = source[leftover_idx.?..];
+        if (decoder.pad_char) |pad_char| {
+            const padding_len = acc_len / 2;
+            var padding_chars: usize = 0;
+            var i: usize = 0;
+            for (leftover) |c| {
+                if (c != pad_char) {
+                    return if (c == Base64Decoder.invalid_char) error.InvalidCharacter else error.InvalidPadding;
+                }
+                padding_chars += 1;
+            }
+            if (padding_chars != padding_len) return error.InvalidPadding;
+        }
     }
 };
 
 pub const Base64DecoderWithIgnore = struct {
     decoder: Base64Decoder,
     char_is_ignored: [256]bool,
-    pub fn init(alphabet_chars: []const u8, pad_char: u8, ignore_chars: []const u8) Base64DecoderWithIgnore {
+
+    pub fn init(alphabet_chars: [64]u8, pad_char: ?u8, ignore_chars: []const u8) Base64DecoderWithIgnore {
         var result = Base64DecoderWithIgnore{
             .decoder = Base64Decoder.init(alphabet_chars, pad_char),
             .char_is_ignored = [_]bool{false} ** 256,
         };
-
         for (ignore_chars) |c| {
-            assert(!result.decoder.char_in_alphabet[c]);
+            assert(result.decoder.char_to_index[c] == Base64Decoder.invalid_char);
             assert(!result.char_is_ignored[c]);
             assert(result.decoder.pad_char != c);
             result.char_is_ignored[c] = true;
         }
-
         return result;
     }
 
-    /// If no characters end up being ignored or padding, this will be the exact decoded size.
-    pub fn calcSizeUpperBound(encoded_len: usize) usize {
-        return @divTrunc(encoded_len, 4) * 3;
+    /// Return the maximum possible decoded size for a given input length - The actual length may be less if the input includes padding
+    /// `InvalidPadding` is returned if the input length is not valid.
+    pub fn calcSizeUpperBound(decoder_with_ignore: *const Base64DecoderWithIgnore, source_len: usize) Error!usize {
+        var result = source_len / 4 * 3;
+        if (decoder_with_ignore.decoder.pad_char == null) {
+            const leftover = source_len % 4;
+            result += leftover * 3 / 4;
+        }
+        return result;
     }
 
     /// Invalid characters that are not ignored result in error.InvalidCharacter.
     /// Invalid padding results in error.InvalidPadding.
-    /// Decoding more data than can fit in dest results in error.OutputTooSmall. See also ::calcSizeUpperBound.
+    /// Decoding more data than can fit in dest results in error.NoSpaceLeft. See also ::calcSizeUpperBound.
     /// Returns the number of bytes written to dest.
-    pub fn decode(decoder_with_ignore: *const Base64DecoderWithIgnore, dest: []u8, source: []const u8) !usize {
+    pub fn decode(decoder_with_ignore: *const Base64DecoderWithIgnore, dest: []u8, source: []const u8) Error!usize {
         const decoder = &decoder_with_ignore.decoder;
-
-        var src_cursor: usize = 0;
-        var dest_cursor: usize = 0;
-
-        while (true) {
-            // get the next 4 chars, if available
-            var next_4_chars: [4]u8 = undefined;
-            var available_chars: usize = 0;
-            var pad_char_count: usize = 0;
-            while (available_chars < 4 and src_cursor < source.len) {
-                var c = source[src_cursor];
-                src_cursor += 1;
-
-                if (decoder.char_in_alphabet[c]) {
-                    // normal char
-                    next_4_chars[available_chars] = c;
-                    available_chars += 1;
-                } else if (decoder_with_ignore.char_is_ignored[c]) {
-                    // we're told to skip this one
-                    continue;
-                } else if (c == decoder.pad_char) {
-                    // the padding has begun. count the pad chars.
-                    pad_char_count += 1;
-                    while (src_cursor < source.len) {
-                        c = source[src_cursor];
-                        src_cursor += 1;
-                        if (c == decoder.pad_char) {
-                            pad_char_count += 1;
-                            if (pad_char_count > 2) return error.InvalidCharacter;
-                        } else if (decoder_with_ignore.char_is_ignored[c]) {
-                            // we can even ignore chars during the padding
-                            continue;
-                        } else return error.InvalidCharacter;
-                    }
-                    break;
-                } else return error.InvalidCharacter;
+        var acc: u12 = 0;
+        var acc_len: u4 = 0;
+        var dest_idx: usize = 0;
+        var leftover_idx: ?usize = null;
+        for (source) |c, src_idx| {
+            if (decoder_with_ignore.char_is_ignored[c]) continue;
+            const d = decoder.char_to_index[c];
+            if (d == Base64Decoder.invalid_char) {
+                if (decoder.pad_char == null or c != decoder.pad_char.?) return error.InvalidCharacter;
+                leftover_idx = src_idx;
+                break;
             }
-
-            switch (available_chars) {
-                4 => {
-                    // common case
-                    if (dest_cursor + 3 > dest.len) return error.OutputTooSmall;
-                    assert(pad_char_count == 0);
-                    dest[dest_cursor + 0] = decoder.char_to_index[next_4_chars[0]] << 2 | decoder.char_to_index[next_4_chars[1]] >> 4;
-                    dest[dest_cursor + 1] = decoder.char_to_index[next_4_chars[1]] << 4 | decoder.char_to_index[next_4_chars[2]] >> 2;
-                    dest[dest_cursor + 2] = decoder.char_to_index[next_4_chars[2]] << 6 | decoder.char_to_index[next_4_chars[3]];
-                    dest_cursor += 3;
-                    continue;
-                },
-                3 => {
-                    if (dest_cursor + 2 > dest.len) return error.OutputTooSmall;
-                    if (pad_char_count != 1) return error.InvalidPadding;
-                    dest[dest_cursor + 0] = decoder.char_to_index[next_4_chars[0]] << 2 | decoder.char_to_index[next_4_chars[1]] >> 4;
-                    dest[dest_cursor + 1] = decoder.char_to_index[next_4_chars[1]] << 4 | decoder.char_to_index[next_4_chars[2]] >> 2;
-                    if (decoder.char_to_index[next_4_chars[2]] << 6 != 0) return error.InvalidPadding;
-                    dest_cursor += 2;
-                    break;
-                },
-                2 => {
-                    if (dest_cursor + 1 > dest.len) return error.OutputTooSmall;
-                    if (pad_char_count != 2) return error.InvalidPadding;
-                    dest[dest_cursor + 0] = decoder.char_to_index[next_4_chars[0]] << 2 | decoder.char_to_index[next_4_chars[1]] >> 4;
-                    if (decoder.char_to_index[next_4_chars[1]] << 4 != 0) return error.InvalidPadding;
-                    dest_cursor += 1;
-                    break;
-                },
-                1 => {
-                    return error.InvalidPadding;
-                },
-                0 => {
-                    if (pad_char_count != 0) return error.InvalidPadding;
-                    break;
-                },
-                else => unreachable,
+            acc = (acc << 6) + d;
+            acc_len += 6;
+            if (acc_len >= 8) {
+                if (dest_idx == dest.len) return error.NoSpaceLeft;
+                acc_len -= 8;
+                dest[dest_idx] = @truncate(u8, acc >> acc_len);
+                dest_idx += 1;
             }
         }
-
-        assert(src_cursor == source.len);
-
-        return dest_cursor;
-    }
-};
-
-pub const standard_decoder_unsafe = Base64DecoderUnsafe.init(standard_alphabet_chars, standard_pad_char);
-
-pub const Base64DecoderUnsafe = struct {
-    /// e.g. 'A' => 0.
-    /// undefined for any value not in the 64 alphabet chars.
-    char_to_index: [256]u8,
-    pad_char: u8,
-
-    pub fn init(alphabet_chars: []const u8, pad_char: u8) Base64DecoderUnsafe {
-        assert(alphabet_chars.len == 64);
-        var result = Base64DecoderUnsafe{
-            .char_to_index = undefined,
-            .pad_char = pad_char,
-        };
-        for (alphabet_chars) |c, i| {
-            assert(c != pad_char);
-            result.char_to_index[c] = @intCast(u8, i);
+        if (acc_len > 4 or (acc & (@as(u12, 1) << acc_len) - 1) != 0) {
+            return error.InvalidPadding;
         }
-        return result;
-    }
-
-    /// The source buffer must be valid.
-    pub fn calcSize(decoder: *const Base64DecoderUnsafe, source: []const u8) usize {
-        return calcDecodedSizeExactUnsafe(source, decoder.pad_char);
-    }
-
-    /// dest.len must be what you get from ::calcDecodedSizeExactUnsafe.
-    /// invalid characters or padding will result in undefined values.
-    pub fn decode(decoder: *const Base64DecoderUnsafe, dest: []u8, source: []const u8) void {
-        assert(dest.len == decoder.calcSize(source));
-
-        var src_index: usize = 0;
-        var dest_index: usize = 0;
-        var in_buf_len: usize = source.len;
-
-        while (in_buf_len > 0 and source[in_buf_len - 1] == decoder.pad_char) {
-            in_buf_len -= 1;
+        const padding_len = acc_len / 2;
+        if (leftover_idx == null) {
+            if (decoder.pad_char != null and padding_len != 0) return error.InvalidPadding;
+            return dest_idx;
         }
-
-        while (in_buf_len > 4) {
-            dest[dest_index] = decoder.char_to_index[source[src_index + 0]] << 2 | decoder.char_to_index[source[src_index + 1]] >> 4;
-            dest_index += 1;
-
-            dest[dest_index] = decoder.char_to_index[source[src_index + 1]] << 4 | decoder.char_to_index[source[src_index + 2]] >> 2;
-            dest_index += 1;
-
-            dest[dest_index] = decoder.char_to_index[source[src_index + 2]] << 6 | decoder.char_to_index[source[src_index + 3]];
-            dest_index += 1;
-
-            src_index += 4;
-            in_buf_len -= 4;
-        }
-
-        if (in_buf_len > 1) {
-            dest[dest_index] = decoder.char_to_index[source[src_index + 0]] << 2 | decoder.char_to_index[source[src_index + 1]] >> 4;
-            dest_index += 1;
-        }
-        if (in_buf_len > 2) {
-            dest[dest_index] = decoder.char_to_index[source[src_index + 1]] << 4 | decoder.char_to_index[source[src_index + 2]] >> 2;
-            dest_index += 1;
-        }
-        if (in_buf_len > 3) {
-            dest[dest_index] = decoder.char_to_index[source[src_index + 2]] << 6 | decoder.char_to_index[source[src_index + 3]];
-            dest_index += 1;
+        var leftover = source[leftover_idx.?..];
+        if (decoder.pad_char) |pad_char| {
+            var padding_chars: usize = 0;
+            var i: usize = 0;
+            for (leftover) |c| {
+                if (decoder_with_ignore.char_is_ignored[c]) continue;
+                if (c != pad_char) {
+                    return if (c == Base64Decoder.invalid_char) error.InvalidCharacter else error.InvalidPadding;
+                }
+                padding_chars += 1;
+            }
+            if (padding_chars != padding_len) return error.InvalidPadding;
         }
+        return dest_idx;
     }
 };
 
-fn calcDecodedSizeExactUnsafe(source: []const u8, pad_char: u8) usize {
-    if (source.len == 0) return 0;
-    var result = @divExact(source.len, 4) * 3;
-    if (source[source.len - 1] == pad_char) {
-        result -= 1;
-        if (source[source.len - 2] == pad_char) {
-            result -= 1;
-        }
-    }
-    return result;
-}
-
 test "base64" {
     @setEvalBranchQuota(8000);
     testBase64() catch unreachable;
-    comptime (testBase64() catch unreachable);
+    comptime testAllApis(standard, "comptime", "Y29tcHRpbWU=") catch unreachable;
+}
+
+test "base64 url_safe_no_pad" {
+    @setEvalBranchQuota(8000);
+    testBase64UrlSafeNoPad() catch unreachable;
+    comptime testAllApis(url_safe_no_pad, "comptime", "Y29tcHRpbWU") catch unreachable;
 }
 
 fn testBase64() !void {
-    try testAllApis("", "");
-    try testAllApis("f", "Zg==");
-    try testAllApis("fo", "Zm8=");
-    try testAllApis("foo", "Zm9v");
-    try testAllApis("foob", "Zm9vYg==");
-    try testAllApis("fooba", "Zm9vYmE=");
-    try testAllApis("foobar", "Zm9vYmFy");
-
-    try testDecodeIgnoreSpace("", " ");
-    try testDecodeIgnoreSpace("f", "Z g= =");
-    try testDecodeIgnoreSpace("fo", "    Zm8=");
-    try testDecodeIgnoreSpace("foo", "Zm9v    ");
-    try testDecodeIgnoreSpace("foob", "Zm9vYg = = ");
-    try testDecodeIgnoreSpace("fooba", "Zm9v YmE=");
-    try testDecodeIgnoreSpace("foobar", " Z m 9 v Y m F y ");
+    const codecs = standard;
+
+    try testAllApis(codecs, "", "");
+    try testAllApis(codecs, "f", "Zg==");
+    try testAllApis(codecs, "fo", "Zm8=");
+    try testAllApis(codecs, "foo", "Zm9v");
+    try testAllApis(codecs, "foob", "Zm9vYg==");
+    try testAllApis(codecs, "fooba", "Zm9vYmE=");
+    try testAllApis(codecs, "foobar", "Zm9vYmFy");
+
+    try testDecodeIgnoreSpace(codecs, "", " ");
+    try testDecodeIgnoreSpace(codecs, "f", "Z g= =");
+    try testDecodeIgnoreSpace(codecs, "fo", "    Zm8=");
+    try testDecodeIgnoreSpace(codecs, "foo", "Zm9v    ");
+    try testDecodeIgnoreSpace(codecs, "foob", "Zm9vYg = = ");
+    try testDecodeIgnoreSpace(codecs, "fooba", "Zm9v YmE=");
+    try testDecodeIgnoreSpace(codecs, "foobar", " Z m 9 v Y m F y ");
+
+    // test getting some api errors
+    try testError(codecs, "A", error.InvalidPadding);
+    try testError(codecs, "AA", error.InvalidPadding);
+    try testError(codecs, "AAA", error.InvalidPadding);
+    try testError(codecs, "A..A", error.InvalidCharacter);
+    try testError(codecs, "AA=A", error.InvalidPadding);
+    try testError(codecs, "AA/=", error.InvalidPadding);
+    try testError(codecs, "A/==", error.InvalidPadding);
+    try testError(codecs, "A===", error.InvalidPadding);
+    try testError(codecs, "====", error.InvalidPadding);
+
+    try testNoSpaceLeftError(codecs, "AA==");
+    try testNoSpaceLeftError(codecs, "AAA=");
+    try testNoSpaceLeftError(codecs, "AAAA");
+    try testNoSpaceLeftError(codecs, "AAAAAA==");
+}
+
+fn testBase64UrlSafeNoPad() !void {
+    const codecs = url_safe_no_pad;
+
+    try testAllApis(codecs, "", "");
+    try testAllApis(codecs, "f", "Zg");
+    try testAllApis(codecs, "fo", "Zm8");
+    try testAllApis(codecs, "foo", "Zm9v");
+    try testAllApis(codecs, "foob", "Zm9vYg");
+    try testAllApis(codecs, "fooba", "Zm9vYmE");
+    try testAllApis(codecs, "foobar", "Zm9vYmFy");
+
+    try testDecodeIgnoreSpace(codecs, "", " ");
+    try testDecodeIgnoreSpace(codecs, "f", "Z g ");
+    try testDecodeIgnoreSpace(codecs, "fo", "    Zm8");
+    try testDecodeIgnoreSpace(codecs, "foo", "Zm9v    ");
+    try testDecodeIgnoreSpace(codecs, "foob", "Zm9vYg   ");
+    try testDecodeIgnoreSpace(codecs, "fooba", "Zm9v YmE");
+    try testDecodeIgnoreSpace(codecs, "foobar", " Z m 9 v Y m F y ");
 
     // test getting some api errors
-    try testError("A", error.InvalidPadding);
-    try testError("AA", error.InvalidPadding);
-    try testError("AAA", error.InvalidPadding);
-    try testError("A..A", error.InvalidCharacter);
-    try testError("AA=A", error.InvalidCharacter);
-    try testError("AA/=", error.InvalidPadding);
-    try testError("A/==", error.InvalidPadding);
-    try testError("A===", error.InvalidCharacter);
-    try testError("====", error.InvalidCharacter);
-
-    try testOutputTooSmallError("AA==");
-    try testOutputTooSmallError("AAA=");
-    try testOutputTooSmallError("AAAA");
-    try testOutputTooSmallError("AAAAAA==");
+    try testError(codecs, "A", error.InvalidPadding);
+    try testError(codecs, "AAA=", error.InvalidCharacter);
+    try testError(codecs, "A..A", error.InvalidCharacter);
+    try testError(codecs, "AA=A", error.InvalidCharacter);
+    try testError(codecs, "AA/=", error.InvalidCharacter);
+    try testError(codecs, "A/==", error.InvalidCharacter);
+    try testError(codecs, "A===", error.InvalidCharacter);
+    try testError(codecs, "====", error.InvalidCharacter);
+
+    try testNoSpaceLeftError(codecs, "AA");
+    try testNoSpaceLeftError(codecs, "AAA");
+    try testNoSpaceLeftError(codecs, "AAAA");
+    try testNoSpaceLeftError(codecs, "AAAAAA");
 }
 
-fn testAllApis(expected_decoded: []const u8, expected_encoded: []const u8) !void {
+fn testAllApis(codecs: Codecs, expected_decoded: []const u8, expected_encoded: []const u8) !void {
     // Base64Encoder
     {
         var buffer: [0x100]u8 = undefined;
-        const encoded = standard_encoder.encode(&buffer, expected_decoded);
+        const encoded = codecs.Encoder.encode(&buffer, expected_decoded);
         testing.expectEqualSlices(u8, expected_encoded, encoded);
     }
 
     // Base64Decoder
     {
         var buffer: [0x100]u8 = undefined;
-        var decoded = buffer[0..try standard_decoder.calcSize(expected_encoded)];
-        try standard_decoder.decode(decoded, expected_encoded);
+        var decoded = buffer[0..try codecs.Decoder.calcSizeForSlice(expected_encoded)];
+        try codecs.Decoder.decode(decoded, expected_encoded);
         testing.expectEqualSlices(u8, expected_decoded, decoded);
     }
 
     // Base64DecoderWithIgnore
     {
-        const standard_decoder_ignore_nothing = Base64DecoderWithIgnore.init(standard_alphabet_chars, standard_pad_char, "");
+        const decoder_ignore_nothing = codecs.decoderWithIgnore("");
         var buffer: [0x100]u8 = undefined;
-        var decoded = buffer[0..Base64DecoderWithIgnore.calcSizeUpperBound(expected_encoded.len)];
-        var written = try standard_decoder_ignore_nothing.decode(decoded, expected_encoded);
+        var decoded = buffer[0..try decoder_ignore_nothing.calcSizeUpperBound(expected_encoded.len)];
+        var written = try decoder_ignore_nothing.decode(decoded, expected_encoded);
         testing.expect(written <= decoded.len);
         testing.expectEqualSlices(u8, expected_decoded, decoded[0..written]);
     }
-
-    // Base64DecoderUnsafe
-    {
-        var buffer: [0x100]u8 = undefined;
-        var decoded = buffer[0..standard_decoder_unsafe.calcSize(expected_encoded)];
-        standard_decoder_unsafe.decode(decoded, expected_encoded);
-        testing.expectEqualSlices(u8, expected_decoded, decoded);
-    }
 }
 
-fn testDecodeIgnoreSpace(expected_decoded: []const u8, encoded: []const u8) !void {
-    const standard_decoder_ignore_space = Base64DecoderWithIgnore.init(standard_alphabet_chars, standard_pad_char, " ");
+fn testDecodeIgnoreSpace(codecs: Codecs, expected_decoded: []const u8, encoded: []const u8) !void {
+    const decoder_ignore_space = codecs.decoderWithIgnore(" ");
     var buffer: [0x100]u8 = undefined;
-    var decoded = buffer[0..Base64DecoderWithIgnore.calcSizeUpperBound(encoded.len)];
-    var written = try standard_decoder_ignore_space.decode(decoded, encoded);
+    var decoded = buffer[0..try decoder_ignore_space.calcSizeUpperBound(encoded.len)];
+    var written = try decoder_ignore_space.decode(decoded, encoded);
     testing.expectEqualSlices(u8, expected_decoded, decoded[0..written]);
 }
 
-fn testError(encoded: []const u8, expected_err: anyerror) !void {
-    const standard_decoder_ignore_space = Base64DecoderWithIgnore.init(standard_alphabet_chars, standard_pad_char, " ");
+fn testError(codecs: Codecs, encoded: []const u8, expected_err: anyerror) !void {
+    const decoder_ignore_space = codecs.decoderWithIgnore(" ");
     var buffer: [0x100]u8 = undefined;
-    if (standard_decoder.calcSize(encoded)) |decoded_size| {
+    if (codecs.Decoder.calcSizeForSlice(encoded)) |decoded_size| {
         var decoded = buffer[0..decoded_size];
-        if (standard_decoder.decode(decoded, encoded)) |_| {
+        if (codecs.Decoder.decode(decoded, encoded)) |_| {
             return error.ExpectedError;
         } else |err| if (err != expected_err) return err;
     } else |err| if (err != expected_err) return err;
 
-    if (standard_decoder_ignore_space.decode(buffer[0..], encoded)) |_| {
+    if (decoder_ignore_space.decode(buffer[0..], encoded)) |_| {
         return error.ExpectedError;
     } else |err| if (err != expected_err) return err;
 }
 
-fn testOutputTooSmallError(encoded: []const u8) !void {
-    const standard_decoder_ignore_space = Base64DecoderWithIgnore.init(standard_alphabet_chars, standard_pad_char, " ");
+fn testNoSpaceLeftError(codecs: Codecs, encoded: []const u8) !void {
+    const decoder_ignore_space = codecs.decoderWithIgnore(" ");
     var buffer: [0x100]u8 = undefined;
-    var decoded = buffer[0 .. calcDecodedSizeExactUnsafe(encoded, standard_pad_char) - 1];
-    if (standard_decoder_ignore_space.decode(decoded, encoded)) |_| {
+    var decoded = buffer[0 .. (try codecs.Decoder.calcSizeForSlice(encoded)) - 1];
+    if (decoder_ignore_space.decode(decoded, encoded)) |_| {
         return error.ExpectedError;
-    } else |err| if (err != error.OutputTooSmall) return err;
+    } else |err| if (err != error.NoSpaceLeft) return err;
 }
diff --git a/lib/std/build.zig b/lib/std/build.zig
index efeea4adb7..825312755f 100644
--- a/lib/std/build.zig
+++ b/lib/std/build.zig
@@ -51,7 +51,7 @@ pub const Builder = struct {
     default_step: *Step,
     env_map: *BufMap,
     top_level_steps: ArrayList(*TopLevelStep),
-    install_prefix: ?[]const u8,
+    install_prefix: []const u8,
     dest_dir: ?[]const u8,
     lib_dir: []const u8,
     exe_dir: []const u8,
@@ -156,7 +156,7 @@ pub const Builder = struct {
             .default_step = undefined,
             .env_map = env_map,
             .search_prefixes = ArrayList([]const u8).init(allocator),
-            .install_prefix = null,
+            .install_prefix = undefined,
             .lib_dir = undefined,
             .exe_dir = undefined,
             .h_dir = undefined,
@@ -190,22 +190,13 @@ pub const Builder = struct {
     }
 
     /// This function is intended to be called by std/special/build_runner.zig, not a build.zig file.
-    pub fn setInstallPrefix(self: *Builder, optional_prefix: ?[]const u8) void {
-        self.install_prefix = optional_prefix;
-    }
-
-    /// This function is intended to be called by std/special/build_runner.zig, not a build.zig file.
-    pub fn resolveInstallPrefix(self: *Builder) void {
+    pub fn resolveInstallPrefix(self: *Builder, install_prefix: ?[]const u8) void {
         if (self.dest_dir) |dest_dir| {
-            const install_prefix = self.install_prefix orelse "/usr";
-            self.install_path = fs.path.join(self.allocator, &[_][]const u8{ dest_dir, install_prefix }) catch unreachable;
+            self.install_prefix = install_prefix orelse "/usr";
+            self.install_path = fs.path.join(self.allocator, &[_][]const u8{ dest_dir, self.install_prefix }) catch unreachable;
         } else {
-            const install_prefix = self.install_prefix orelse blk: {
-                const p = self.cache_root;
-                self.install_prefix = p;
-                break :blk p;
-            };
-            self.install_path = install_prefix;
+            self.install_prefix = install_prefix orelse self.cache_root;
+            self.install_path = self.install_prefix;
         }
         self.lib_dir = fs.path.join(self.allocator, &[_][]const u8{ self.install_path, "lib" }) catch unreachable;
         self.exe_dir = fs.path.join(self.allocator, &[_][]const u8{ self.install_path, "bin" }) catch unreachable;
diff --git a/lib/std/fmt.zig b/lib/std/fmt.zig
index 90c0d98539..bfe28ef203 100644
--- a/lib/std/fmt.zig
+++ b/lib/std/fmt.zig
@@ -1250,9 +1250,9 @@ fn formatDuration(ns: u64, comptime fmt: []const u8, options: std.fmt.FormatOpti
         const kunits = ns_remaining * 1000 / unit.ns;
         if (kunits >= 1000) {
             try formatInt(kunits / 1000, 10, false, .{}, writer);
-            if (kunits > 1000) {
+            const frac = kunits % 1000;
+            if (frac > 0) {
                 // Write up to 3 decimal places
-                const frac = kunits % 1000;
                 var buf = [_]u8{ '.', 0, 0, 0 };
                 _ = formatIntBuf(buf[1..], frac, 10, false, .{ .fill = '0', .width = 3 });
                 var end: usize = 4;
@@ -1286,9 +1286,14 @@ test "fmtDuration" {
         .{ .s = "1us", .d = std.time.ns_per_us },
         .{ .s = "1.45us", .d = 1450 },
         .{ .s = "1.5us", .d = 3 * std.time.ns_per_us / 2 },
+        .{ .s = "14.5us", .d = 14500 },
+        .{ .s = "145us", .d = 145000 },
         .{ .s = "999.999us", .d = std.time.ns_per_ms - 1 },
         .{ .s = "1ms", .d = std.time.ns_per_ms + 1 },
         .{ .s = "1.5ms", .d = 3 * std.time.ns_per_ms / 2 },
+        .{ .s = "1.11ms", .d = 1110000 },
+        .{ .s = "1.111ms", .d = 1111000 },
+        .{ .s = "1.111ms", .d = 1111100 },
         .{ .s = "999.999ms", .d = std.time.ns_per_s - 1 },
         .{ .s = "1s", .d = std.time.ns_per_s },
         .{ .s = "59.999s", .d = std.time.ns_per_min - 1 },
diff --git a/lib/std/fs.zig b/lib/std/fs.zig
index 79385708af..1a02cd5b6b 100644
--- a/lib/std/fs.zig
+++ b/lib/std/fs.zig
@@ -50,13 +50,13 @@ pub const MAX_PATH_BYTES = switch (builtin.os.tag) {
     else => @compileError("Unsupported OS"),
 };
 
-pub const base64_alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+pub const base64_alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_".*;
 
 /// Base64 encoder, replacing the standard `+/` with `-_` so that it can be used in a file name on any filesystem.
-pub const base64_encoder = base64.Base64Encoder.init(base64_alphabet, base64.standard_pad_char);
+pub const base64_encoder = base64.Base64Encoder.init(base64_alphabet, null);
 
 /// Base64 decoder, replacing the standard `+/` with `-_` so that it can be used in a file name on any filesystem.
-pub const base64_decoder = base64.Base64Decoder.init(base64_alphabet, base64.standard_pad_char);
+pub const base64_decoder = base64.Base64Decoder.init(base64_alphabet, null);
 
 /// Whether or not async file system syscalls need a dedicated thread because the operating
 /// system does not support non-blocking I/O on the file system.
@@ -77,7 +77,7 @@ pub fn atomicSymLink(allocator: *Allocator, existing_path: []const u8, new_path:
     const dirname = path.dirname(new_path) orelse ".";
 
     var rand_buf: [AtomicFile.RANDOM_BYTES]u8 = undefined;
-    const tmp_path = try allocator.alloc(u8, dirname.len + 1 + base64.Base64Encoder.calcSize(rand_buf.len));
+    const tmp_path = try allocator.alloc(u8, dirname.len + 1 + base64_encoder.calcSize(rand_buf.len));
     defer allocator.free(tmp_path);
     mem.copy(u8, tmp_path[0..], dirname);
     tmp_path[dirname.len] = path.sep;
@@ -142,7 +142,7 @@ pub const AtomicFile = struct {
     const InitError = File.OpenError;
 
     const RANDOM_BYTES = 12;
-    const TMP_PATH_LEN = base64.Base64Encoder.calcSize(RANDOM_BYTES);
+    const TMP_PATH_LEN = base64_encoder.calcSize(RANDOM_BYTES);
 
     /// Note that the `Dir.atomicFile` API may be more handy than this lower-level function.
     pub fn init(
diff --git a/lib/std/hash/auto_hash.zig b/lib/std/hash/auto_hash.zig
index 4afc2b425b..e053e87efb 100644
--- a/lib/std/hash/auto_hash.zig
+++ b/lib/std/hash/auto_hash.zig
@@ -95,7 +95,7 @@ pub fn hash(hasher: anytype, key: anytype, comptime strat: HashStrategy) void {
         .EnumLiteral,
         .Frame,
         .Float,
-        => @compileError("cannot hash this type"),
+        => @compileError("unable to hash type " ++ @typeName(Key)),
 
         // Help the optimizer see that hashing an int is easy by inlining!
         // TODO Check if the situation is better after #561 is resolved.
diff --git a/lib/std/mem.zig b/lib/std/mem.zig
index 2bd5fdac7b..66505f5d29 100644
--- a/lib/std/mem.zig
+++ b/lib/std/mem.zig
@@ -1373,6 +1373,20 @@ test "mem.tokenize (multibyte)" {
     testing.expect(it.next() == null);
 }
 
+test "mem.tokenize (reset)" {
+    var it = tokenize("   abc def   ghi  ", " ");
+    testing.expect(eql(u8, it.next().?, "abc"));
+    testing.expect(eql(u8, it.next().?, "def"));
+    testing.expect(eql(u8, it.next().?, "ghi"));
+
+    it.reset();
+
+    testing.expect(eql(u8, it.next().?, "abc"));
+    testing.expect(eql(u8, it.next().?, "def"));
+    testing.expect(eql(u8, it.next().?, "ghi"));
+    testing.expect(it.next() == null);
+}
+
 /// Returns an iterator that iterates over the slices of `buffer` that
 /// are separated by bytes in `delimiter`.
 /// split("abc|def||ghi", "|")
@@ -1471,6 +1485,11 @@ pub const TokenIterator = struct {
         return self.buffer[index..];
     }
 
+    /// Resets the iterator to the initial token.
+    pub fn reset(self: *TokenIterator) void {
+        self.index = 0;
+    }
+
     fn isSplitByte(self: TokenIterator, byte: u8) bool {
         for (self.delimiter_bytes) |delimiter_byte| {
             if (byte == delimiter_byte) {
diff --git a/lib/std/os.zig b/lib/std/os.zig
index 8b552d05a7..9d9fd872a8 100644
--- a/lib/std/os.zig
+++ b/lib/std/os.zig
@@ -5610,6 +5610,7 @@ pub fn recvfrom(
                 EAGAIN => return error.WouldBlock,
                 ENOMEM => return error.SystemResources,
                 ECONNREFUSED => return error.ConnectionRefused,
+                ECONNRESET => return error.ConnectionResetByPeer,
                 else => |err| return unexpectedErrno(err),
             }
         }
diff --git a/lib/std/os/linux/mips.zig b/lib/std/os/linux/mips.zig
index 2622628533..ddb3103cfa 100644
--- a/lib/std/os/linux/mips.zig
+++ b/lib/std/os/linux/mips.zig
@@ -115,6 +115,9 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
     );
 }
 
+// NOTE: The o32 calling convention requires the callee to reserve 16 bytes for
+// the first four arguments even though they're passed in $a0-$a3.
+
 pub fn syscall6(
     number: SYS,
     arg1: usize,
@@ -146,6 +149,40 @@ pub fn syscall6(
     );
 }
 
+pub fn syscall7(
+    number: SYS,
+    arg1: usize,
+    arg2: usize,
+    arg3: usize,
+    arg4: usize,
+    arg5: usize,
+    arg6: usize,
+    arg7: usize,
+) usize {
+    return asm volatile (
+        \\ .set noat
+        \\ subu $sp, $sp, 32
+        \\ sw %[arg5], 16($sp)
+        \\ sw %[arg6], 20($sp)
+        \\ sw %[arg7], 24($sp)
+        \\ syscall
+        \\ addu $sp, $sp, 32
+        \\ blez $7, 1f
+        \\ subu $2, $0, $2
+        \\ 1:
+        : [ret] "={$2}" (-> usize)
+        : [number] "{$2}" (@enumToInt(number)),
+          [arg1] "{$4}" (arg1),
+          [arg2] "{$5}" (arg2),
+          [arg3] "{$6}" (arg3),
+          [arg4] "{$7}" (arg4),
+          [arg5] "r" (arg5),
+          [arg6] "r" (arg6),
+          [arg7] "r" (arg7)
+        : "memory", "cc", "$7"
+    );
+}
+
 /// This matches the libc clone function.
 pub extern fn clone(func: fn (arg: usize) callconv(.C) u8, stack: usize, flags: u32, arg: usize, ptid: *i32, tls: usize, ctid: *i32) usize;
 
diff --git a/lib/std/os/uefi/tables/boot_services.zig b/lib/std/os/uefi/tables/boot_services.zig
index b96881fcc2..2b3e896960 100644
--- a/lib/std/os/uefi/tables/boot_services.zig
+++ b/lib/std/os/uefi/tables/boot_services.zig
@@ -78,7 +78,8 @@ pub const BootServices = extern struct {
     /// Returns an array of handles that support a specified protocol.
     locateHandle: fn (LocateSearchType, ?*align(8) const Guid, ?*const c_void, *usize, [*]Handle) callconv(.C) Status,
 
-    locateDevicePath: Status, // TODO
+    /// Locates the handle to a device on the device path that supports the specified protocol
+    locateDevicePath: fn (*align(8) const Guid, **const DevicePathProtocol, *?Handle) callconv(.C) Status,
     installConfigurationTable: Status, // TODO
 
     /// Loads an EFI image into memory.
diff --git a/lib/std/os/windows/user32.zig b/lib/std/os/windows/user32.zig
index 186a1af59f..9a058f35c0 100644
--- a/lib/std/os/windows/user32.zig
+++ b/lib/std/os/windows/user32.zig
@@ -373,7 +373,7 @@ pub fn createWindowExA(dwExStyle: u32, lpClassName: [*:0]const u8, lpWindowName:
 }
 
 pub extern "user32" fn CreateWindowExW(dwExStyle: DWORD, lpClassName: [*:0]const u16, lpWindowName: [*:0]const u16, dwStyle: DWORD, X: i32, Y: i32, nWidth: i32, nHeight: i32, hWindParent: ?HWND, hMenu: ?HMENU, hInstance: HINSTANCE, lpParam: ?LPVOID) callconv(WINAPI) ?HWND;
-pub var pfnCreateWindowExW: @TypeOf(RegisterClassExW) = undefined;
+pub var pfnCreateWindowExW: @TypeOf(CreateWindowExW) = undefined;
 pub fn createWindowExW(dwExStyle: u32, lpClassName: [*:0]const u16, lpWindowName: [*:0]const u16, dwStyle: u32, X: i32, Y: i32, nWidth: i32, nHeight: i32, hWindParent: ?HWND, hMenu: ?HMENU, hInstance: HINSTANCE, lpParam: ?*c_void) !HWND {
     const function = selectSymbol(CreateWindowExW, pfnCreateWindowExW, .win2k);
     const window = function(dwExStyle, lpClassName, lpWindowName, dwStyle, X, Y, nWidth, nHeight, hWindParent, hMenu, hInstance, lpParam);
diff --git a/lib/std/special/build_runner.zig b/lib/std/special/build_runner.zig
index 0b7baf0fc1..70aa3c8dc6 100644
--- a/lib/std/special/build_runner.zig
+++ b/lib/std/special/build_runner.zig
@@ -60,6 +60,7 @@ pub fn main() !void {
     const stderr_stream = io.getStdErr().writer();
     const stdout_stream = io.getStdOut().writer();
 
+    var install_prefix: ?[]const u8 = null;
     while (nextArg(args, &arg_idx)) |arg| {
         if (mem.startsWith(u8, arg, "-D")) {
             const option_contents = arg[2..];
@@ -82,7 +83,7 @@ pub fn main() !void {
             } else if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {
                 return usage(builder, false, stdout_stream);
             } else if (mem.eql(u8, arg, "--prefix")) {
-                builder.install_prefix = nextArg(args, &arg_idx) orelse {
+                install_prefix = nextArg(args, &arg_idx) orelse {
                     warn("Expected argument after --prefix\n\n", .{});
                     return usageAndErr(builder, false, stderr_stream);
                 };
@@ -134,7 +135,7 @@ pub fn main() !void {
         }
     }
 
-    builder.resolveInstallPrefix();
+    builder.resolveInstallPrefix(install_prefix);
     try runBuild(builder);
 
     if (builder.validateUserInputDidItFail())
@@ -162,8 +163,7 @@ fn runBuild(builder: *Builder) anyerror!void {
 fn usage(builder: *Builder, already_ran_build: bool, out_stream: anytype) !void {
     // run the build script to collect the options
     if (!already_ran_build) {
-        builder.setInstallPrefix(null);
-        builder.resolveInstallPrefix();
+        builder.resolveInstallPrefix(null);
         try runBuild(builder);
     }
 
diff --git a/lib/std/testing.zig b/lib/std/testing.zig
index 67831c92fb..eb2b6e87b3 100644
--- a/lib/std/testing.zig
+++ b/lib/std/testing.zig
@@ -298,7 +298,7 @@ pub const TmpDir = struct {
     sub_path: [sub_path_len]u8,
 
     const random_bytes_count = 12;
-    const sub_path_len = std.base64.Base64Encoder.calcSize(random_bytes_count);
+    const sub_path_len = std.fs.base64_encoder.calcSize(random_bytes_count);
 
     pub fn cleanup(self: *TmpDir) void {
         self.dir.close();