Commit f2ad3bcc1c
Changed files (6)
lib
std
src
codegen
lib/std/Build/Step/CheckObject.zig
@@ -1231,12 +1231,12 @@ const MachODumper = struct {
}
fn parseRebaseInfo(ctx: ObjectContext, data: []const u8, rebases: *std.ArrayList(u64)) !void {
- var br: std.io.Reader = .fixed(data);
+ var r: std.io.Reader = .fixed(data);
var seg_id: ?u8 = null;
var offset: u64 = 0;
while (true) {
- const byte = br.takeByte() catch break;
+ const byte = r.takeByte() catch break;
const opc = byte & macho.REBASE_OPCODE_MASK;
const imm = byte & macho.REBASE_IMMEDIATE_MASK;
switch (opc) {
@@ -1244,17 +1244,17 @@ const MachODumper = struct {
macho.REBASE_OPCODE_SET_TYPE_IMM => {},
macho.REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB => {
seg_id = imm;
- offset = try br.takeLeb128(u64);
+ offset = try r.takeLeb128(u64);
},
macho.REBASE_OPCODE_ADD_ADDR_IMM_SCALED => {
offset += imm * @sizeOf(u64);
},
macho.REBASE_OPCODE_ADD_ADDR_ULEB => {
- const addend = try br.takeLeb128(u64);
+ const addend = try r.takeLeb128(u64);
offset += addend;
},
macho.REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB => {
- const addend = try br.takeLeb128(u64);
+ const addend = try r.takeLeb128(u64);
const seg = ctx.segments.items[seg_id.?];
const addr = seg.vmaddr + offset;
try rebases.append(addr);
@@ -1271,11 +1271,11 @@ const MachODumper = struct {
ntimes = imm;
},
macho.REBASE_OPCODE_DO_REBASE_ULEB_TIMES => {
- ntimes = try br.takeLeb128(u64);
+ ntimes = try r.takeLeb128(u64);
},
macho.REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB => {
- ntimes = try br.takeLeb128(u64);
- skip = try br.takeLeb128(u64);
+ ntimes = try r.takeLeb128(u64);
+ skip = try r.takeLeb128(u64);
},
else => unreachable,
}
@@ -1341,7 +1341,7 @@ const MachODumper = struct {
}
fn parseBindInfo(ctx: ObjectContext, data: []const u8, bindings: *std.ArrayList(Binding)) !void {
- var br: std.io.Reader = .fixed(data);
+ var r: std.io.Reader = .fixed(data);
var seg_id: ?u8 = null;
var tag: Binding.Tag = .self;
@@ -1352,7 +1352,7 @@ const MachODumper = struct {
var name_buf: std.io.Writer.Allocating = .init(ctx.gpa);
defer name_buf.deinit();
- while (br.takeByte()) |byte| {
+ while (r.takeByte()) |byte| {
const opc = byte & macho.BIND_OPCODE_MASK;
const imm = byte & macho.BIND_IMMEDIATE_MASK;
switch (opc) {
@@ -1373,18 +1373,18 @@ const MachODumper = struct {
},
macho.BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB => {
seg_id = imm;
- offset = try br.takeLeb128(u64);
+ offset = try r.takeLeb128(u64);
},
macho.BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM => {
name_buf.clearRetainingCapacity();
- _ = try br.streamDelimiterLimit(&name_buf.writer, 0, .limited(std.math.maxInt(u32)));
+ _ = try r.streamDelimiterLimit(&name_buf.writer, 0, .limited(std.math.maxInt(u32)));
try name_buf.writer.writeByte(0);
},
macho.BIND_OPCODE_SET_ADDEND_SLEB => {
- addend = try br.takeLeb128(i64);
+ addend = try r.takeLeb128(i64);
},
macho.BIND_OPCODE_ADD_ADDR_ULEB => {
- const x = try br.takeLeb128(u64);
+ const x = try r.takeLeb128(u64);
offset = @intCast(@as(i64, @intCast(offset)) + @as(i64, @bitCast(x)));
},
macho.BIND_OPCODE_DO_BIND,
@@ -1399,14 +1399,14 @@ const MachODumper = struct {
switch (opc) {
macho.BIND_OPCODE_DO_BIND => {},
macho.BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB => {
- add_addr = try br.takeLeb128(u64);
+ add_addr = try r.takeLeb128(u64);
},
macho.BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED => {
add_addr = imm * @sizeOf(u64);
},
macho.BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB => {
- count = try br.takeLeb128(u64);
- skip = try br.takeLeb128(u64);
+ count = try r.takeLeb128(u64);
+ skip = try r.takeLeb128(u64);
},
else => unreachable,
}
@@ -1437,8 +1437,8 @@ const MachODumper = struct {
defer arena.deinit();
var exports: std.ArrayList(Export) = .init(arena.allocator());
- var br: std.io.Reader = .fixed(data);
- try parseTrieNode(arena.allocator(), &br, "", &exports);
+ var r: std.io.Reader = .fixed(data);
+ try parseTrieNode(arena.allocator(), &r, "", &exports);
mem.sort(Export, exports.items, {}, Export.lessThan);
@@ -1506,17 +1506,17 @@ const MachODumper = struct {
fn parseTrieNode(
arena: Allocator,
- br: *std.io.Reader,
+ r: *std.io.Reader,
prefix: []const u8,
exports: *std.ArrayList(Export),
) !void {
- const size = try br.takeLeb128(u64);
+ const size = try r.takeLeb128(u64);
if (size > 0) {
- const flags = try br.takeLeb128(u8);
+ const flags = try r.takeLeb128(u8);
switch (flags) {
macho.EXPORT_SYMBOL_FLAGS_REEXPORT => {
- const ord = try br.takeLeb128(u64);
- const name = try br.takeSentinel(0);
+ const ord = try r.takeLeb128(u64);
+ const name = try r.takeSentinel(0);
try exports.append(.{
.name = if (name.len > 0) name else prefix,
.tag = .reexport,
@@ -1524,8 +1524,8 @@ const MachODumper = struct {
});
},
macho.EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER => {
- const stub_offset = try br.takeLeb128(u64);
- const resolver_offset = try br.takeLeb128(u64);
+ const stub_offset = try r.takeLeb128(u64);
+ const resolver_offset = try r.takeLeb128(u64);
try exports.append(.{
.name = prefix,
.tag = .stub_resolver,
@@ -1536,7 +1536,7 @@ const MachODumper = struct {
});
},
else => {
- const vmoff = try br.takeLeb128(u64);
+ const vmoff = try r.takeLeb128(u64);
try exports.append(.{
.name = prefix,
.tag = .@"export",
@@ -1555,15 +1555,15 @@ const MachODumper = struct {
}
}
- const nedges = try br.takeByte();
+ const nedges = try r.takeByte();
for (0..nedges) |_| {
- const label = try br.takeSentinel(0);
- const off = try br.takeLeb128(usize);
+ const label = try r.takeSentinel(0);
+ const off = try r.takeLeb128(usize);
const prefix_label = try std.fmt.allocPrint(arena, "{s}{s}", .{ prefix, label });
- const seek = br.seek;
- br.seek = off;
- try parseTrieNode(arena, br, prefix_label, exports);
- br.seek = seek;
+ const seek = r.seek;
+ r.seek = off;
+ try parseTrieNode(arena, r, prefix_label, exports);
+ r.seek = seek;
}
}
@@ -1693,9 +1693,9 @@ const ElfDumper = struct {
fn parseAndDumpArchive(step: *Step, check: Check, bytes: []const u8) ![]const u8 {
const gpa = step.owner.allocator;
- var br: std.io.Reader = .fixed(bytes);
+ var r: std.io.Reader = .fixed(bytes);
- if (!mem.eql(u8, try br.takeArray(elf.ARMAG.len), elf.ARMAG)) return error.InvalidArchiveMagicNumber;
+ if (!mem.eql(u8, try r.takeArray(elf.ARMAG.len), elf.ARMAG)) return error.InvalidArchiveMagicNumber;
var ctx: ArchiveContext = .{
.gpa = gpa,
@@ -1706,14 +1706,14 @@ const ElfDumper = struct {
};
defer ctx.deinit();
- while (br.seek < bytes.len) {
- const hdr_seek = std.mem.alignForward(usize, br.seek, 2);
- br.seek = hdr_seek;
- const hdr = try br.takeStruct(elf.ar_hdr);
+ while (r.seek < bytes.len) {
+ const hdr_seek = std.mem.alignForward(usize, r.seek, 2);
+ r.seek = hdr_seek;
+ const hdr = try r.takeStruct(elf.ar_hdr);
if (!mem.eql(u8, &hdr.ar_fmag, elf.ARFMAG)) return error.InvalidArchiveHeaderMagicNumber;
- const data = try br.take(try hdr.size());
+ const data = try r.take(try hdr.size());
if (hdr.isSymtab()) {
try ctx.parseSymtab(data, .p32);
@@ -1766,17 +1766,17 @@ const ElfDumper = struct {
}
fn parseSymtab(ctx: *ArchiveContext, data: []const u8, ptr_width: enum { p32, p64 }) !void {
- var br: std.io.Reader = .fixed(data);
+ var r: std.io.Reader = .fixed(data);
const num = switch (ptr_width) {
- .p32 => try br.takeInt(u32, .big),
- .p64 => try br.takeInt(u64, .big),
+ .p32 => try r.takeInt(u32, .big),
+ .p64 => try r.takeInt(u64, .big),
};
const ptr_size: usize = switch (ptr_width) {
.p32 => @sizeOf(u32),
.p64 => @sizeOf(u64),
};
- _ = try br.discard(.limited(num * ptr_size));
- const strtab = br.buffered();
+ _ = try r.discard(.limited(num * ptr_size));
+ const strtab = r.buffered();
assert(ctx.symtab.len == 0);
ctx.symtab = try ctx.gpa.alloc(ArSymtabEntry, num);
@@ -1784,8 +1784,8 @@ const ElfDumper = struct {
var stroff: usize = 0;
for (ctx.symtab) |*entry| {
const off = switch (ptr_width) {
- .p32 => try br.takeInt(u32, .big),
- .p64 => try br.takeInt(u64, .big),
+ .p32 => try r.takeInt(u32, .big),
+ .p64 => try r.takeInt(u64, .big),
};
const name = mem.sliceTo(@as([*:0]const u8, @ptrCast(strtab[stroff..].ptr)), 0);
stroff += name.len + 1;
@@ -1836,9 +1836,9 @@ const ElfDumper = struct {
fn parseAndDumpObject(step: *Step, check: Check, bytes: []const u8) ![]const u8 {
const gpa = step.owner.allocator;
- var br: std.io.Reader = .fixed(bytes);
+ var r: std.io.Reader = .fixed(bytes);
- const hdr = try br.takeStruct(elf.Elf64_Ehdr);
+ const hdr = try r.takeStruct(elf.Elf64_Ehdr);
if (!mem.eql(u8, hdr.e_ident[0..4], "\x7fELF")) return error.InvalidMagicNumber;
const shdrs = @as([*]align(1) const elf.Elf64_Shdr, @ptrCast(bytes[hdr.e_shoff..].ptr))[0..hdr.e_shnum];
@@ -2327,9 +2327,9 @@ const WasmDumper = struct {
fn parseAndDump(step: *Step, check: Check, bytes: []const u8) ![]const u8 {
const gpa = step.owner.allocator;
- var br: std.io.Reader = .fixed(bytes);
+ var r: std.io.Reader = .fixed(bytes);
- const buf = try br.takeArray(8);
+ const buf = try r.takeArray(8);
if (!mem.eql(u8, buf[0..4], &std.wasm.magic)) return error.InvalidMagicByte;
if (!mem.eql(u8, buf[4..8], &std.wasm.version)) return error.UnsupportedWasmVersion;
@@ -2337,7 +2337,7 @@ const WasmDumper = struct {
defer aw.deinit();
const bw = &aw.writer;
- parseAndDumpInner(step, check, &br, bw) catch |err| switch (err) {
+ parseAndDumpInner(step, check, &r, bw) catch |err| switch (err) {
error.EndOfStream => try bw.writeAll("\n<UnexpectedEndOfStream>"),
else => |e| return e,
};
@@ -2347,14 +2347,13 @@ const WasmDumper = struct {
fn parseAndDumpInner(
step: *Step,
check: Check,
- br: *std.io.Reader,
+ r: *std.io.Reader,
bw: *Writer,
) !void {
- var section_br: std.io.Reader = undefined;
switch (check.kind) {
- .headers => while (br.takeEnum(std.wasm.Section, .little)) |section| {
- section_br = .fixed(try br.take(try br.takeLeb128(u32)));
- try parseAndDumpSection(step, section, §ion_br, bw);
+ .headers => while (r.takeEnum(std.wasm.Section, .little)) |section| {
+ var section_reader: std.io.Reader = .fixed(try r.take(try r.takeLeb128(u32)));
+ try parseAndDumpSection(step, section, §ion_reader, bw);
} else |err| switch (err) {
error.InvalidEnumTag => return step.fail("invalid section id", .{}),
error.EndOfStream => {},
@@ -2367,13 +2366,13 @@ const WasmDumper = struct {
fn parseAndDumpSection(
step: *Step,
section: std.wasm.Section,
- br: *std.io.Reader,
+ r: *std.io.Reader,
bw: *Writer,
) !void {
try bw.print(
\\Section {s}
\\size {d}
- , .{ @tagName(section), br.buffer.len });
+ , .{ @tagName(section), r.buffer.len });
switch (section) {
.type,
@@ -2387,63 +2386,63 @@ const WasmDumper = struct {
.code,
.data,
=> {
- const entries = try br.takeLeb128(u32);
+ const entries = try r.takeLeb128(u32);
try bw.print("\nentries {d}\n", .{entries});
- try parseSection(step, section, br, entries, bw);
+ try parseSection(step, section, r, entries, bw);
},
.custom => {
- const name = try br.take(try br.takeLeb128(u32));
+ const name = try r.take(try r.takeLeb128(u32));
try bw.print("\nname {s}\n", .{name});
if (mem.eql(u8, name, "name")) {
- try parseDumpNames(step, br, bw);
+ try parseDumpNames(step, r, bw);
} else if (mem.eql(u8, name, "producers")) {
- try parseDumpProducers(br, bw);
+ try parseDumpProducers(r, bw);
} else if (mem.eql(u8, name, "target_features")) {
- try parseDumpFeatures(br, bw);
+ try parseDumpFeatures(r, bw);
}
// TODO: Implement parsing and dumping other custom sections (such as relocations)
},
.start => {
- const start = try br.takeLeb128(u32);
+ const start = try r.takeLeb128(u32);
try bw.print("\nstart {d}\n", .{start});
},
.data_count => {
- const count = try br.takeLeb128(u32);
+ const count = try r.takeLeb128(u32);
try bw.print("\ncount {d}\n", .{count});
},
else => {}, // skip unknown sections
}
}
- fn parseSection(step: *Step, section: std.wasm.Section, br: *std.io.Reader, entries: u32, bw: *Writer) !void {
+ fn parseSection(step: *Step, section: std.wasm.Section, r: *std.io.Reader, entries: u32, bw: *Writer) !void {
switch (section) {
.type => {
var i: u32 = 0;
while (i < entries) : (i += 1) {
- const func_type = try br.takeByte();
+ const func_type = try r.takeByte();
if (func_type != std.wasm.function_type) {
return step.fail("expected function type, found byte '{d}'", .{func_type});
}
- const params = try br.takeLeb128(u32);
+ const params = try r.takeLeb128(u32);
try bw.print("params {d}\n", .{params});
var index: u32 = 0;
while (index < params) : (index += 1) {
- _ = try parseDumpType(step, std.wasm.Valtype, br, bw);
+ _ = try parseDumpType(step, std.wasm.Valtype, r, bw);
} else index = 0;
- const returns = try br.takeLeb128(u32);
+ const returns = try r.takeLeb128(u32);
try bw.print("returns {d}\n", .{returns});
while (index < returns) : (index += 1) {
- _ = try parseDumpType(step, std.wasm.Valtype, br, bw);
+ _ = try parseDumpType(step, std.wasm.Valtype, r, bw);
}
}
},
.import => {
var i: u32 = 0;
while (i < entries) : (i += 1) {
- const module_name = try br.take(try br.takeLeb128(u32));
- const name = try br.take(try br.takeLeb128(u32));
- const kind = br.takeEnum(std.wasm.ExternalKind, .little) catch |err| switch (err) {
+ const module_name = try r.take(try r.takeLeb128(u32));
+ const name = try r.take(try r.takeLeb128(u32));
+ const kind = r.takeEnum(std.wasm.ExternalKind, .little) catch |err| switch (err) {
error.InvalidEnumTag => return step.fail("invalid import kind", .{}),
else => |e| return e,
};
@@ -2455,15 +2454,15 @@ const WasmDumper = struct {
, .{ module_name, name, @tagName(kind) });
try bw.writeByte('\n');
switch (kind) {
- .function => try bw.print("index {d}\n", .{try br.takeLeb128(u32)}),
- .memory => try parseDumpLimits(br, bw),
+ .function => try bw.print("index {d}\n", .{try r.takeLeb128(u32)}),
+ .memory => try parseDumpLimits(r, bw),
.global => {
- _ = try parseDumpType(step, std.wasm.Valtype, br, bw);
- try bw.print("mutable {}\n", .{0x01 == try br.takeLeb128(u32)});
+ _ = try parseDumpType(step, std.wasm.Valtype, r, bw);
+ try bw.print("mutable {}\n", .{0x01 == try r.takeLeb128(u32)});
},
.table => {
- _ = try parseDumpType(step, std.wasm.RefType, br, bw);
- try parseDumpLimits(br, bw);
+ _ = try parseDumpType(step, std.wasm.RefType, r, bw);
+ try parseDumpLimits(r, bw);
},
}
}
@@ -2471,39 +2470,39 @@ const WasmDumper = struct {
.function => {
var i: u32 = 0;
while (i < entries) : (i += 1) {
- try bw.print("index {d}\n", .{try br.takeLeb128(u32)});
+ try bw.print("index {d}\n", .{try r.takeLeb128(u32)});
}
},
.table => {
var i: u32 = 0;
while (i < entries) : (i += 1) {
- _ = try parseDumpType(step, std.wasm.RefType, br, bw);
- try parseDumpLimits(br, bw);
+ _ = try parseDumpType(step, std.wasm.RefType, r, bw);
+ try parseDumpLimits(r, bw);
}
},
.memory => {
var i: u32 = 0;
while (i < entries) : (i += 1) {
- try parseDumpLimits(br, bw);
+ try parseDumpLimits(r, bw);
}
},
.global => {
var i: u32 = 0;
while (i < entries) : (i += 1) {
- _ = try parseDumpType(step, std.wasm.Valtype, br, bw);
- try bw.print("mutable {}\n", .{0x01 == try br.takeLeb128(u1)});
- try parseDumpInit(step, br, bw);
+ _ = try parseDumpType(step, std.wasm.Valtype, r, bw);
+ try bw.print("mutable {}\n", .{0x01 == try r.takeLeb128(u1)});
+ try parseDumpInit(step, r, bw);
}
},
.@"export" => {
var i: u32 = 0;
while (i < entries) : (i += 1) {
- const name = try br.take(try br.takeLeb128(u32));
- const kind = br.takeEnum(std.wasm.ExternalKind, .little) catch |err| switch (err) {
+ const name = try r.take(try r.takeLeb128(u32));
+ const kind = r.takeEnum(std.wasm.ExternalKind, .little) catch |err| switch (err) {
error.InvalidEnumTag => return step.fail("invalid export kind value", .{}),
else => |e| return e,
};
- const index = try br.takeLeb128(u32);
+ const index = try r.takeLeb128(u32);
try bw.print(
\\name {s}
\\kind {s}
@@ -2515,14 +2514,14 @@ const WasmDumper = struct {
.element => {
var i: u32 = 0;
while (i < entries) : (i += 1) {
- try bw.print("table index {d}\n", .{try br.takeLeb128(u32)});
- try parseDumpInit(step, br, bw);
+ try bw.print("table index {d}\n", .{try r.takeLeb128(u32)});
+ try parseDumpInit(step, r, bw);
- const function_indexes = try br.takeLeb128(u32);
+ const function_indexes = try r.takeLeb128(u32);
var function_index: u32 = 0;
try bw.print("indexes {d}\n", .{function_indexes});
while (function_index < function_indexes) : (function_index += 1) {
- try bw.print("index {d}\n", .{try br.takeLeb128(u32)});
+ try bw.print("index {d}\n", .{try r.takeLeb128(u32)});
}
}
},
@@ -2534,21 +2533,21 @@ const WasmDumper = struct {
passive: bool,
memidx: bool,
unused: u30,
- } = @bitCast(try br.takeLeb128(u32));
- const index = if (flags.memidx) try br.takeLeb128(u32) else 0;
+ } = @bitCast(try r.takeLeb128(u32));
+ const index = if (flags.memidx) try r.takeLeb128(u32) else 0;
try bw.print("memory index 0x{x}\n", .{index});
- if (!flags.passive) try parseDumpInit(step, br, bw);
- const size = try br.takeLeb128(u32);
+ if (!flags.passive) try parseDumpInit(step, r, bw);
+ const size = try r.takeLeb128(u32);
try bw.print("size {d}\n", .{size});
- _ = try br.discard(.limited(size)); // we do not care about the content of the segments
+ _ = try r.discard(.limited(size)); // we do not care about the content of the segments
}
},
else => unreachable,
}
}
- fn parseDumpType(step: *Step, comptime E: type, br: *std.io.Reader, bw: *Writer) !E {
- const tag = br.takeEnum(E, .little) catch |err| switch (err) {
+ fn parseDumpType(step: *Step, comptime E: type, r: *std.io.Reader, bw: *Writer) !E {
+ const tag = r.takeEnum(E, .little) catch |err| switch (err) {
error.InvalidEnumTag => return step.fail("invalid wasm type value", .{}),
else => |e| return e,
};
@@ -2556,42 +2555,42 @@ const WasmDumper = struct {
return tag;
}
- fn parseDumpLimits(br: *std.io.Reader, bw: *Writer) !void {
- const flags = try br.takeLeb128(u8);
- const min = try br.takeLeb128(u32);
+ fn parseDumpLimits(r: *std.io.Reader, bw: *Writer) !void {
+ const flags = try r.takeLeb128(u8);
+ const min = try r.takeLeb128(u32);
try bw.print("min {x}\n", .{min});
- if (flags != 0) try bw.print("max {x}\n", .{try br.takeLeb128(u32)});
+ if (flags != 0) try bw.print("max {x}\n", .{try r.takeLeb128(u32)});
}
- fn parseDumpInit(step: *Step, br: *std.io.Reader, bw: *Writer) !void {
- const opcode = br.takeEnum(std.wasm.Opcode, .little) catch |err| switch (err) {
+ fn parseDumpInit(step: *Step, r: *std.io.Reader, bw: *Writer) !void {
+ const opcode = r.takeEnum(std.wasm.Opcode, .little) catch |err| switch (err) {
error.InvalidEnumTag => return step.fail("invalid wasm opcode", .{}),
else => |e| return e,
};
switch (opcode) {
- .i32_const => try bw.print("i32.const {x}\n", .{try br.takeLeb128(i32)}),
- .i64_const => try bw.print("i64.const {x}\n", .{try br.takeLeb128(i64)}),
- .f32_const => try bw.print("f32.const {x}\n", .{@as(f32, @bitCast(try br.takeInt(u32, .little)))}),
- .f64_const => try bw.print("f64.const {x}\n", .{@as(f64, @bitCast(try br.takeInt(u64, .little)))}),
- .global_get => try bw.print("global.get {x}\n", .{try br.takeLeb128(u32)}),
+ .i32_const => try bw.print("i32.const {x}\n", .{try r.takeLeb128(i32)}),
+ .i64_const => try bw.print("i64.const {x}\n", .{try r.takeLeb128(i64)}),
+ .f32_const => try bw.print("f32.const {x}\n", .{@as(f32, @bitCast(try r.takeInt(u32, .little)))}),
+ .f64_const => try bw.print("f64.const {x}\n", .{@as(f64, @bitCast(try r.takeInt(u64, .little)))}),
+ .global_get => try bw.print("global.get {x}\n", .{try r.takeLeb128(u32)}),
else => unreachable,
}
- const end_opcode = try br.takeLeb128(u8);
+ const end_opcode = try r.takeLeb128(u8);
if (end_opcode != @intFromEnum(std.wasm.Opcode.end)) {
return step.fail("expected 'end' opcode in init expression", .{});
}
}
/// https://webassembly.github.io/spec/core/appendix/custom.html
- fn parseDumpNames(step: *Step, br: *std.io.Reader, bw: *Writer) !void {
+ fn parseDumpNames(step: *Step, r: *std.io.Reader, bw: *Writer) !void {
var subsection_br: std.io.Reader = undefined;
- while (br.seek < br.buffer.len) {
- switch (try parseDumpType(step, std.wasm.NameSubsection, br, bw)) {
+ while (r.seek < r.buffer.len) {
+ switch (try parseDumpType(step, std.wasm.NameSubsection, r, bw)) {
// The module name subsection ... consists of a single name
// that is assigned to the module itself.
.module => {
- subsection_br = .fixed(try br.take(try br.takeLeb128(u32)));
+ subsection_br = .fixed(try r.take(try r.takeLeb128(u32)));
const name = try subsection_br.take(try subsection_br.takeLeb128(u32));
try bw.print(
\\name {s}
@@ -2603,15 +2602,15 @@ const WasmDumper = struct {
// The function name subsection ... consists of a name map
// assigning function names to function indices.
.function, .global, .data_segment => {
- subsection_br = .fixed(try br.take(try br.takeLeb128(u32)));
- const entries = try br.takeLeb128(u32);
+ subsection_br = .fixed(try r.take(try r.takeLeb128(u32)));
+ const entries = try r.takeLeb128(u32);
try bw.print(
\\names {d}
\\
, .{entries});
for (0..entries) |_| {
- const index = try br.takeLeb128(u32);
- const name = try br.take(try br.takeLeb128(u32));
+ const index = try r.takeLeb128(u32);
+ const name = try r.take(try r.takeLeb128(u32));
try bw.print(
\\index {d}
\\name {s}
@@ -2633,16 +2632,16 @@ const WasmDumper = struct {
}
}
- fn parseDumpProducers(br: *std.io.Reader, bw: *Writer) !void {
- const field_count = try br.takeLeb128(u32);
+ fn parseDumpProducers(r: *std.io.Reader, bw: *Writer) !void {
+ const field_count = try r.takeLeb128(u32);
try bw.print(
\\fields {d}
\\
, .{field_count});
var current_field: u32 = 0;
while (current_field < field_count) : (current_field += 1) {
- const field_name = try br.take(try br.takeLeb128(u32));
- const value_count = try br.takeLeb128(u32);
+ const field_name = try r.take(try r.takeLeb128(u32));
+ const value_count = try r.takeLeb128(u32);
try bw.print(
\\field_name {s}
\\values {d}
@@ -2650,8 +2649,8 @@ const WasmDumper = struct {
, .{ field_name, value_count });
var current_value: u32 = 0;
while (current_value < value_count) : (current_value += 1) {
- const value = try br.take(try br.takeLeb128(u32));
- const version = try br.take(try br.takeLeb128(u32));
+ const value = try r.take(try r.takeLeb128(u32));
+ const version = try r.take(try r.takeLeb128(u32));
try bw.print(
\\value_name {s}
\\version {s}
@@ -2661,8 +2660,8 @@ const WasmDumper = struct {
}
}
- fn parseDumpFeatures(br: *std.io.Reader, bw: *Writer) !void {
- const feature_count = try br.takeLeb128(u32);
+ fn parseDumpFeatures(r: *std.io.Reader, bw: *Writer) !void {
+ const feature_count = try r.takeLeb128(u32);
try bw.print(
\\features {d}
\\
@@ -2670,8 +2669,8 @@ const WasmDumper = struct {
var index: u32 = 0;
while (index < feature_count) : (index += 1) {
- const prefix_byte = try br.takeLeb128(u8);
- const feature_name = try br.take(try br.takeLeb128(u32));
+ const prefix_byte = try r.takeLeb128(u8);
+ const feature_name = try r.take(try r.takeLeb128(u32));
try bw.print(
\\{c} {s}
\\
lib/std/fs/File.zig
@@ -1350,7 +1350,7 @@ pub const Reader = struct {
};
var remaining = std.math.cast(u64, offset) orelse return seek_err;
while (remaining > 0) {
- const n = discard(&r.interface, .limited(remaining)) catch |err| {
+ const n = discard(&r.interface, .limited64(remaining)) catch |err| {
r.seek_err = err;
return err;
};
@@ -1385,7 +1385,7 @@ pub const Reader = struct {
const max_buffers_len = 16;
fn stream(io_reader: *std.io.Reader, w: *std.io.Writer, limit: std.io.Limit) std.io.Reader.StreamError!usize {
- const r: *Reader = @fieldParentPtr("interface", io_reader);
+ const r: *Reader = @alignCast(@fieldParentPtr("interface", io_reader));
switch (r.mode) {
.positional, .streaming => return w.sendFile(r, limit) catch |write_err| switch (write_err) {
error.Unimplemented => {
@@ -1459,7 +1459,7 @@ pub const Reader = struct {
}
fn discard(io_reader: *std.io.Reader, limit: std.io.Limit) std.io.Reader.Error!usize {
- const r: *Reader = @fieldParentPtr("interface", io_reader);
+ const r: *Reader = @alignCast(@fieldParentPtr("interface", io_reader));
const file = r.file;
const pos = r.pos;
switch (r.mode) {
@@ -1661,7 +1661,7 @@ pub const Writer = struct {
}
pub fn drain(io_w: *std.io.Writer, data: []const []const u8, splat: usize) std.io.Writer.Error!usize {
- const w: *Writer = @fieldParentPtr("interface", io_w);
+ const w: *Writer = @alignCast(@fieldParentPtr("interface", io_w));
const handle = w.file.handle;
const buffered = io_w.buffered();
if (is_windows) switch (w.mode) {
@@ -1789,7 +1789,7 @@ pub const Writer = struct {
file_reader: *Reader,
limit: std.io.Limit,
) std.io.Writer.FileError!usize {
- const w: *Writer = @fieldParentPtr("interface", io_w);
+ const w: *Writer = @alignCast(@fieldParentPtr("interface", io_w));
const out_fd = w.file.handle;
const in_fd = file_reader.file.handle;
// TODO try using copy_file_range on FreeBSD
lib/std/io/Writer.zig
@@ -1958,7 +1958,7 @@ pub fn discardingSendFile(w: *Writer, file_reader: *File.Reader, limit: Limit) F
if (File.Handle == void) return error.Unimplemented;
w.end = 0;
if (file_reader.getSize()) |size| {
- const n = limit.minInt(size - file_reader.pos);
+ const n = limit.minInt64(size - file_reader.pos);
file_reader.seekBy(@intCast(n)) catch return error.Unimplemented;
w.end = 0;
return n;
@@ -2256,7 +2256,7 @@ pub const Allocating = struct {
defer setArrayList(a, list);
const pos = file_reader.pos;
const additional = if (file_reader.getSize()) |size| size - pos else |_| std.atomic.cache_line;
- list.ensureUnusedCapacity(gpa, limit.minInt(additional)) catch return error.WriteFailed;
+ list.ensureUnusedCapacity(gpa, limit.minInt64(additional)) catch return error.WriteFailed;
const dest = limit.slice(list.unusedCapacitySlice());
const n = file_reader.read(dest) catch |err| switch (err) {
error.ReadFailed => return error.ReadFailed,
lib/std/zig/system/linux.zig
@@ -391,7 +391,7 @@ pub fn detectNativeCpuAndFeatures() ?Target.Cpu {
const current_arch = builtin.cpu.arch;
switch (current_arch) {
.arm, .armeb, .thumb, .thumbeb => {
- return ArmCpuinfoParser.parse(current_arch, f.reader()) catch null;
+ return ArmCpuinfoParser.parse(current_arch, f.deprecatedReader()) catch null;
},
.aarch64, .aarch64_be => {
const registers = [12]u64{
lib/std/io.zig
@@ -24,6 +24,12 @@ pub const Limit = enum(usize) {
return @enumFromInt(n);
}
+ /// Any value grater than `std.math.maxInt(usize)` is interpreted to mean
+ /// `.unlimited`.
+ pub fn limited64(n: u64) Limit {
+ return @enumFromInt(@min(n, std.math.maxInt(usize)));
+ }
+
pub fn countVec(data: []const []const u8) Limit {
var total: usize = 0;
for (data) |d| total += d.len;
@@ -38,6 +44,10 @@ pub const Limit = enum(usize) {
return @min(n, @intFromEnum(l));
}
+ pub fn minInt64(l: Limit, n: u64) usize {
+ return @min(n, @intFromEnum(l));
+ }
+
pub fn slice(l: Limit, s: []u8) []u8 {
return s[0..l.minInt(s.len)];
}
src/codegen/c.zig
@@ -1295,7 +1295,7 @@ pub const DeclGen = struct {
}
const ai = ty.arrayInfo(zcu);
if (ai.elem_type.eql(.u8, zcu)) {
- var literal: StringLiteral = .init(w, ty.arrayLenIncludingSentinel(zcu));
+ var literal: StringLiteral = .init(w, @intCast(ty.arrayLenIncludingSentinel(zcu)));
try literal.start();
var index: usize = 0;
while (index < ai.len) : (index += 1) {
@@ -1854,7 +1854,7 @@ pub const DeclGen = struct {
const ai = ty.arrayInfo(zcu);
if (ai.elem_type.eql(.u8, zcu)) {
const c_len = ty.arrayLenIncludingSentinel(zcu);
- var literal: StringLiteral = .init(w, c_len);
+ var literal: StringLiteral = .init(w, @intCast(c_len));
try literal.start();
var index: u64 = 0;
while (index < c_len) : (index += 1)