From 48d60834fd61404ea009f7f970775f9c59de1240 Mon Sep 17 00:00:00 2001 From: tgschultz Date: Mon, 16 Nov 2020 17:51:54 -0600 Subject: [PATCH] Move leb128 and remove trivial *mem functions as discussed in #5588 (#6876) * Move leb128 out of debug and remove trivial *mem functions as discussed in #5588 * Turns out one of the *Mem functions was used by MachO. Replaced with trivial use of FixedBufferStream. --- lib/std/debug.zig | 7 ---- lib/std/dwarf.zig | 2 +- lib/std/{debug => }/leb128.zig | 67 ---------------------------------- lib/std/std.zig | 1 + src/codegen.zig | 2 +- src/codegen/wasm.zig | 2 +- src/link/Elf.zig | 2 +- src/link/MachO/Trie.zig | 19 ++++++---- src/link/Wasm.zig | 2 +- 9 files changed, 17 insertions(+), 87 deletions(-) rename lib/std/{debug => }/leb128.zig (85%) diff --git a/lib/std/debug.zig b/lib/std/debug.zig index bb769a03c1..a135dde0ff 100644 --- a/lib/std/debug.zig +++ b/lib/std/debug.zig @@ -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; -} diff --git a/lib/std/dwarf.zig b/lib/std/dwarf.zig index 37b76b1c14..1677f0a04c 100644 --- a/lib/std/dwarf.zig +++ b/lib/std/dwarf.zig @@ -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; diff --git a/lib/std/debug/leb128.zig b/lib/std/leb128.zig similarity index 85% rename from lib/std/debug/leb128.zig rename to lib/std/leb128.zig index 7b3532c2b9..2fa5776e1f 100644 --- a/lib/std/debug/leb128.zig +++ b/lib/std/leb128.zig @@ -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" { diff --git a/lib/std/std.zig b/lib/std/std.zig index 5386e2e037..6d748daafc 100644 --- a/lib/std/std.zig +++ b/lib/std/std.zig @@ -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"); diff --git a/src/codegen.zig b/src/codegen.zig index 53d065d26c..804a9b2029 100644 --- a/src/codegen.zig +++ b/src/codegen.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. diff --git a/src/codegen/wasm.zig b/src/codegen/wasm.zig index 4ea8838409..7297ea1d54 100644 --- a/src/codegen/wasm.zig +++ b/src/codegen/wasm.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"); diff --git a/src/link/Elf.zig b/src/link/Elf.zig index 7d4662c68d..94a946c3c7 100644 --- a/src/link/Elf.zig +++ b/src/link/Elf.zig @@ -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"); diff --git a/src/link/MachO/Trie.zig b/src/link/MachO/Trie.zig index e077df101d..34ce4e99b9 100644 --- a/src/link/MachO/Trie.zig +++ b/src/link/MachO/Trie.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]); } } diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig index 2ab757461c..bf6b34ed76 100644 --- a/src/link/Wasm.zig +++ b/src/link/Wasm.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");