authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-07-06 23:49:30-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-07-07 22:43:53-07:00
logf2ad3bcc1c7ad18ed8e2d9c919be45885e224bfc
tree0b8e18d175dd49ca41bb9ad4ead20530248a2a84
parentb077e2979c4ec21173e0ffa20ab7ee0c750a3ddc

fix 32-bit compilation

6 files changed, 153 insertions(+), 144 deletions(-)

lib/std/Build/Step/CheckObject.zig+133-134
......@@ -1231,12 +1231,12 @@ const MachODumper = struct {
12311231 }
12321232
12331233 fn parseRebaseInfo(ctx: ObjectContext, data: []const u8, rebases: *std.ArrayList(u64)) !void {
1234 var br: std.io.Reader = .fixed(data);
1234 var r: std.io.Reader = .fixed(data);
12351235
12361236 var seg_id: ?u8 = null;
12371237 var offset: u64 = 0;
12381238 while (true) {
1239 const byte = br.takeByte() catch break;
1239 const byte = r.takeByte() catch break;
12401240 const opc = byte & macho.REBASE_OPCODE_MASK;
12411241 const imm = byte & macho.REBASE_IMMEDIATE_MASK;
12421242 switch (opc) {
......@@ -1244,17 +1244,17 @@ const MachODumper = struct {
12441244 macho.REBASE_OPCODE_SET_TYPE_IMM => {},
12451245 macho.REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB => {
12461246 seg_id = imm;
1247 offset = try br.takeLeb128(u64);
1247 offset = try r.takeLeb128(u64);
12481248 },
12491249 macho.REBASE_OPCODE_ADD_ADDR_IMM_SCALED => {
12501250 offset += imm * @sizeOf(u64);
12511251 },
12521252 macho.REBASE_OPCODE_ADD_ADDR_ULEB => {
1253 const addend = try br.takeLeb128(u64);
1253 const addend = try r.takeLeb128(u64);
12541254 offset += addend;
12551255 },
12561256 macho.REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB => {
1257 const addend = try br.takeLeb128(u64);
1257 const addend = try r.takeLeb128(u64);
12581258 const seg = ctx.segments.items[seg_id.?];
12591259 const addr = seg.vmaddr + offset;
12601260 try rebases.append(addr);
......@@ -1271,11 +1271,11 @@ const MachODumper = struct {
12711271 ntimes = imm;
12721272 },
12731273 macho.REBASE_OPCODE_DO_REBASE_ULEB_TIMES => {
1274 ntimes = try br.takeLeb128(u64);
1274 ntimes = try r.takeLeb128(u64);
12751275 },
12761276 macho.REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB => {
1277 ntimes = try br.takeLeb128(u64);
1278 skip = try br.takeLeb128(u64);
1277 ntimes = try r.takeLeb128(u64);
1278 skip = try r.takeLeb128(u64);
12791279 },
12801280 else => unreachable,
12811281 }
......@@ -1341,7 +1341,7 @@ const MachODumper = struct {
13411341 }
13421342
13431343 fn parseBindInfo(ctx: ObjectContext, data: []const u8, bindings: *std.ArrayList(Binding)) !void {
1344 var br: std.io.Reader = .fixed(data);
1344 var r: std.io.Reader = .fixed(data);
13451345
13461346 var seg_id: ?u8 = null;
13471347 var tag: Binding.Tag = .self;
......@@ -1352,7 +1352,7 @@ const MachODumper = struct {
13521352 var name_buf: std.io.Writer.Allocating = .init(ctx.gpa);
13531353 defer name_buf.deinit();
13541354
1355 while (br.takeByte()) |byte| {
1355 while (r.takeByte()) |byte| {
13561356 const opc = byte & macho.BIND_OPCODE_MASK;
13571357 const imm = byte & macho.BIND_IMMEDIATE_MASK;
13581358 switch (opc) {
......@@ -1373,18 +1373,18 @@ const MachODumper = struct {
13731373 },
13741374 macho.BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB => {
13751375 seg_id = imm;
1376 offset = try br.takeLeb128(u64);
1376 offset = try r.takeLeb128(u64);
13771377 },
13781378 macho.BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM => {
13791379 name_buf.clearRetainingCapacity();
1380 _ = try br.streamDelimiterLimit(&name_buf.writer, 0, .limited(std.math.maxInt(u32)));
1380 _ = try r.streamDelimiterLimit(&name_buf.writer, 0, .limited(std.math.maxInt(u32)));
13811381 try name_buf.writer.writeByte(0);
13821382 },
13831383 macho.BIND_OPCODE_SET_ADDEND_SLEB => {
1384 addend = try br.takeLeb128(i64);
1384 addend = try r.takeLeb128(i64);
13851385 },
13861386 macho.BIND_OPCODE_ADD_ADDR_ULEB => {
1387 const x = try br.takeLeb128(u64);
1387 const x = try r.takeLeb128(u64);
13881388 offset = @intCast(@as(i64, @intCast(offset)) + @as(i64, @bitCast(x)));
13891389 },
13901390 macho.BIND_OPCODE_DO_BIND,
......@@ -1399,14 +1399,14 @@ const MachODumper = struct {
13991399 switch (opc) {
14001400 macho.BIND_OPCODE_DO_BIND => {},
14011401 macho.BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB => {
1402 add_addr = try br.takeLeb128(u64);
1402 add_addr = try r.takeLeb128(u64);
14031403 },
14041404 macho.BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED => {
14051405 add_addr = imm * @sizeOf(u64);
14061406 },
14071407 macho.BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB => {
1408 count = try br.takeLeb128(u64);
1409 skip = try br.takeLeb128(u64);
1408 count = try r.takeLeb128(u64);
1409 skip = try r.takeLeb128(u64);
14101410 },
14111411 else => unreachable,
14121412 }
......@@ -1437,8 +1437,8 @@ const MachODumper = struct {
14371437 defer arena.deinit();
14381438
14391439 var exports: std.ArrayList(Export) = .init(arena.allocator());
1440 var br: std.io.Reader = .fixed(data);
1441 try parseTrieNode(arena.allocator(), &br, "", &exports);
1440 var r: std.io.Reader = .fixed(data);
1441 try parseTrieNode(arena.allocator(), &r, "", &exports);
14421442
14431443 mem.sort(Export, exports.items, {}, Export.lessThan);
14441444
......@@ -1506,17 +1506,17 @@ const MachODumper = struct {
15061506
15071507 fn parseTrieNode(
15081508 arena: Allocator,
1509 br: *std.io.Reader,
1509 r: *std.io.Reader,
15101510 prefix: []const u8,
15111511 exports: *std.ArrayList(Export),
15121512 ) !void {
1513 const size = try br.takeLeb128(u64);
1513 const size = try r.takeLeb128(u64);
15141514 if (size > 0) {
1515 const flags = try br.takeLeb128(u8);
1515 const flags = try r.takeLeb128(u8);
15161516 switch (flags) {
15171517 macho.EXPORT_SYMBOL_FLAGS_REEXPORT => {
1518 const ord = try br.takeLeb128(u64);
1519 const name = try br.takeSentinel(0);
1518 const ord = try r.takeLeb128(u64);
1519 const name = try r.takeSentinel(0);
15201520 try exports.append(.{
15211521 .name = if (name.len > 0) name else prefix,
15221522 .tag = .reexport,
......@@ -1524,8 +1524,8 @@ const MachODumper = struct {
15241524 });
15251525 },
15261526 macho.EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER => {
1527 const stub_offset = try br.takeLeb128(u64);
1528 const resolver_offset = try br.takeLeb128(u64);
1527 const stub_offset = try r.takeLeb128(u64);
1528 const resolver_offset = try r.takeLeb128(u64);
15291529 try exports.append(.{
15301530 .name = prefix,
15311531 .tag = .stub_resolver,
......@@ -1536,7 +1536,7 @@ const MachODumper = struct {
15361536 });
15371537 },
15381538 else => {
1539 const vmoff = try br.takeLeb128(u64);
1539 const vmoff = try r.takeLeb128(u64);
15401540 try exports.append(.{
15411541 .name = prefix,
15421542 .tag = .@"export",
......@@ -1555,15 +1555,15 @@ const MachODumper = struct {
15551555 }
15561556 }
15571557
1558 const nedges = try br.takeByte();
1558 const nedges = try r.takeByte();
15591559 for (0..nedges) |_| {
1560 const label = try br.takeSentinel(0);
1561 const off = try br.takeLeb128(usize);
1560 const label = try r.takeSentinel(0);
1561 const off = try r.takeLeb128(usize);
15621562 const prefix_label = try std.fmt.allocPrint(arena, "{s}{s}", .{ prefix, label });
1563 const seek = br.seek;
1564 br.seek = off;
1565 try parseTrieNode(arena, br, prefix_label, exports);
1566 br.seek = seek;
1563 const seek = r.seek;
1564 r.seek = off;
1565 try parseTrieNode(arena, r, prefix_label, exports);
1566 r.seek = seek;
15671567 }
15681568 }
15691569
......@@ -1693,9 +1693,9 @@ const ElfDumper = struct {
16931693
16941694 fn parseAndDumpArchive(step: *Step, check: Check, bytes: []const u8) ![]const u8 {
16951695 const gpa = step.owner.allocator;
1696 var br: std.io.Reader = .fixed(bytes);
1696 var r: std.io.Reader = .fixed(bytes);
16971697
1698 if (!mem.eql(u8, try br.takeArray(elf.ARMAG.len), elf.ARMAG)) return error.InvalidArchiveMagicNumber;
1698 if (!mem.eql(u8, try r.takeArray(elf.ARMAG.len), elf.ARMAG)) return error.InvalidArchiveMagicNumber;
16991699
17001700 var ctx: ArchiveContext = .{
17011701 .gpa = gpa,
......@@ -1706,14 +1706,14 @@ const ElfDumper = struct {
17061706 };
17071707 defer ctx.deinit();
17081708
1709 while (br.seek < bytes.len) {
1710 const hdr_seek = std.mem.alignForward(usize, br.seek, 2);
1711 br.seek = hdr_seek;
1712 const hdr = try br.takeStruct(elf.ar_hdr);
1709 while (r.seek < bytes.len) {
1710 const hdr_seek = std.mem.alignForward(usize, r.seek, 2);
1711 r.seek = hdr_seek;
1712 const hdr = try r.takeStruct(elf.ar_hdr);
17131713
17141714 if (!mem.eql(u8, &hdr.ar_fmag, elf.ARFMAG)) return error.InvalidArchiveHeaderMagicNumber;
17151715
1716 const data = try br.take(try hdr.size());
1716 const data = try r.take(try hdr.size());
17171717
17181718 if (hdr.isSymtab()) {
17191719 try ctx.parseSymtab(data, .p32);
......@@ -1766,17 +1766,17 @@ const ElfDumper = struct {
17661766 }
17671767
17681768 fn parseSymtab(ctx: *ArchiveContext, data: []const u8, ptr_width: enum { p32, p64 }) !void {
1769 var br: std.io.Reader = .fixed(data);
1769 var r: std.io.Reader = .fixed(data);
17701770 const num = switch (ptr_width) {
1771 .p32 => try br.takeInt(u32, .big),
1772 .p64 => try br.takeInt(u64, .big),
1771 .p32 => try r.takeInt(u32, .big),
1772 .p64 => try r.takeInt(u64, .big),
17731773 };
17741774 const ptr_size: usize = switch (ptr_width) {
17751775 .p32 => @sizeOf(u32),
17761776 .p64 => @sizeOf(u64),
17771777 };
1778 _ = try br.discard(.limited(num * ptr_size));
1779 const strtab = br.buffered();
1778 _ = try r.discard(.limited(num * ptr_size));
1779 const strtab = r.buffered();
17801780
17811781 assert(ctx.symtab.len == 0);
17821782 ctx.symtab = try ctx.gpa.alloc(ArSymtabEntry, num);
......@@ -1784,8 +1784,8 @@ const ElfDumper = struct {
17841784 var stroff: usize = 0;
17851785 for (ctx.symtab) |*entry| {
17861786 const off = switch (ptr_width) {
1787 .p32 => try br.takeInt(u32, .big),
1788 .p64 => try br.takeInt(u64, .big),
1787 .p32 => try r.takeInt(u32, .big),
1788 .p64 => try r.takeInt(u64, .big),
17891789 };
17901790 const name = mem.sliceTo(@as([*:0]const u8, @ptrCast(strtab[stroff..].ptr)), 0);
17911791 stroff += name.len + 1;
......@@ -1836,9 +1836,9 @@ const ElfDumper = struct {
18361836
18371837 fn parseAndDumpObject(step: *Step, check: Check, bytes: []const u8) ![]const u8 {
18381838 const gpa = step.owner.allocator;
1839 var br: std.io.Reader = .fixed(bytes);
1839 var r: std.io.Reader = .fixed(bytes);
18401840
1841 const hdr = try br.takeStruct(elf.Elf64_Ehdr);
1841 const hdr = try r.takeStruct(elf.Elf64_Ehdr);
18421842 if (!mem.eql(u8, hdr.e_ident[0..4], "\x7fELF")) return error.InvalidMagicNumber;
18431843
18441844 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 {
23272327
23282328 fn parseAndDump(step: *Step, check: Check, bytes: []const u8) ![]const u8 {
23292329 const gpa = step.owner.allocator;
2330 var br: std.io.Reader = .fixed(bytes);
2330 var r: std.io.Reader = .fixed(bytes);
23312331
2332 const buf = try br.takeArray(8);
2332 const buf = try r.takeArray(8);
23332333 if (!mem.eql(u8, buf[0..4], &std.wasm.magic)) return error.InvalidMagicByte;
23342334 if (!mem.eql(u8, buf[4..8], &std.wasm.version)) return error.UnsupportedWasmVersion;
23352335
......@@ -2337,7 +2337,7 @@ const WasmDumper = struct {
23372337 defer aw.deinit();
23382338 const bw = &aw.writer;
23392339
2340 parseAndDumpInner(step, check, &br, bw) catch |err| switch (err) {
2340 parseAndDumpInner(step, check, &r, bw) catch |err| switch (err) {
23412341 error.EndOfStream => try bw.writeAll("\n<UnexpectedEndOfStream>"),
23422342 else => |e| return e,
23432343 };
......@@ -2347,14 +2347,13 @@ const WasmDumper = struct {
23472347 fn parseAndDumpInner(
23482348 step: *Step,
23492349 check: Check,
2350 br: *std.io.Reader,
2350 r: *std.io.Reader,
23512351 bw: *Writer,
23522352 ) !void {
2353 var section_br: std.io.Reader = undefined;
23542353 switch (check.kind) {
2355 .headers => while (br.takeEnum(std.wasm.Section, .little)) |section| {
2356 section_br = .fixed(try br.take(try br.takeLeb128(u32)));
2357 try parseAndDumpSection(step, section, &section_br, bw);
2354 .headers => while (r.takeEnum(std.wasm.Section, .little)) |section| {
2355 var section_reader: std.io.Reader = .fixed(try r.take(try r.takeLeb128(u32)));
2356 try parseAndDumpSection(step, section, &section_reader, bw);
23582357 } else |err| switch (err) {
23592358 error.InvalidEnumTag => return step.fail("invalid section id", .{}),
23602359 error.EndOfStream => {},
......@@ -2367,13 +2366,13 @@ const WasmDumper = struct {
23672366 fn parseAndDumpSection(
23682367 step: *Step,
23692368 section: std.wasm.Section,
2370 br: *std.io.Reader,
2369 r: *std.io.Reader,
23712370 bw: *Writer,
23722371 ) !void {
23732372 try bw.print(
23742373 \\Section {s}
23752374 \\size {d}
2376 , .{ @tagName(section), br.buffer.len });
2375 , .{ @tagName(section), r.buffer.len });
23772376
23782377 switch (section) {
23792378 .type,
......@@ -2387,63 +2386,63 @@ const WasmDumper = struct {
23872386 .code,
23882387 .data,
23892388 => {
2390 const entries = try br.takeLeb128(u32);
2389 const entries = try r.takeLeb128(u32);
23912390 try bw.print("\nentries {d}\n", .{entries});
2392 try parseSection(step, section, br, entries, bw);
2391 try parseSection(step, section, r, entries, bw);
23932392 },
23942393 .custom => {
2395 const name = try br.take(try br.takeLeb128(u32));
2394 const name = try r.take(try r.takeLeb128(u32));
23962395 try bw.print("\nname {s}\n", .{name});
23972396
23982397 if (mem.eql(u8, name, "name")) {
2399 try parseDumpNames(step, br, bw);
2398 try parseDumpNames(step, r, bw);
24002399 } else if (mem.eql(u8, name, "producers")) {
2401 try parseDumpProducers(br, bw);
2400 try parseDumpProducers(r, bw);
24022401 } else if (mem.eql(u8, name, "target_features")) {
2403 try parseDumpFeatures(br, bw);
2402 try parseDumpFeatures(r, bw);
24042403 }
24052404 // TODO: Implement parsing and dumping other custom sections (such as relocations)
24062405 },
24072406 .start => {
2408 const start = try br.takeLeb128(u32);
2407 const start = try r.takeLeb128(u32);
24092408 try bw.print("\nstart {d}\n", .{start});
24102409 },
24112410 .data_count => {
2412 const count = try br.takeLeb128(u32);
2411 const count = try r.takeLeb128(u32);
24132412 try bw.print("\ncount {d}\n", .{count});
24142413 },
24152414 else => {}, // skip unknown sections
24162415 }
24172416 }
24182417
2419 fn parseSection(step: *Step, section: std.wasm.Section, br: *std.io.Reader, entries: u32, bw: *Writer) !void {
2418 fn parseSection(step: *Step, section: std.wasm.Section, r: *std.io.Reader, entries: u32, bw: *Writer) !void {
24202419 switch (section) {
24212420 .type => {
24222421 var i: u32 = 0;
24232422 while (i < entries) : (i += 1) {
2424 const func_type = try br.takeByte();
2423 const func_type = try r.takeByte();
24252424 if (func_type != std.wasm.function_type) {
24262425 return step.fail("expected function type, found byte '{d}'", .{func_type});
24272426 }
2428 const params = try br.takeLeb128(u32);
2427 const params = try r.takeLeb128(u32);
24292428 try bw.print("params {d}\n", .{params});
24302429 var index: u32 = 0;
24312430 while (index < params) : (index += 1) {
2432 _ = try parseDumpType(step, std.wasm.Valtype, br, bw);
2431 _ = try parseDumpType(step, std.wasm.Valtype, r, bw);
24332432 } else index = 0;
2434 const returns = try br.takeLeb128(u32);
2433 const returns = try r.takeLeb128(u32);
24352434 try bw.print("returns {d}\n", .{returns});
24362435 while (index < returns) : (index += 1) {
2437 _ = try parseDumpType(step, std.wasm.Valtype, br, bw);
2436 _ = try parseDumpType(step, std.wasm.Valtype, r, bw);
24382437 }
24392438 }
24402439 },
24412440 .import => {
24422441 var i: u32 = 0;
24432442 while (i < entries) : (i += 1) {
2444 const module_name = try br.take(try br.takeLeb128(u32));
2445 const name = try br.take(try br.takeLeb128(u32));
2446 const kind = br.takeEnum(std.wasm.ExternalKind, .little) catch |err| switch (err) {
2443 const module_name = try r.take(try r.takeLeb128(u32));
2444 const name = try r.take(try r.takeLeb128(u32));
2445 const kind = r.takeEnum(std.wasm.ExternalKind, .little) catch |err| switch (err) {
24472446 error.InvalidEnumTag => return step.fail("invalid import kind", .{}),
24482447 else => |e| return e,
24492448 };
......@@ -2455,15 +2454,15 @@ const WasmDumper = struct {
24552454 , .{ module_name, name, @tagName(kind) });
24562455 try bw.writeByte('\n');
24572456 switch (kind) {
2458 .function => try bw.print("index {d}\n", .{try br.takeLeb128(u32)}),
2459 .memory => try parseDumpLimits(br, bw),
2457 .function => try bw.print("index {d}\n", .{try r.takeLeb128(u32)}),
2458 .memory => try parseDumpLimits(r, bw),
24602459 .global => {
2461 _ = try parseDumpType(step, std.wasm.Valtype, br, bw);
2462 try bw.print("mutable {}\n", .{0x01 == try br.takeLeb128(u32)});
2460 _ = try parseDumpType(step, std.wasm.Valtype, r, bw);
2461 try bw.print("mutable {}\n", .{0x01 == try r.takeLeb128(u32)});
24632462 },
24642463 .table => {
2465 _ = try parseDumpType(step, std.wasm.RefType, br, bw);
2466 try parseDumpLimits(br, bw);
2464 _ = try parseDumpType(step, std.wasm.RefType, r, bw);
2465 try parseDumpLimits(r, bw);
24672466 },
24682467 }
24692468 }
......@@ -2471,39 +2470,39 @@ const WasmDumper = struct {
24712470 .function => {
24722471 var i: u32 = 0;
24732472 while (i < entries) : (i += 1) {
2474 try bw.print("index {d}\n", .{try br.takeLeb128(u32)});
2473 try bw.print("index {d}\n", .{try r.takeLeb128(u32)});
24752474 }
24762475 },
24772476 .table => {
24782477 var i: u32 = 0;
24792478 while (i < entries) : (i += 1) {
2480 _ = try parseDumpType(step, std.wasm.RefType, br, bw);
2481 try parseDumpLimits(br, bw);
2479 _ = try parseDumpType(step, std.wasm.RefType, r, bw);
2480 try parseDumpLimits(r, bw);
24822481 }
24832482 },
24842483 .memory => {
24852484 var i: u32 = 0;
24862485 while (i < entries) : (i += 1) {
2487 try parseDumpLimits(br, bw);
2486 try parseDumpLimits(r, bw);
24882487 }
24892488 },
24902489 .global => {
24912490 var i: u32 = 0;
24922491 while (i < entries) : (i += 1) {
2493 _ = try parseDumpType(step, std.wasm.Valtype, br, bw);
2494 try bw.print("mutable {}\n", .{0x01 == try br.takeLeb128(u1)});
2495 try parseDumpInit(step, br, bw);
2492 _ = try parseDumpType(step, std.wasm.Valtype, r, bw);
2493 try bw.print("mutable {}\n", .{0x01 == try r.takeLeb128(u1)});
2494 try parseDumpInit(step, r, bw);
24962495 }
24972496 },
24982497 .@"export" => {
24992498 var i: u32 = 0;
25002499 while (i < entries) : (i += 1) {
2501 const name = try br.take(try br.takeLeb128(u32));
2502 const kind = br.takeEnum(std.wasm.ExternalKind, .little) catch |err| switch (err) {
2500 const name = try r.take(try r.takeLeb128(u32));
2501 const kind = r.takeEnum(std.wasm.ExternalKind, .little) catch |err| switch (err) {
25032502 error.InvalidEnumTag => return step.fail("invalid export kind value", .{}),
25042503 else => |e| return e,
25052504 };
2506 const index = try br.takeLeb128(u32);
2505 const index = try r.takeLeb128(u32);
25072506 try bw.print(
25082507 \\name {s}
25092508 \\kind {s}
......@@ -2515,14 +2514,14 @@ const WasmDumper = struct {
25152514 .element => {
25162515 var i: u32 = 0;
25172516 while (i < entries) : (i += 1) {
2518 try bw.print("table index {d}\n", .{try br.takeLeb128(u32)});
2519 try parseDumpInit(step, br, bw);
2517 try bw.print("table index {d}\n", .{try r.takeLeb128(u32)});
2518 try parseDumpInit(step, r, bw);
25202519
2521 const function_indexes = try br.takeLeb128(u32);
2520 const function_indexes = try r.takeLeb128(u32);
25222521 var function_index: u32 = 0;
25232522 try bw.print("indexes {d}\n", .{function_indexes});
25242523 while (function_index < function_indexes) : (function_index += 1) {
2525 try bw.print("index {d}\n", .{try br.takeLeb128(u32)});
2524 try bw.print("index {d}\n", .{try r.takeLeb128(u32)});
25262525 }
25272526 }
25282527 },
......@@ -2534,21 +2533,21 @@ const WasmDumper = struct {
25342533 passive: bool,
25352534 memidx: bool,
25362535 unused: u30,
2537 } = @bitCast(try br.takeLeb128(u32));
2538 const index = if (flags.memidx) try br.takeLeb128(u32) else 0;
2536 } = @bitCast(try r.takeLeb128(u32));
2537 const index = if (flags.memidx) try r.takeLeb128(u32) else 0;
25392538 try bw.print("memory index 0x{x}\n", .{index});
2540 if (!flags.passive) try parseDumpInit(step, br, bw);
2541 const size = try br.takeLeb128(u32);
2539 if (!flags.passive) try parseDumpInit(step, r, bw);
2540 const size = try r.takeLeb128(u32);
25422541 try bw.print("size {d}\n", .{size});
2543 _ = try br.discard(.limited(size)); // we do not care about the content of the segments
2542 _ = try r.discard(.limited(size)); // we do not care about the content of the segments
25442543 }
25452544 },
25462545 else => unreachable,
25472546 }
25482547 }
25492548
2550 fn parseDumpType(step: *Step, comptime E: type, br: *std.io.Reader, bw: *Writer) !E {
2551 const tag = br.takeEnum(E, .little) catch |err| switch (err) {
2549 fn parseDumpType(step: *Step, comptime E: type, r: *std.io.Reader, bw: *Writer) !E {
2550 const tag = r.takeEnum(E, .little) catch |err| switch (err) {
25522551 error.InvalidEnumTag => return step.fail("invalid wasm type value", .{}),
25532552 else => |e| return e,
25542553 };
......@@ -2556,42 +2555,42 @@ const WasmDumper = struct {
25562555 return tag;
25572556 }
25582557
2559 fn parseDumpLimits(br: *std.io.Reader, bw: *Writer) !void {
2560 const flags = try br.takeLeb128(u8);
2561 const min = try br.takeLeb128(u32);
2558 fn parseDumpLimits(r: *std.io.Reader, bw: *Writer) !void {
2559 const flags = try r.takeLeb128(u8);
2560 const min = try r.takeLeb128(u32);
25622561
25632562 try bw.print("min {x}\n", .{min});
2564 if (flags != 0) try bw.print("max {x}\n", .{try br.takeLeb128(u32)});
2563 if (flags != 0) try bw.print("max {x}\n", .{try r.takeLeb128(u32)});
25652564 }
25662565
2567 fn parseDumpInit(step: *Step, br: *std.io.Reader, bw: *Writer) !void {
2568 const opcode = br.takeEnum(std.wasm.Opcode, .little) catch |err| switch (err) {
2566 fn parseDumpInit(step: *Step, r: *std.io.Reader, bw: *Writer) !void {
2567 const opcode = r.takeEnum(std.wasm.Opcode, .little) catch |err| switch (err) {
25692568 error.InvalidEnumTag => return step.fail("invalid wasm opcode", .{}),
25702569 else => |e| return e,
25712570 };
25722571 switch (opcode) {
2573 .i32_const => try bw.print("i32.const {x}\n", .{try br.takeLeb128(i32)}),
2574 .i64_const => try bw.print("i64.const {x}\n", .{try br.takeLeb128(i64)}),
2575 .f32_const => try bw.print("f32.const {x}\n", .{@as(f32, @bitCast(try br.takeInt(u32, .little)))}),
2576 .f64_const => try bw.print("f64.const {x}\n", .{@as(f64, @bitCast(try br.takeInt(u64, .little)))}),
2577 .global_get => try bw.print("global.get {x}\n", .{try br.takeLeb128(u32)}),
2572 .i32_const => try bw.print("i32.const {x}\n", .{try r.takeLeb128(i32)}),
2573 .i64_const => try bw.print("i64.const {x}\n", .{try r.takeLeb128(i64)}),
2574 .f32_const => try bw.print("f32.const {x}\n", .{@as(f32, @bitCast(try r.takeInt(u32, .little)))}),
2575 .f64_const => try bw.print("f64.const {x}\n", .{@as(f64, @bitCast(try r.takeInt(u64, .little)))}),
2576 .global_get => try bw.print("global.get {x}\n", .{try r.takeLeb128(u32)}),
25782577 else => unreachable,
25792578 }
2580 const end_opcode = try br.takeLeb128(u8);
2579 const end_opcode = try r.takeLeb128(u8);
25812580 if (end_opcode != @intFromEnum(std.wasm.Opcode.end)) {
25822581 return step.fail("expected 'end' opcode in init expression", .{});
25832582 }
25842583 }
25852584
25862585 /// https://webassembly.github.io/spec/core/appendix/custom.html
2587 fn parseDumpNames(step: *Step, br: *std.io.Reader, bw: *Writer) !void {
2586 fn parseDumpNames(step: *Step, r: *std.io.Reader, bw: *Writer) !void {
25882587 var subsection_br: std.io.Reader = undefined;
2589 while (br.seek < br.buffer.len) {
2590 switch (try parseDumpType(step, std.wasm.NameSubsection, br, bw)) {
2588 while (r.seek < r.buffer.len) {
2589 switch (try parseDumpType(step, std.wasm.NameSubsection, r, bw)) {
25912590 // The module name subsection ... consists of a single name
25922591 // that is assigned to the module itself.
25932592 .module => {
2594 subsection_br = .fixed(try br.take(try br.takeLeb128(u32)));
2593 subsection_br = .fixed(try r.take(try r.takeLeb128(u32)));
25952594 const name = try subsection_br.take(try subsection_br.takeLeb128(u32));
25962595 try bw.print(
25972596 \\name {s}
......@@ -2603,15 +2602,15 @@ const WasmDumper = struct {
26032602 // The function name subsection ... consists of a name map
26042603 // assigning function names to function indices.
26052604 .function, .global, .data_segment => {
2606 subsection_br = .fixed(try br.take(try br.takeLeb128(u32)));
2607 const entries = try br.takeLeb128(u32);
2605 subsection_br = .fixed(try r.take(try r.takeLeb128(u32)));
2606 const entries = try r.takeLeb128(u32);
26082607 try bw.print(
26092608 \\names {d}
26102609 \\
26112610 , .{entries});
26122611 for (0..entries) |_| {
2613 const index = try br.takeLeb128(u32);
2614 const name = try br.take(try br.takeLeb128(u32));
2612 const index = try r.takeLeb128(u32);
2613 const name = try r.take(try r.takeLeb128(u32));
26152614 try bw.print(
26162615 \\index {d}
26172616 \\name {s}
......@@ -2633,16 +2632,16 @@ const WasmDumper = struct {
26332632 }
26342633 }
26352634
2636 fn parseDumpProducers(br: *std.io.Reader, bw: *Writer) !void {
2637 const field_count = try br.takeLeb128(u32);
2635 fn parseDumpProducers(r: *std.io.Reader, bw: *Writer) !void {
2636 const field_count = try r.takeLeb128(u32);
26382637 try bw.print(
26392638 \\fields {d}
26402639 \\
26412640 , .{field_count});
26422641 var current_field: u32 = 0;
26432642 while (current_field < field_count) : (current_field += 1) {
2644 const field_name = try br.take(try br.takeLeb128(u32));
2645 const value_count = try br.takeLeb128(u32);
2643 const field_name = try r.take(try r.takeLeb128(u32));
2644 const value_count = try r.takeLeb128(u32);
26462645 try bw.print(
26472646 \\field_name {s}
26482647 \\values {d}
......@@ -2650,8 +2649,8 @@ const WasmDumper = struct {
26502649 , .{ field_name, value_count });
26512650 var current_value: u32 = 0;
26522651 while (current_value < value_count) : (current_value += 1) {
2653 const value = try br.take(try br.takeLeb128(u32));
2654 const version = try br.take(try br.takeLeb128(u32));
2652 const value = try r.take(try r.takeLeb128(u32));
2653 const version = try r.take(try r.takeLeb128(u32));
26552654 try bw.print(
26562655 \\value_name {s}
26572656 \\version {s}
......@@ -2661,8 +2660,8 @@ const WasmDumper = struct {
26612660 }
26622661 }
26632662
2664 fn parseDumpFeatures(br: *std.io.Reader, bw: *Writer) !void {
2665 const feature_count = try br.takeLeb128(u32);
2663 fn parseDumpFeatures(r: *std.io.Reader, bw: *Writer) !void {
2664 const feature_count = try r.takeLeb128(u32);
26662665 try bw.print(
26672666 \\features {d}
26682667 \\
......@@ -2670,8 +2669,8 @@ const WasmDumper = struct {
26702669
26712670 var index: u32 = 0;
26722671 while (index < feature_count) : (index += 1) {
2673 const prefix_byte = try br.takeLeb128(u8);
2674 const feature_name = try br.take(try br.takeLeb128(u32));
2672 const prefix_byte = try r.takeLeb128(u8);
2673 const feature_name = try r.take(try r.takeLeb128(u32));
26752674 try bw.print(
26762675 \\{c} {s}
26772676 \\
lib/std/fs/File.zig+5-5
......@@ -1350,7 +1350,7 @@ pub const Reader = struct {
13501350 };
13511351 var remaining = std.math.cast(u64, offset) orelse return seek_err;
13521352 while (remaining > 0) {
1353 const n = discard(&r.interface, .limited(remaining)) catch |err| {
1353 const n = discard(&r.interface, .limited64(remaining)) catch |err| {
13541354 r.seek_err = err;
13551355 return err;
13561356 };
......@@ -1385,7 +1385,7 @@ pub const Reader = struct {
13851385 const max_buffers_len = 16;
13861386
13871387 fn stream(io_reader: *std.io.Reader, w: *std.io.Writer, limit: std.io.Limit) std.io.Reader.StreamError!usize {
1388 const r: *Reader = @fieldParentPtr("interface", io_reader);
1388 const r: *Reader = @alignCast(@fieldParentPtr("interface", io_reader));
13891389 switch (r.mode) {
13901390 .positional, .streaming => return w.sendFile(r, limit) catch |write_err| switch (write_err) {
13911391 error.Unimplemented => {
......@@ -1459,7 +1459,7 @@ pub const Reader = struct {
14591459 }
14601460
14611461 fn discard(io_reader: *std.io.Reader, limit: std.io.Limit) std.io.Reader.Error!usize {
1462 const r: *Reader = @fieldParentPtr("interface", io_reader);
1462 const r: *Reader = @alignCast(@fieldParentPtr("interface", io_reader));
14631463 const file = r.file;
14641464 const pos = r.pos;
14651465 switch (r.mode) {
......@@ -1661,7 +1661,7 @@ pub const Writer = struct {
16611661 }
16621662
16631663 pub fn drain(io_w: *std.io.Writer, data: []const []const u8, splat: usize) std.io.Writer.Error!usize {
1664 const w: *Writer = @fieldParentPtr("interface", io_w);
1664 const w: *Writer = @alignCast(@fieldParentPtr("interface", io_w));
16651665 const handle = w.file.handle;
16661666 const buffered = io_w.buffered();
16671667 if (is_windows) switch (w.mode) {
......@@ -1789,7 +1789,7 @@ pub const Writer = struct {
17891789 file_reader: *Reader,
17901790 limit: std.io.Limit,
17911791 ) std.io.Writer.FileError!usize {
1792 const w: *Writer = @fieldParentPtr("interface", io_w);
1792 const w: *Writer = @alignCast(@fieldParentPtr("interface", io_w));
17931793 const out_fd = w.file.handle;
17941794 const in_fd = file_reader.file.handle;
17951795 // TODO try using copy_file_range on FreeBSD
lib/std/io.zig+10
......@@ -24,6 +24,12 @@ pub const Limit = enum(usize) {
2424 return @enumFromInt(n);
2525 }
2626
27 /// Any value grater than `std.math.maxInt(usize)` is interpreted to mean
28 /// `.unlimited`.
29 pub fn limited64(n: u64) Limit {
30 return @enumFromInt(@min(n, std.math.maxInt(usize)));
31 }
32
2733 pub fn countVec(data: []const []const u8) Limit {
2834 var total: usize = 0;
2935 for (data) |d| total += d.len;
......@@ -38,6 +44,10 @@ pub const Limit = enum(usize) {
3844 return @min(n, @intFromEnum(l));
3945 }
4046
47 pub fn minInt64(l: Limit, n: u64) usize {
48 return @min(n, @intFromEnum(l));
49 }
50
4151 pub fn slice(l: Limit, s: []u8) []u8 {
4252 return s[0..l.minInt(s.len)];
4353 }
lib/std/io/Writer.zig+2-2
......@@ -1958,7 +1958,7 @@ pub fn discardingSendFile(w: *Writer, file_reader: *File.Reader, limit: Limit) F
19581958 if (File.Handle == void) return error.Unimplemented;
19591959 w.end = 0;
19601960 if (file_reader.getSize()) |size| {
1961 const n = limit.minInt(size - file_reader.pos);
1961 const n = limit.minInt64(size - file_reader.pos);
19621962 file_reader.seekBy(@intCast(n)) catch return error.Unimplemented;
19631963 w.end = 0;
19641964 return n;
......@@ -2256,7 +2256,7 @@ pub const Allocating = struct {
22562256 defer setArrayList(a, list);
22572257 const pos = file_reader.pos;
22582258 const additional = if (file_reader.getSize()) |size| size - pos else |_| std.atomic.cache_line;
2259 list.ensureUnusedCapacity(gpa, limit.minInt(additional)) catch return error.WriteFailed;
2259 list.ensureUnusedCapacity(gpa, limit.minInt64(additional)) catch return error.WriteFailed;
22602260 const dest = limit.slice(list.unusedCapacitySlice());
22612261 const n = file_reader.read(dest) catch |err| switch (err) {
22622262 error.ReadFailed => return error.ReadFailed,
lib/std/zig/system/linux.zig+1-1
......@@ -391,7 +391,7 @@ pub fn detectNativeCpuAndFeatures() ?Target.Cpu {
391391 const current_arch = builtin.cpu.arch;
392392 switch (current_arch) {
393393 .arm, .armeb, .thumb, .thumbeb => {
394 return ArmCpuinfoParser.parse(current_arch, f.reader()) catch null;
394 return ArmCpuinfoParser.parse(current_arch, f.deprecatedReader()) catch null;
395395 },
396396 .aarch64, .aarch64_be => {
397397 const registers = [12]u64{
src/codegen/c.zig+2-2
......@@ -1295,7 +1295,7 @@ pub const DeclGen = struct {
12951295 }
12961296 const ai = ty.arrayInfo(zcu);
12971297 if (ai.elem_type.eql(.u8, zcu)) {
1298 var literal: StringLiteral = .init(w, ty.arrayLenIncludingSentinel(zcu));
1298 var literal: StringLiteral = .init(w, @intCast(ty.arrayLenIncludingSentinel(zcu)));
12991299 try literal.start();
13001300 var index: usize = 0;
13011301 while (index < ai.len) : (index += 1) {
......@@ -1854,7 +1854,7 @@ pub const DeclGen = struct {
18541854 const ai = ty.arrayInfo(zcu);
18551855 if (ai.elem_type.eql(.u8, zcu)) {
18561856 const c_len = ty.arrayLenIncludingSentinel(zcu);
1857 var literal: StringLiteral = .init(w, c_len);
1857 var literal: StringLiteral = .init(w, @intCast(c_len));
18581858 try literal.start();
18591859 var index: u64 = 0;
18601860 while (index < c_len) : (index += 1)