jimzah/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2024-12-03 18:38:45 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Move leb128 and remove trivial *mem functions as discussed in #5588 (#6876)

Browse Source 
* 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.
This commit is contained in:
tgschultz 2020-11-16 17:51:54 -06:00 committed by GitHub
parent d9c36cb250
commit 48d60834fd
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 17 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
lib/std/debug.zig
View File

@ -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;
}

2
lib/std/dwarf.zig
View File

@ -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;

67
lib/std/debug/leb128.zig → lib/std/leb128.zig
View File

@ -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" {

1
lib/std/std.zig
View File

@ -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
src/codegen.zig
View File

@ -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.

2
src/codegen/wasm.zig
View File

@ -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");

2
src/link/Elf.zig
View File

@ -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");

19
src/link/MachO/Trie.zig
View File

@ -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]);
}
}

2
src/link/Wasm.zig
View File

@ -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");