Commit 48d60834fd

@@ -22,8 +22,6 @@ const maxInt = std.math.maxInt;
 const File = std.fs.File;
 const windows = std.os.windows;
 
-pub const leb = @import("debug/leb128.zig");
-
 pub const runtime_safety = switch (builtin.mode) {
     .Debug, .ReleaseSafe => true,
     .ReleaseFast, .ReleaseSmall => false,
@@ -1843,8 +1841,3 @@ pub fn dumpStackPointerAddr(prefix: []const u8) void {
     );
     std.debug.warn("{} sp = 0x{x}\n", .{ prefix, sp });
 }
-
-// Reference everything so it gets tested.
-test "" {
-    _ = leb;
-}

@@ -10,7 +10,7 @@ const fs = std.fs;
 const io = std.io;
 const mem = std.mem;
 const math = std.math;
-const leb = @import("debug/leb128.zig");
+const leb = @import("leb128.zig");
 
 const ArrayList = std.ArrayList;
 

@@ -55,25 +55,6 @@ pub fn writeULEB128(writer: anytype, uint_value: anytype) !void {
     }
 }
 
-/// Read a single unsigned integer from the given memory as type T.
-/// The provided slice reference will be updated to point to the byte after the last byte read.
-pub fn readULEB128Mem(comptime T: type, ptr: *[]const u8) !T {
-    var buf = std.io.fixedBufferStream(ptr.*);
-    const value = try readULEB128(T, buf.reader());
-    ptr.*.ptr += buf.pos;
-    return value;
-}
-
-/// Write a single unsigned LEB128 integer to the given memory as unsigned LEB128,
-/// returning the number of bytes written.
-pub fn writeULEB128Mem(ptr: []u8, uint_value: anytype) !usize {
-    const T = @TypeOf(uint_value);
-    const max_group = (@typeInfo(T).Int.bits + 6) / 7;
-    var buf = std.io.fixedBufferStream(ptr);
-    try writeULEB128(buf.writer(), uint_value);
-    return buf.pos;
-}
-
 /// Read a single signed LEB128 value from the given reader as type T,
 /// or error.Overflow if the value cannot fit.
 pub fn readILEB128(comptime T: type, reader: anytype) !T {
@@ -146,24 +127,6 @@ pub fn writeILEB128(writer: anytype, int_value: anytype) !void {
     }
 }
 
-/// Read a single singed LEB128 integer from the given memory as type T.
-/// The provided slice reference will be updated to point to the byte after the last byte read.
-pub fn readILEB128Mem(comptime T: type, ptr: *[]const u8) !T {
-    var buf = std.io.fixedBufferStream(ptr.*);
-    const value = try readILEB128(T, buf.reader());
-    ptr.*.ptr += buf.pos;
-    return value;
-}
-
-/// Write a single signed LEB128 integer to the given memory as unsigned LEB128,
-/// returning the number of bytes written.
-pub fn writeILEB128Mem(ptr: []u8, int_value: anytype) !usize {
-    const T = @TypeOf(int_value);
-    var buf = std.io.fixedBufferStream(ptr);
-    try writeILEB128(buf.writer(), int_value);
-    return buf.pos;
-}
-
 /// This is an "advanced" function. It allows one to use a fixed amount of memory to store a
 /// ULEB128. This defeats the entire purpose of using this data encoding; it will no longer use
 /// fewer bytes to store smaller numbers. The advantage of using a fixed width is that it makes
@@ -222,40 +185,28 @@ fn test_read_stream_uleb128(comptime T: type, encoded: []const u8) !T {
 fn test_read_ileb128(comptime T: type, encoded: []const u8) !T {
     var reader = std.io.fixedBufferStream(encoded);
     const v1 = try readILEB128(T, reader.reader());
-    var in_ptr = encoded;
-    const v2 = try readILEB128Mem(T, &in_ptr);
-    testing.expectEqual(v1, v2);
     return v1;
 }
 
 fn test_read_uleb128(comptime T: type, encoded: []const u8) !T {
     var reader = std.io.fixedBufferStream(encoded);
     const v1 = try readULEB128(T, reader.reader());
-    var in_ptr = encoded;
-    const v2 = try readULEB128Mem(T, &in_ptr);
-    testing.expectEqual(v1, v2);
     return v1;
 }
 
 fn test_read_ileb128_seq(comptime T: type, comptime N: usize, encoded: []const u8) !void {
     var reader = std.io.fixedBufferStream(encoded);
-    var in_ptr = encoded;
     var i: usize = 0;
     while (i < N) : (i += 1) {
         const v1 = try readILEB128(T, reader.reader());
-        const v2 = try readILEB128Mem(T, &in_ptr);
-        testing.expectEqual(v1, v2);
     }
 }
 
 fn test_read_uleb128_seq(comptime T: type, comptime N: usize, encoded: []const u8) !void {
     var reader = std.io.fixedBufferStream(encoded);
-    var in_ptr = encoded;
     var i: usize = 0;
     while (i < N) : (i += 1) {
         const v1 = try readULEB128(T, reader.reader());
-        const v2 = try readULEB128Mem(T, &in_ptr);
-        testing.expectEqual(v1, v2);
     }
 }
 
@@ -350,9 +301,7 @@ fn test_write_leb128(value: anytype) !void {
     const signedness = if (t_signed) .signed else .unsigned;
 
     const writeStream = if (t_signed) writeILEB128 else writeULEB128;
-    const writeMem = if (t_signed) writeILEB128Mem else writeULEB128Mem;
     const readStream = if (t_signed) readILEB128 else readULEB128;
-    const readMem = if (t_signed) readILEB128Mem else readULEB128Mem;
 
     // decode to a larger bit size too, to ensure sign extension
     // is working as expected
@@ -390,22 +339,6 @@ fn test_write_leb128(value: anytype) !void {
     const bsr = try readStream(B, fbs.reader());
     testing.expect(fbs.pos == w1_pos);
     testing.expect(bsr == value);
-
-    // mem write
-    const w2_pos = try writeMem(&buf, value);
-    testing.expect(w2_pos == w1_pos);
-
-    // mem read
-    var buf_ref: []u8 = buf[0..];
-    const mr = try readMem(T, &buf_ref);
-    testing.expect(@ptrToInt(buf_ref.ptr) - @ptrToInt(&buf) == w2_pos);
-    testing.expect(mr == value);
-
-    // bigger type mem read
-    buf_ref = buf[0..];
-    const bmr = try readMem(T, &buf_ref);
-    testing.expect(@ptrToInt(buf_ref.ptr) - @ptrToInt(&buf) == w2_pos);
-    testing.expect(bmr == value);
 }
 
 test "serialize unsigned LEB128" {

@@ -65,6 +65,7 @@ pub const hash_map = @import("hash_map.zig");
 pub const heap = @import("heap.zig");
 pub const io = @import("io.zig");
 pub const json = @import("json.zig");
+pub const leb = @import("leb128.zig");
 pub const log = @import("log.zig");
 pub const macho = @import("macho.zig");
 pub const math = @import("math.zig");

@@ -2,7 +2,7 @@ const std = @import("std");
 const Allocator = std.mem.Allocator;
 const ArrayList = std.ArrayList;
 const assert = std.debug.assert;
-const leb = std.debug.leb;
+const leb = std.leb;
 const mem = std.mem;
 
 const Module = @import("../Module.zig");

@@ -32,7 +32,7 @@ const Trie = @This();
 
 const std = @import("std");
 const mem = std.mem;
-const leb = std.debug.leb;
+const leb = std.leb;
 const log = std.log.scoped(.link);
 const testing = std.testing;
 const assert = std.debug.assert;
@@ -139,16 +139,18 @@ const Node = struct {
             // Terminal node info: encode export flags and vmaddr offset of this symbol.
             var info_buf_len: usize = 0;
             var info_buf: [@sizeOf(u64) * 2]u8 = undefined;
-            info_buf_len += try leb.writeULEB128Mem(info_buf[0..], self.export_flags.?);
-            info_buf_len += try leb.writeULEB128Mem(info_buf[info_buf_len..], offset);
+            var info_stream = std.io.fixedBufferStream(&info_buf);
+            try leb.writeULEB128(info_stream.writer(), self.export_flags.?);
+            try leb.writeULEB128(info_stream.writer(), offset);
 
             // Encode the size of the terminal node info.
             var size_buf: [@sizeOf(u64)]u8 = undefined;
-            const size_buf_len = try leb.writeULEB128Mem(size_buf[0..], info_buf_len);
+            var size_stream = std.io.fixedBufferStream(&size_buf);
+            try leb.writeULEB128(size_stream.writer(), info_stream.pos);
 
             // Now, write them to the output buffer.
-            buffer.appendSliceAssumeCapacity(size_buf[0..size_buf_len]);
-            buffer.appendSliceAssumeCapacity(info_buf[0..info_buf_len]);
+            buffer.appendSliceAssumeCapacity(size_buf[0..size_stream.pos]);
+            buffer.appendSliceAssumeCapacity(info_buf[0..info_stream.pos]);
         } else {
             // Non-terminal node is delimited by 0 byte.
             buffer.appendAssumeCapacity(0);
@@ -162,8 +164,9 @@ const Node = struct {
             buffer.appendAssumeCapacity(0);
 
             var buf: [@sizeOf(u64)]u8 = undefined;
-            const buf_len = try leb.writeULEB128Mem(buf[0..], edge.to.trie_offset.?);
-            buffer.appendSliceAssumeCapacity(buf[0..buf_len]);
+            var buf_stream = std.io.fixedBufferStream(&buf);
+            try leb.writeULEB128(buf_stream.writer(), edge.to.trie_offset.?);
+            buffer.appendSliceAssumeCapacity(buf[0..buf_stream.pos]);
         }
     }
 

@@ -8,7 +8,7 @@ const fs = std.fs;
 const elf = std.elf;
 const log = std.log.scoped(.link);
 const DW = std.dwarf;
-const leb128 = std.debug.leb;
+const leb128 = std.leb;
 
 const ir = @import("../ir.zig");
 const Module = @import("../Module.zig");

@@ -5,7 +5,7 @@ const mem = std.mem;
 const Allocator = std.mem.Allocator;
 const assert = std.debug.assert;
 const fs = std.fs;
-const leb = std.debug.leb;
+const leb = std.leb;
 const log = std.log.scoped(.link);
 
 const Module = @import("../Module.zig");

@@ -14,7 +14,7 @@ const Target = std.Target;
 const Allocator = mem.Allocator;
 const trace = @import("tracy.zig").trace;
 const DW = std.dwarf;
-const leb128 = std.debug.leb;
+const leb128 = std.leb;
 const log = std.log.scoped(.codegen);
 
 /// The codegen-related data that is stored in `ir.Inst.Block` instructions.