authorgravatar for github@mjb.ioMichael Bradshaw <github@mjb.io> 2024-06-10 07:43:22-06:00
committergravatar for mlugg@mlugg.co.ukMatthew Lugg <mlugg@mlugg.co.uk> 2024-06-23 04:30:12+01:00
log642093e04bf10f6a9a7c23dfcf219bbbc7d51b54
treea3945fb11a5a6f71834b9aae2d163dd67f14fa46
parent0fcd59eadae468284943895f50bc9fc6d1924154

Rename *[UI]LEB128 functions to *[UI]leb128

18 files changed, 465 insertions(+), 453 deletions(-)

lib/std/Build/Step/CheckObject.zig+64-64
......@@ -1229,17 +1229,17 @@ const MachODumper = struct {
12291229 macho.REBASE_OPCODE_SET_TYPE_IMM => {},
12301230 macho.REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB => {
12311231 seg_id = imm;
1232 offset = try std.leb.readULEB128(u64, reader);
1232 offset = try std.leb.readUleb128(u64, reader);
12331233 },
12341234 macho.REBASE_OPCODE_ADD_ADDR_IMM_SCALED => {
12351235 offset += imm * @sizeOf(u64);
12361236 },
12371237 macho.REBASE_OPCODE_ADD_ADDR_ULEB => {
1238 const addend = try std.leb.readULEB128(u64, reader);
1238 const addend = try std.leb.readUleb128(u64, reader);
12391239 offset += addend;
12401240 },
12411241 macho.REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB => {
1242 const addend = try std.leb.readULEB128(u64, reader);
1242 const addend = try std.leb.readUleb128(u64, reader);
12431243 const seg = ctx.segments.items[seg_id.?];
12441244 const addr = seg.vmaddr + offset;
12451245 try rebases.append(addr);
......@@ -1256,11 +1256,11 @@ const MachODumper = struct {
12561256 ntimes = imm;
12571257 },
12581258 macho.REBASE_OPCODE_DO_REBASE_ULEB_TIMES => {
1259 ntimes = try std.leb.readULEB128(u64, reader);
1259 ntimes = try std.leb.readUleb128(u64, reader);
12601260 },
12611261 macho.REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB => {
1262 ntimes = try std.leb.readULEB128(u64, reader);
1263 skip = try std.leb.readULEB128(u64, reader);
1262 ntimes = try std.leb.readUleb128(u64, reader);
1263 skip = try std.leb.readUleb128(u64, reader);
12641264 },
12651265 else => unreachable,
12661266 }
......@@ -1361,7 +1361,7 @@ const MachODumper = struct {
13611361 },
13621362 macho.BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB => {
13631363 seg_id = imm;
1364 offset = try std.leb.readULEB128(u64, reader);
1364 offset = try std.leb.readUleb128(u64, reader);
13651365 },
13661366 macho.BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM => {
13671367 name_buf.clearRetainingCapacity();
......@@ -1369,10 +1369,10 @@ const MachODumper = struct {
13691369 try name_buf.append(0);
13701370 },
13711371 macho.BIND_OPCODE_SET_ADDEND_SLEB => {
1372 addend = try std.leb.readILEB128(i64, reader);
1372 addend = try std.leb.readIleb128(i64, reader);
13731373 },
13741374 macho.BIND_OPCODE_ADD_ADDR_ULEB => {
1375 const x = try std.leb.readULEB128(u64, reader);
1375 const x = try std.leb.readUleb128(u64, reader);
13761376 offset = @intCast(@as(i64, @intCast(offset)) + @as(i64, @bitCast(x)));
13771377 },
13781378 macho.BIND_OPCODE_DO_BIND,
......@@ -1387,14 +1387,14 @@ const MachODumper = struct {
13871387 switch (opc) {
13881388 macho.BIND_OPCODE_DO_BIND => {},
13891389 macho.BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB => {
1390 add_addr = try std.leb.readULEB128(u64, reader);
1390 add_addr = try std.leb.readUleb128(u64, reader);
13911391 },
13921392 macho.BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED => {
13931393 add_addr = imm * @sizeOf(u64);
13941394 },
13951395 macho.BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB => {
1396 count = try std.leb.readULEB128(u64, reader);
1397 skip = try std.leb.readULEB128(u64, reader);
1396 count = try std.leb.readUleb128(u64, reader);
1397 skip = try std.leb.readUleb128(u64, reader);
13981398 },
13991399 else => unreachable,
14001400 }
......@@ -1463,11 +1463,11 @@ const MachODumper = struct {
14631463 return std.io.fixedBufferStream(it.data[it.pos..]);
14641464 }
14651465
1466 fn readULEB128(it: *TrieIterator) !u64 {
1466 fn readUleb128(it: *TrieIterator) !u64 {
14671467 var stream = it.getStream();
14681468 var creader = std.io.countingReader(stream.reader());
14691469 const reader = creader.reader();
1470 const value = try std.leb.readULEB128(u64, reader);
1470 const value = try std.leb.readUleb128(u64, reader);
14711471 it.pos += creader.bytes_read;
14721472 return value;
14731473 }
......@@ -1538,12 +1538,12 @@ const MachODumper = struct {
15381538 prefix: []const u8,
15391539 exports: *std.ArrayList(Export),
15401540 ) !void {
1541 const size = try it.readULEB128();
1541 const size = try it.readUleb128();
15421542 if (size > 0) {
1543 const flags = try it.readULEB128();
1543 const flags = try it.readUleb128();
15441544 switch (flags) {
15451545 macho.EXPORT_SYMBOL_FLAGS_REEXPORT => {
1546 const ord = try it.readULEB128();
1546 const ord = try it.readUleb128();
15471547 const name = try arena.dupe(u8, try it.readString());
15481548 try exports.append(.{
15491549 .name = if (name.len > 0) name else prefix,
......@@ -1552,8 +1552,8 @@ const MachODumper = struct {
15521552 });
15531553 },
15541554 macho.EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER => {
1555 const stub_offset = try it.readULEB128();
1556 const resolver_offset = try it.readULEB128();
1555 const stub_offset = try it.readUleb128();
1556 const resolver_offset = try it.readUleb128();
15571557 try exports.append(.{
15581558 .name = prefix,
15591559 .tag = .stub_resolver,
......@@ -1564,7 +1564,7 @@ const MachODumper = struct {
15641564 });
15651565 },
15661566 else => {
1567 const vmoff = try it.readULEB128();
1567 const vmoff = try it.readUleb128();
15681568 try exports.append(.{
15691569 .name = prefix,
15701570 .tag = .@"export",
......@@ -1586,7 +1586,7 @@ const MachODumper = struct {
15861586 const nedges = try it.readByte();
15871587 for (0..nedges) |_| {
15881588 const label = try it.readString();
1589 const off = try it.readULEB128();
1589 const off = try it.readUleb128();
15901590 const prefix_label = try std.fmt.allocPrint(arena, "{s}{s}", .{ prefix, label });
15911591 const curr = it.pos;
15921592 it.pos = off;
......@@ -2413,7 +2413,7 @@ const WasmDumper = struct {
24132413 return step.fail("Found invalid section id '{d}'", .{current_byte});
24142414 };
24152415
2416 const section_length = try std.leb.readULEB128(u32, reader);
2416 const section_length = try std.leb.readUleb128(u32, reader);
24172417 try parseAndDumpSection(step, section, bytes[fbs.pos..][0..section_length], writer);
24182418 fbs.pos += section_length;
24192419 } else |_| {} // reached end of stream
......@@ -2451,12 +2451,12 @@ const WasmDumper = struct {
24512451 .code,
24522452 .data,
24532453 => {
2454 const entries = try std.leb.readULEB128(u32, reader);
2454 const entries = try std.leb.readUleb128(u32, reader);
24552455 try writer.print("\nentries {d}\n", .{entries});
24562456 try parseSection(step, section, data[fbs.pos..], entries, writer);
24572457 },
24582458 .custom => {
2459 const name_length = try std.leb.readULEB128(u32, reader);
2459 const name_length = try std.leb.readUleb128(u32, reader);
24602460 const name = data[fbs.pos..][0..name_length];
24612461 fbs.pos += name_length;
24622462 try writer.print("\nname {s}\n", .{name});
......@@ -2471,11 +2471,11 @@ const WasmDumper = struct {
24712471 // TODO: Implement parsing and dumping other custom sections (such as relocations)
24722472 },
24732473 .start => {
2474 const start = try std.leb.readULEB128(u32, reader);
2474 const start = try std.leb.readUleb128(u32, reader);
24752475 try writer.print("\nstart {d}\n", .{start});
24762476 },
24772477 .data_count => {
2478 const count = try std.leb.readULEB128(u32, reader);
2478 const count = try std.leb.readUleb128(u32, reader);
24792479 try writer.print("\ncount {d}\n", .{count});
24802480 },
24812481 else => {}, // skip unknown sections
......@@ -2494,13 +2494,13 @@ const WasmDumper = struct {
24942494 if (func_type != std.wasm.function_type) {
24952495 return step.fail("expected function type, found byte '{d}'", .{func_type});
24962496 }
2497 const params = try std.leb.readULEB128(u32, reader);
2497 const params = try std.leb.readUleb128(u32, reader);
24982498 try writer.print("params {d}\n", .{params});
24992499 var index: u32 = 0;
25002500 while (index < params) : (index += 1) {
25012501 _ = try parseDumpType(step, std.wasm.Valtype, reader, writer);
25022502 } else index = 0;
2503 const returns = try std.leb.readULEB128(u32, reader);
2503 const returns = try std.leb.readUleb128(u32, reader);
25042504 try writer.print("returns {d}\n", .{returns});
25052505 while (index < returns) : (index += 1) {
25062506 _ = try parseDumpType(step, std.wasm.Valtype, reader, writer);
......@@ -2510,10 +2510,10 @@ const WasmDumper = struct {
25102510 .import => {
25112511 var i: u32 = 0;
25122512 while (i < entries) : (i += 1) {
2513 const module_name_len = try std.leb.readULEB128(u32, reader);
2513 const module_name_len = try std.leb.readUleb128(u32, reader);
25142514 const module_name = data[fbs.pos..][0..module_name_len];
25152515 fbs.pos += module_name_len;
2516 const name_len = try std.leb.readULEB128(u32, reader);
2516 const name_len = try std.leb.readUleb128(u32, reader);
25172517 const name = data[fbs.pos..][0..name_len];
25182518 fbs.pos += name_len;
25192519
......@@ -2529,14 +2529,14 @@ const WasmDumper = struct {
25292529 try writer.writeByte('\n');
25302530 switch (kind) {
25312531 .function => {
2532 try writer.print("index {d}\n", .{try std.leb.readULEB128(u32, reader)});
2532 try writer.print("index {d}\n", .{try std.leb.readUleb128(u32, reader)});
25332533 },
25342534 .memory => {
25352535 try parseDumpLimits(reader, writer);
25362536 },
25372537 .global => {
25382538 _ = try parseDumpType(step, std.wasm.Valtype, reader, writer);
2539 try writer.print("mutable {}\n", .{0x01 == try std.leb.readULEB128(u32, reader)});
2539 try writer.print("mutable {}\n", .{0x01 == try std.leb.readUleb128(u32, reader)});
25402540 },
25412541 .table => {
25422542 _ = try parseDumpType(step, std.wasm.RefType, reader, writer);
......@@ -2548,7 +2548,7 @@ const WasmDumper = struct {
25482548 .function => {
25492549 var i: u32 = 0;
25502550 while (i < entries) : (i += 1) {
2551 try writer.print("index {d}\n", .{try std.leb.readULEB128(u32, reader)});
2551 try writer.print("index {d}\n", .{try std.leb.readUleb128(u32, reader)});
25522552 }
25532553 },
25542554 .table => {
......@@ -2568,21 +2568,21 @@ const WasmDumper = struct {
25682568 var i: u32 = 0;
25692569 while (i < entries) : (i += 1) {
25702570 _ = try parseDumpType(step, std.wasm.Valtype, reader, writer);
2571 try writer.print("mutable {}\n", .{0x01 == try std.leb.readULEB128(u1, reader)});
2571 try writer.print("mutable {}\n", .{0x01 == try std.leb.readUleb128(u1, reader)});
25722572 try parseDumpInit(step, reader, writer);
25732573 }
25742574 },
25752575 .@"export" => {
25762576 var i: u32 = 0;
25772577 while (i < entries) : (i += 1) {
2578 const name_len = try std.leb.readULEB128(u32, reader);
2578 const name_len = try std.leb.readUleb128(u32, reader);
25792579 const name = data[fbs.pos..][0..name_len];
25802580 fbs.pos += name_len;
2581 const kind_byte = try std.leb.readULEB128(u8, reader);
2581 const kind_byte = try std.leb.readUleb128(u8, reader);
25822582 const kind = std.meta.intToEnum(std.wasm.ExternalKind, kind_byte) catch {
25832583 return step.fail("invalid export kind value '{d}'", .{kind_byte});
25842584 };
2585 const index = try std.leb.readULEB128(u32, reader);
2585 const index = try std.leb.readUleb128(u32, reader);
25862586 try writer.print(
25872587 \\name {s}
25882588 \\kind {s}
......@@ -2594,14 +2594,14 @@ const WasmDumper = struct {
25942594 .element => {
25952595 var i: u32 = 0;
25962596 while (i < entries) : (i += 1) {
2597 try writer.print("table index {d}\n", .{try std.leb.readULEB128(u32, reader)});
2597 try writer.print("table index {d}\n", .{try std.leb.readUleb128(u32, reader)});
25982598 try parseDumpInit(step, reader, writer);
25992599
2600 const function_indexes = try std.leb.readULEB128(u32, reader);
2600 const function_indexes = try std.leb.readUleb128(u32, reader);
26012601 var function_index: u32 = 0;
26022602 try writer.print("indexes {d}\n", .{function_indexes});
26032603 while (function_index < function_indexes) : (function_index += 1) {
2604 try writer.print("index {d}\n", .{try std.leb.readULEB128(u32, reader)});
2604 try writer.print("index {d}\n", .{try std.leb.readUleb128(u32, reader)});
26052605 }
26062606 }
26072607 },
......@@ -2609,9 +2609,9 @@ const WasmDumper = struct {
26092609 .data => {
26102610 var i: u32 = 0;
26112611 while (i < entries) : (i += 1) {
2612 const flags = try std.leb.readULEB128(u32, reader);
2612 const flags = try std.leb.readUleb128(u32, reader);
26132613 const index = if (flags & 0x02 != 0)
2614 try std.leb.readULEB128(u32, reader)
2614 try std.leb.readUleb128(u32, reader)
26152615 else
26162616 0;
26172617 try writer.print("memory index 0x{x}\n", .{index});
......@@ -2619,7 +2619,7 @@ const WasmDumper = struct {
26192619 try parseDumpInit(step, reader, writer);
26202620 }
26212621
2622 const size = try std.leb.readULEB128(u32, reader);
2622 const size = try std.leb.readUleb128(u32, reader);
26232623 try writer.print("size {d}\n", .{size});
26242624 try reader.skipBytes(size, .{}); // we do not care about the content of the segments
26252625 }
......@@ -2638,12 +2638,12 @@ const WasmDumper = struct {
26382638 }
26392639
26402640 fn parseDumpLimits(reader: anytype, writer: anytype) !void {
2641 const flags = try std.leb.readULEB128(u8, reader);
2642 const min = try std.leb.readULEB128(u32, reader);
2641 const flags = try std.leb.readUleb128(u8, reader);
2642 const min = try std.leb.readUleb128(u32, reader);
26432643
26442644 try writer.print("min {x}\n", .{min});
26452645 if (flags != 0) {
2646 try writer.print("max {x}\n", .{try std.leb.readULEB128(u32, reader)});
2646 try writer.print("max {x}\n", .{try std.leb.readUleb128(u32, reader)});
26472647 }
26482648 }
26492649
......@@ -2653,14 +2653,14 @@ const WasmDumper = struct {
26532653 return step.fail("invalid wasm opcode '{d}'", .{byte});
26542654 };
26552655 switch (opcode) {
2656 .i32_const => try writer.print("i32.const {x}\n", .{try std.leb.readILEB128(i32, reader)}),
2657 .i64_const => try writer.print("i64.const {x}\n", .{try std.leb.readILEB128(i64, reader)}),
2656 .i32_const => try writer.print("i32.const {x}\n", .{try std.leb.readIleb128(i32, reader)}),
2657 .i64_const => try writer.print("i64.const {x}\n", .{try std.leb.readIleb128(i64, reader)}),
26582658 .f32_const => try writer.print("f32.const {x}\n", .{@as(f32, @bitCast(try reader.readInt(u32, .little)))}),
26592659 .f64_const => try writer.print("f64.const {x}\n", .{@as(f64, @bitCast(try reader.readInt(u64, .little)))}),
2660 .global_get => try writer.print("global.get {x}\n", .{try std.leb.readULEB128(u32, reader)}),
2660 .global_get => try writer.print("global.get {x}\n", .{try std.leb.readUleb128(u32, reader)}),
26612661 else => unreachable,
26622662 }
2663 const end_opcode = try std.leb.readULEB128(u8, reader);
2663 const end_opcode = try std.leb.readUleb128(u8, reader);
26642664 if (end_opcode != std.wasm.opcode(.end)) {
26652665 return step.fail("expected 'end' opcode in init expression", .{});
26662666 }
......@@ -2673,8 +2673,8 @@ const WasmDumper = struct {
26732673 // The module name subsection ... consists of a single name
26742674 // that is assigned to the module itself.
26752675 .module => {
2676 const size = try std.leb.readULEB128(u32, reader);
2677 const name_len = try std.leb.readULEB128(u32, reader);
2676 const size = try std.leb.readUleb128(u32, reader);
2677 const name_len = try std.leb.readUleb128(u32, reader);
26782678 if (size != name_len + 1) return error.BadSubsectionSize;
26792679 if (reader.context.pos + name_len > data.len) return error.UnexpectedEndOfStream;
26802680 try writer.print("name {s}\n", .{data[reader.context.pos..][0..name_len]});
......@@ -2684,16 +2684,16 @@ const WasmDumper = struct {
26842684 // The function name subsection ... consists of a name map
26852685 // assigning function names to function indices.
26862686 .function, .global, .data_segment => {
2687 const size = try std.leb.readULEB128(u32, reader);
2688 const entries = try std.leb.readULEB128(u32, reader);
2687 const size = try std.leb.readUleb128(u32, reader);
2688 const entries = try std.leb.readUleb128(u32, reader);
26892689 try writer.print(
26902690 \\size {d}
26912691 \\names {d}
26922692 \\
26932693 , .{ size, entries });
26942694 for (0..entries) |_| {
2695 const index = try std.leb.readULEB128(u32, reader);
2696 const name_len = try std.leb.readULEB128(u32, reader);
2695 const index = try std.leb.readUleb128(u32, reader);
2696 const name_len = try std.leb.readUleb128(u32, reader);
26972697 if (reader.context.pos + name_len > data.len) return error.UnexpectedEndOfStream;
26982698 const name = data[reader.context.pos..][0..name_len];
26992699 reader.context.pos += name.len;
......@@ -2719,15 +2719,15 @@ const WasmDumper = struct {
27192719 }
27202720
27212721 fn parseDumpProducers(reader: anytype, writer: anytype, data: []const u8) !void {
2722 const field_count = try std.leb.readULEB128(u32, reader);
2722 const field_count = try std.leb.readUleb128(u32, reader);
27232723 try writer.print("fields {d}\n", .{field_count});
27242724 var current_field: u32 = 0;
27252725 while (current_field < field_count) : (current_field += 1) {
2726 const field_name_length = try std.leb.readULEB128(u32, reader);
2726 const field_name_length = try std.leb.readUleb128(u32, reader);
27272727 const field_name = data[reader.context.pos..][0..field_name_length];
27282728 reader.context.pos += field_name_length;
27292729
2730 const value_count = try std.leb.readULEB128(u32, reader);
2730 const value_count = try std.leb.readUleb128(u32, reader);
27312731 try writer.print(
27322732 \\field_name {s}
27332733 \\values {d}
......@@ -2735,11 +2735,11 @@ const WasmDumper = struct {
27352735 try writer.writeByte('\n');
27362736 var current_value: u32 = 0;
27372737 while (current_value < value_count) : (current_value += 1) {
2738 const value_length = try std.leb.readULEB128(u32, reader);
2738 const value_length = try std.leb.readUleb128(u32, reader);
27392739 const value = data[reader.context.pos..][0..value_length];
27402740 reader.context.pos += value_length;
27412741
2742 const version_length = try std.leb.readULEB128(u32, reader);
2742 const version_length = try std.leb.readUleb128(u32, reader);
27432743 const version = data[reader.context.pos..][0..version_length];
27442744 reader.context.pos += version_length;
27452745
......@@ -2753,13 +2753,13 @@ const WasmDumper = struct {
27532753 }
27542754
27552755 fn parseDumpFeatures(reader: anytype, writer: anytype, data: []const u8) !void {
2756 const feature_count = try std.leb.readULEB128(u32, reader);
2756 const feature_count = try std.leb.readUleb128(u32, reader);
27572757 try writer.print("features {d}\n", .{feature_count});
27582758
27592759 var index: u32 = 0;
27602760 while (index < feature_count) : (index += 1) {
2761 const prefix_byte = try std.leb.readULEB128(u8, reader);
2762 const name_length = try std.leb.readULEB128(u32, reader);
2761 const prefix_byte = try std.leb.readUleb128(u8, reader);
2762 const name_length = try std.leb.readUleb128(u32, reader);
27632763 const feature_name = data[reader.context.pos..][0..name_length];
27642764 reader.context.pos += name_length;
27652765
lib/std/compress/xz.zig+3-3
......@@ -88,15 +88,15 @@ pub fn Decompress(comptime ReaderType: type) type {
8888
8989 const counting_reader = counter.reader();
9090
91 const record_count = try std.leb.readULEB128(u64, counting_reader);
91 const record_count = try std.leb.readUleb128(u64, counting_reader);
9292 if (record_count != self.block_decoder.block_count)
9393 return error.CorruptInput;
9494
9595 var i: usize = 0;
9696 while (i < record_count) : (i += 1) {
9797 // TODO: validate records
98 _ = try std.leb.readULEB128(u64, counting_reader);
99 _ = try std.leb.readULEB128(u64, counting_reader);
98 _ = try std.leb.readUleb128(u64, counting_reader);
99 _ = try std.leb.readUleb128(u64, counting_reader);
100100 }
101101
102102 while (counter.bytes_read % 4 != 0) {
lib/std/compress/xz/block.zig+4-4
......@@ -111,10 +111,10 @@ pub fn Decoder(comptime ReaderType: type) type {
111111 return error.Unsupported;
112112
113113 if (flags.has_packed_size)
114 packed_size = try std.leb.readULEB128(u64, header_reader);
114 packed_size = try std.leb.readUleb128(u64, header_reader);
115115
116116 if (flags.has_unpacked_size)
117 unpacked_size = try std.leb.readULEB128(u64, header_reader);
117 unpacked_size = try std.leb.readUleb128(u64, header_reader);
118118
119119 const FilterId = enum(u64) {
120120 lzma2 = 0x21,
......@@ -123,7 +123,7 @@ pub fn Decoder(comptime ReaderType: type) type {
123123
124124 const filter_id = @as(
125125 FilterId,
126 @enumFromInt(try std.leb.readULEB128(u64, header_reader)),
126 @enumFromInt(try std.leb.readUleb128(u64, header_reader)),
127127 );
128128
129129 if (@intFromEnum(filter_id) >= 0x4000_0000_0000_0000)
......@@ -132,7 +132,7 @@ pub fn Decoder(comptime ReaderType: type) type {
132132 if (filter_id != .lzma2)
133133 return error.Unsupported;
134134
135 const properties_size = try std.leb.readULEB128(u64, header_reader);
135 const properties_size = try std.leb.readUleb128(u64, header_reader);
136136 if (properties_size != 1)
137137 return error.CorruptInput;
138138
lib/std/dwarf.zig+2-2
......@@ -2762,11 +2762,11 @@ pub const FixedBufferReader = struct {
27622762 }
27632763
27642764 fn readUleb128(fbr: *FixedBufferReader, comptime T: type) Error!T {
2765 return std.leb.readULEB128(T, fbr);
2765 return std.leb.readUleb128(T, fbr);
27662766 }
27672767
27682768 fn readIleb128(fbr: *FixedBufferReader, comptime T: type) Error!T {
2769 return std.leb.readILEB128(T, fbr);
2769 return std.leb.readIleb128(T, fbr);
27702770 }
27712771
27722772 fn readAddress(fbr: *FixedBufferReader, format: Format) Error!u64 {
lib/std/dwarf/call_frame.zig+24-24
......@@ -53,7 +53,7 @@ const Opcode = enum(u8) {
5353
5454fn readBlock(stream: *std.io.FixedBufferStream([]const u8)) ![]const u8 {
5555 const reader = stream.reader();
56 const block_len = try leb.readULEB128(usize, reader);
56 const block_len = try leb.readUleb128(usize, reader);
5757 if (stream.pos + block_len > stream.buffer.len) return error.InvalidOperand;
5858
5959 const block = stream.buffer[stream.pos..][0..block_len];
......@@ -163,7 +163,7 @@ pub const Instruction = union(Opcode) {
163163 .offset => .{
164164 .offset = .{
165165 .register = value,
166 .offset = try leb.readULEB128(u64, reader),
166 .offset = try leb.readUleb128(u64, reader),
167167 },
168168 },
169169 .restore => .{
......@@ -201,47 +201,47 @@ pub const Instruction = union(Opcode) {
201201 },
202202 .offset_extended => .{
203203 .offset_extended = .{
204 .register = try leb.readULEB128(u8, reader),
205 .offset = try leb.readULEB128(u64, reader),
204 .register = try leb.readUleb128(u8, reader),
205 .offset = try leb.readUleb128(u64, reader),
206206 },
207207 },
208208 .restore_extended => .{
209209 .restore_extended = .{
210 .register = try leb.readULEB128(u8, reader),
210 .register = try leb.readUleb128(u8, reader),
211211 },
212212 },
213213 .undefined => .{
214214 .undefined = .{
215 .register = try leb.readULEB128(u8, reader),
215 .register = try leb.readUleb128(u8, reader),
216216 },
217217 },
218218 .same_value => .{
219219 .same_value = .{
220 .register = try leb.readULEB128(u8, reader),
220 .register = try leb.readUleb128(u8, reader),
221221 },
222222 },
223223 .register => .{
224224 .register = .{
225 .register = try leb.readULEB128(u8, reader),
226 .target_register = try leb.readULEB128(u8, reader),
225 .register = try leb.readUleb128(u8, reader),
226 .target_register = try leb.readUleb128(u8, reader),
227227 },
228228 },
229229 .remember_state => .{ .remember_state = {} },
230230 .restore_state => .{ .restore_state = {} },
231231 .def_cfa => .{
232232 .def_cfa = .{
233 .register = try leb.readULEB128(u8, reader),
234 .offset = try leb.readULEB128(u64, reader),
233 .register = try leb.readUleb128(u8, reader),
234 .offset = try leb.readUleb128(u64, reader),
235235 },
236236 },
237237 .def_cfa_register => .{
238238 .def_cfa_register = .{
239 .register = try leb.readULEB128(u8, reader),
239 .register = try leb.readUleb128(u8, reader),
240240 },
241241 },
242242 .def_cfa_offset => .{
243243 .def_cfa_offset = .{
244 .offset = try leb.readULEB128(u64, reader),
244 .offset = try leb.readUleb128(u64, reader),
245245 },
246246 },
247247 .def_cfa_expression => .{
......@@ -251,42 +251,42 @@ pub const Instruction = union(Opcode) {
251251 },
252252 .expression => .{
253253 .expression = .{
254 .register = try leb.readULEB128(u8, reader),
254 .register = try leb.readUleb128(u8, reader),
255255 .block = try readBlock(stream),
256256 },
257257 },
258258 .offset_extended_sf => .{
259259 .offset_extended_sf = .{
260 .register = try leb.readULEB128(u8, reader),
261 .offset = try leb.readILEB128(i64, reader),
260 .register = try leb.readUleb128(u8, reader),
261 .offset = try leb.readIleb128(i64, reader),
262262 },
263263 },
264264 .def_cfa_sf => .{
265265 .def_cfa_sf = .{
266 .register = try leb.readULEB128(u8, reader),
267 .offset = try leb.readILEB128(i64, reader),
266 .register = try leb.readUleb128(u8, reader),
267 .offset = try leb.readIleb128(i64, reader),
268268 },
269269 },
270270 .def_cfa_offset_sf => .{
271271 .def_cfa_offset_sf = .{
272 .offset = try leb.readILEB128(i64, reader),
272 .offset = try leb.readIleb128(i64, reader),
273273 },
274274 },
275275 .val_offset => .{
276276 .val_offset = .{
277 .register = try leb.readULEB128(u8, reader),
278 .offset = try leb.readULEB128(u64, reader),
277 .register = try leb.readUleb128(u8, reader),
278 .offset = try leb.readUleb128(u64, reader),
279279 },
280280 },
281281 .val_offset_sf => .{
282282 .val_offset_sf = .{
283 .register = try leb.readULEB128(u8, reader),
284 .offset = try leb.readILEB128(i64, reader),
283 .register = try leb.readUleb128(u8, reader),
284 .offset = try leb.readIleb128(i64, reader),
285285 },
286286 },
287287 .val_expression => .{
288288 .val_expression = .{
289 .register = try leb.readULEB128(u8, reader),
289 .register = try leb.readUleb128(u8, reader),
290290 .block = try readBlock(stream),
291291 },
292292 },
lib/std/dwarf/expressions.zig+33-33
......@@ -219,28 +219,28 @@ pub fn StackMachine(comptime options: ExpressionOptions) type {
219219 OP.constx,
220220 OP.convert,
221221 OP.reinterpret,
222 => generic(try leb.readULEB128(u64, reader)),
222 => generic(try leb.readUleb128(u64, reader)),
223223 OP.consts,
224224 OP.fbreg,
225 => generic(try leb.readILEB128(i64, reader)),
225 => generic(try leb.readIleb128(i64, reader)),
226226 OP.lit0...OP.lit31 => |n| generic(n - OP.lit0),
227227 OP.reg0...OP.reg31 => |n| .{ .register = n - OP.reg0 },
228228 OP.breg0...OP.breg31 => |n| .{ .base_register = .{
229229 .base_register = n - OP.breg0,
230 .offset = try leb.readILEB128(i64, reader),
230 .offset = try leb.readIleb128(i64, reader),
231231 } },
232 OP.regx => .{ .register = try leb.readULEB128(u8, reader) },
232 OP.regx => .{ .register = try leb.readUleb128(u8, reader) },
233233 OP.bregx => blk: {
234 const base_register = try leb.readULEB128(u8, reader);
235 const offset = try leb.readILEB128(i64, reader);
234 const base_register = try leb.readUleb128(u8, reader);
235 const offset = try leb.readIleb128(i64, reader);
236236 break :blk .{ .base_register = .{
237237 .base_register = base_register,
238238 .offset = offset,
239239 } };
240240 },
241241 OP.regval_type => blk: {
242 const register = try leb.readULEB128(u8, reader);
243 const type_offset = try leb.readULEB128(addr_type, reader);
242 const register = try leb.readUleb128(u8, reader);
243 const type_offset = try leb.readUleb128(addr_type, reader);
244244 break :blk .{ .register_type = .{
245245 .register = register,
246246 .type_offset = type_offset,
......@@ -248,20 +248,20 @@ pub fn StackMachine(comptime options: ExpressionOptions) type {
248248 },
249249 OP.piece => .{
250250 .composite_location = .{
251 .size = try leb.readULEB128(u8, reader),
251 .size = try leb.readUleb128(u8, reader),
252252 .offset = 0,
253253 },
254254 },
255255 OP.bit_piece => blk: {
256 const size = try leb.readULEB128(u8, reader);
257 const offset = try leb.readILEB128(i64, reader);
256 const size = try leb.readUleb128(u8, reader);
257 const offset = try leb.readIleb128(i64, reader);
258258 break :blk .{ .composite_location = .{
259259 .size = size,
260260 .offset = offset,
261261 } };
262262 },
263263 OP.implicit_value, OP.entry_value => blk: {
264 const size = try leb.readULEB128(u8, reader);
264 const size = try leb.readUleb128(u8, reader);
265265 if (stream.pos + size > stream.buffer.len) return error.InvalidExpression;
266266 const block = stream.buffer[stream.pos..][0..size];
267267 stream.pos += size;
......@@ -270,7 +270,7 @@ pub fn StackMachine(comptime options: ExpressionOptions) type {
270270 };
271271 },
272272 OP.const_type => blk: {
273 const type_offset = try leb.readULEB128(addr_type, reader);
273 const type_offset = try leb.readUleb128(addr_type, reader);
274274 const size = try reader.readByte();
275275 if (stream.pos + size > stream.buffer.len) return error.InvalidExpression;
276276 const value_bytes = stream.buffer[stream.pos..][0..size];
......@@ -285,7 +285,7 @@ pub fn StackMachine(comptime options: ExpressionOptions) type {
285285 => .{
286286 .deref_type = .{
287287 .size = try reader.readByte(),
288 .type_offset = try leb.readULEB128(addr_type, reader),
288 .type_offset = try leb.readUleb128(addr_type, reader),
289289 },
290290 },
291291 OP.lo_user...OP.hi_user => return error.UnimplementedUserOpcode,
......@@ -863,11 +863,11 @@ pub fn Builder(comptime options: ExpressionOptions) type {
863863 else => switch (@typeInfo(T).Int.signedness) {
864864 .unsigned => {
865865 try writer.writeByte(OP.constu);
866 try leb.writeULEB128(writer, value);
866 try leb.writeUleb128(writer, value);
867867 },
868868 .signed => {
869869 try writer.writeByte(OP.consts);
870 try leb.writeILEB128(writer, value);
870 try leb.writeIleb128(writer, value);
871871 },
872872 },
873873 }
......@@ -875,14 +875,14 @@ pub fn Builder(comptime options: ExpressionOptions) type {
875875
876876 pub fn writeConstx(writer: anytype, debug_addr_offset: anytype) !void {
877877 try writer.writeByte(OP.constx);
878 try leb.writeULEB128(writer, debug_addr_offset);
878 try leb.writeUleb128(writer, debug_addr_offset);
879879 }
880880
881881 pub fn writeConstType(writer: anytype, die_offset: anytype, value_bytes: []const u8) !void {
882882 if (options.call_frame_context) return error.InvalidCFAOpcode;
883883 if (value_bytes.len > 0xff) return error.InvalidTypeLength;
884884 try writer.writeByte(OP.const_type);
885 try leb.writeULEB128(writer, die_offset);
885 try leb.writeUleb128(writer, die_offset);
886886 try writer.writeByte(@intCast(value_bytes.len));
887887 try writer.writeAll(value_bytes);
888888 }
......@@ -895,32 +895,32 @@ pub fn Builder(comptime options: ExpressionOptions) type {
895895 pub fn writeAddrx(writer: anytype, debug_addr_offset: anytype) !void {
896896 if (options.call_frame_context) return error.InvalidCFAOpcode;
897897 try writer.writeByte(OP.addrx);
898 try leb.writeULEB128(writer, debug_addr_offset);
898 try leb.writeUleb128(writer, debug_addr_offset);
899899 }
900900
901901 // 2.5.1.2: Register Values
902902 pub fn writeFbreg(writer: anytype, offset: anytype) !void {
903903 try writer.writeByte(OP.fbreg);
904 try leb.writeILEB128(writer, offset);
904 try leb.writeIleb128(writer, offset);
905905 }
906906
907907 pub fn writeBreg(writer: anytype, register: u8, offset: anytype) !void {
908908 if (register > 31) return error.InvalidRegister;
909909 try writer.writeByte(OP.breg0 + register);
910 try leb.writeILEB128(writer, offset);
910 try leb.writeIleb128(writer, offset);
911911 }
912912
913913 pub fn writeBregx(writer: anytype, register: anytype, offset: anytype) !void {
914914 try writer.writeByte(OP.bregx);
915 try leb.writeULEB128(writer, register);
916 try leb.writeILEB128(writer, offset);
915 try leb.writeUleb128(writer, register);
916 try leb.writeIleb128(writer, offset);
917917 }
918918
919919 pub fn writeRegvalType(writer: anytype, register: anytype, offset: anytype) !void {
920920 if (options.call_frame_context) return error.InvalidCFAOpcode;
921921 try writer.writeByte(OP.regval_type);
922 try leb.writeULEB128(writer, register);
923 try leb.writeULEB128(writer, offset);
922 try leb.writeUleb128(writer, register);
923 try leb.writeUleb128(writer, offset);
924924 }
925925
926926 // 2.5.1.3: Stack Operations
......@@ -943,20 +943,20 @@ pub fn Builder(comptime options: ExpressionOptions) type {
943943 if (options.call_frame_context) return error.InvalidCFAOpcode;
944944 try writer.writeByte(OP.deref_type);
945945 try writer.writeByte(size);
946 try leb.writeULEB128(writer, die_offset);
946 try leb.writeUleb128(writer, die_offset);
947947 }
948948
949949 pub fn writeXDerefType(writer: anytype, size: u8, die_offset: anytype) !void {
950950 try writer.writeByte(OP.xderef_type);
951951 try writer.writeByte(size);
952 try leb.writeULEB128(writer, die_offset);
952 try leb.writeUleb128(writer, die_offset);
953953 }
954954
955955 // 2.5.1.4: Arithmetic and Logical Operations
956956
957957 pub fn writePlusUconst(writer: anytype, uint_value: anytype) !void {
958958 try writer.writeByte(OP.plus_uconst);
959 try leb.writeULEB128(writer, uint_value);
959 try leb.writeUleb128(writer, uint_value);
960960 }
961961
962962 // 2.5.1.5: Control Flow Operations
......@@ -991,20 +991,20 @@ pub fn Builder(comptime options: ExpressionOptions) type {
991991 pub fn writeConvert(writer: anytype, die_offset: anytype) !void {
992992 if (options.call_frame_context) return error.InvalidCFAOpcode;
993993 try writer.writeByte(OP.convert);
994 try leb.writeULEB128(writer, die_offset);
994 try leb.writeUleb128(writer, die_offset);
995995 }
996996
997997 pub fn writeReinterpret(writer: anytype, die_offset: anytype) !void {
998998 if (options.call_frame_context) return error.InvalidCFAOpcode;
999999 try writer.writeByte(OP.reinterpret);
1000 try leb.writeULEB128(writer, die_offset);
1000 try leb.writeUleb128(writer, die_offset);
10011001 }
10021002
10031003 // 2.5.1.7: Special Operations
10041004
10051005 pub fn writeEntryValue(writer: anytype, expression: []const u8) !void {
10061006 try writer.writeByte(OP.entry_value);
1007 try leb.writeULEB128(writer, expression.len);
1007 try leb.writeUleb128(writer, expression.len);
10081008 try writer.writeAll(expression);
10091009 }
10101010
......@@ -1015,12 +1015,12 @@ pub fn Builder(comptime options: ExpressionOptions) type {
10151015
10161016 pub fn writeRegx(writer: anytype, register: anytype) !void {
10171017 try writer.writeByte(OP.regx);
1018 try leb.writeULEB128(writer, register);
1018 try leb.writeUleb128(writer, register);
10191019 }
10201020
10211021 pub fn writeImplicitValue(writer: anytype, value_bytes: []const u8) !void {
10221022 try writer.writeByte(OP.implicit_value);
1023 try leb.writeULEB128(writer, value_bytes.len);
1023 try leb.writeUleb128(writer, value_bytes.len);
10241024 try writer.writeAll(value_bytes);
10251025 }
10261026 };
lib/std/leb128.zig+24-12
......@@ -3,7 +3,7 @@ const testing = std.testing;
33
44/// Read a single unsigned LEB128 value from the given reader as type T,
55/// or error.Overflow if the value cannot fit.
6pub fn readULEB128(comptime T: type, reader: anytype) !T {
6pub fn readUleb128(comptime T: type, reader: anytype) !T {
77 const U = if (@typeInfo(T).Int.bits < 8) u8 else T;
88 const ShiftT = std.math.Log2Int(U);
99
......@@ -32,8 +32,11 @@ pub fn readULEB128(comptime T: type, reader: anytype) !T {
3232 return @as(T, @truncate(value));
3333}
3434
35/// Deprecated: use `readUleb128`
36pub const readULEB128 = readUleb128;
37
3538/// Write a single unsigned integer as unsigned LEB128 to the given writer.
36pub fn writeULEB128(writer: anytype, uint_value: anytype) !void {
39pub fn writeUleb128(writer: anytype, uint_value: anytype) !void {
3740 const T = @TypeOf(uint_value);
3841 const U = if (@typeInfo(T).Int.bits < 8) u8 else T;
3942 var value: U = @intCast(uint_value);
......@@ -50,9 +53,12 @@ pub fn writeULEB128(writer: anytype, uint_value: anytype) !void {
5053 }
5154}
5255
56/// Deprecated: use `writeUleb128`
57pub const writeULEB128 = writeUleb128;
58
5359/// Read a single signed LEB128 value from the given reader as type T,
5460/// or error.Overflow if the value cannot fit.
55pub fn readILEB128(comptime T: type, reader: anytype) !T {
61pub fn readIleb128(comptime T: type, reader: anytype) !T {
5662 const S = if (@typeInfo(T).Int.bits < 8) i8 else T;
5763 const U = std.meta.Int(.unsigned, @typeInfo(S).Int.bits);
5864 const ShiftU = std.math.Log2Int(U);
......@@ -108,8 +114,11 @@ pub fn readILEB128(comptime T: type, reader: anytype) !T {
108114 return @as(T, @truncate(result));
109115}
110116
117/// Deprecated: use `readIleb128`
118pub const readILEB128 = readIleb128;
119
111120/// Write a single signed integer as signed LEB128 to the given writer.
112pub fn writeILEB128(writer: anytype, int_value: anytype) !void {
121pub fn writeIleb128(writer: anytype, int_value: anytype) !void {
113122 const T = @TypeOf(int_value);
114123 const S = if (@typeInfo(T).Int.bits < 8) i8 else T;
115124 const U = std.meta.Int(.unsigned, @typeInfo(S).Int.bits);
......@@ -151,6 +160,9 @@ pub fn writeUnsignedFixed(comptime l: usize, ptr: *[l]u8, int: std.meta.Int(.uns
151160 ptr[i] = @truncate(value);
152161}
153162
163/// Deprecated: use `writeIleb128`
164pub const writeILEB128 = writeIleb128;
165
154166test writeUnsignedFixed {
155167 {
156168 var buf: [4]u8 = undefined;
......@@ -236,23 +248,23 @@ test writeSignedFixed {
236248// tests
237249fn test_read_stream_ileb128(comptime T: type, encoded: []const u8) !T {
238250 var reader = std.io.fixedBufferStream(encoded);
239 return try readILEB128(T, reader.reader());
251 return try readIleb128(T, reader.reader());
240252}
241253
242254fn test_read_stream_uleb128(comptime T: type, encoded: []const u8) !T {
243255 var reader = std.io.fixedBufferStream(encoded);
244 return try readULEB128(T, reader.reader());
256 return try readUleb128(T, reader.reader());
245257}
246258
247259fn test_read_ileb128(comptime T: type, encoded: []const u8) !T {
248260 var reader = std.io.fixedBufferStream(encoded);
249 const v1 = try readILEB128(T, reader.reader());
261 const v1 = try readIleb128(T, reader.reader());
250262 return v1;
251263}
252264
253265fn test_read_uleb128(comptime T: type, encoded: []const u8) !T {
254266 var reader = std.io.fixedBufferStream(encoded);
255 const v1 = try readULEB128(T, reader.reader());
267 const v1 = try readUleb128(T, reader.reader());
256268 return v1;
257269}
258270
......@@ -260,7 +272,7 @@ fn test_read_ileb128_seq(comptime T: type, comptime N: usize, encoded: []const u
260272 var reader = std.io.fixedBufferStream(encoded);
261273 var i: usize = 0;
262274 while (i < N) : (i += 1) {
263 _ = try readILEB128(T, reader.reader());
275 _ = try readIleb128(T, reader.reader());
264276 }
265277}
266278
......@@ -268,7 +280,7 @@ fn test_read_uleb128_seq(comptime T: type, comptime N: usize, encoded: []const u
268280 var reader = std.io.fixedBufferStream(encoded);
269281 var i: usize = 0;
270282 while (i < N) : (i += 1) {
271 _ = try readULEB128(T, reader.reader());
283 _ = try readUleb128(T, reader.reader());
272284 }
273285}
274286
......@@ -364,8 +376,8 @@ fn test_write_leb128(value: anytype) !void {
364376 const signedness = @typeInfo(T).Int.signedness;
365377 const t_signed = signedness == .signed;
366378
367 const writeStream = if (t_signed) writeILEB128 else writeULEB128;
368 const readStream = if (t_signed) readILEB128 else readULEB128;
379 const writeStream = if (t_signed) writeIleb128 else writeUleb128;
380 const readStream = if (t_signed) readIleb128 else readUleb128;
369381
370382 // decode to a larger bit size too, to ensure sign extension
371383 // is working as expected
src/arch/wasm/CodeGen.zig+18-18
......@@ -7374,7 +7374,7 @@ fn getTagNameFunction(func: *CodeGen, enum_ty: Type) InnerError!u32 {
73747374 var writer = body_list.writer();
73757375
73767376 // The locals of the function body (always 0)
7377 try leb.writeULEB128(writer, @as(u32, 0));
7377 try leb.writeUleb128(writer, @as(u32, 0));
73787378
73797379 // outer block
73807380 try writer.writeByte(std.wasm.opcode(.block));
......@@ -7408,7 +7408,7 @@ fn getTagNameFunction(func: *CodeGen, enum_ty: Type) InnerError!u32 {
74087408
74097409 // get actual tag value (stored in 2nd parameter);
74107410 try writer.writeByte(std.wasm.opcode(.local_get));
7411 try leb.writeULEB128(writer, @as(u32, 1));
7411 try leb.writeUleb128(writer, @as(u32, 1));
74127412
74137413 const tag_val = try mod.enumValueFieldIndex(enum_ty, @intCast(tag_index));
74147414 const tag_value = try func.lowerConstant(tag_val, enum_ty);
......@@ -7416,26 +7416,26 @@ fn getTagNameFunction(func: *CodeGen, enum_ty: Type) InnerError!u32 {
74167416 switch (tag_value) {
74177417 .imm32 => |value| {
74187418 try writer.writeByte(std.wasm.opcode(.i32_const));
7419 try leb.writeILEB128(writer, @as(i32, @bitCast(value)));
7419 try leb.writeIleb128(writer, @as(i32, @bitCast(value)));
74207420 try writer.writeByte(std.wasm.opcode(.i32_ne));
74217421 },
74227422 .imm64 => |value| {
74237423 try writer.writeByte(std.wasm.opcode(.i64_const));
7424 try leb.writeILEB128(writer, @as(i64, @bitCast(value)));
7424 try leb.writeIleb128(writer, @as(i64, @bitCast(value)));
74257425 try writer.writeByte(std.wasm.opcode(.i64_ne));
74267426 },
74277427 else => unreachable,
74287428 }
74297429 // if they're not equal, break out of current branch
74307430 try writer.writeByte(std.wasm.opcode(.br_if));
7431 try leb.writeULEB128(writer, @as(u32, 0));
7431 try leb.writeUleb128(writer, @as(u32, 0));
74327432
74337433 // store the address of the tagname in the pointer field of the slice
74347434 // get the address twice so we can also store the length.
74357435 try writer.writeByte(std.wasm.opcode(.local_get));
7436 try leb.writeULEB128(writer, @as(u32, 0));
7436 try leb.writeUleb128(writer, @as(u32, 0));
74377437 try writer.writeByte(std.wasm.opcode(.local_get));
7438 try leb.writeULEB128(writer, @as(u32, 0));
7438 try leb.writeUleb128(writer, @as(u32, 0));
74397439
74407440 // get address of tagname and emit a relocation to it
74417441 if (func.arch() == .wasm32) {
......@@ -7450,15 +7450,15 @@ fn getTagNameFunction(func: *CodeGen, enum_ty: Type) InnerError!u32 {
74507450
74517451 // store pointer
74527452 try writer.writeByte(std.wasm.opcode(.i32_store));
7453 try leb.writeULEB128(writer, encoded_alignment);
7454 try leb.writeULEB128(writer, @as(u32, 0));
7453 try leb.writeUleb128(writer, encoded_alignment);
7454 try leb.writeUleb128(writer, @as(u32, 0));
74557455
74567456 // store length
74577457 try writer.writeByte(std.wasm.opcode(.i32_const));
7458 try leb.writeULEB128(writer, @as(u32, @intCast(tag_name_len)));
7458 try leb.writeUleb128(writer, @as(u32, @intCast(tag_name_len)));
74597459 try writer.writeByte(std.wasm.opcode(.i32_store));
7460 try leb.writeULEB128(writer, encoded_alignment);
7461 try leb.writeULEB128(writer, @as(u32, 4));
7460 try leb.writeUleb128(writer, encoded_alignment);
7461 try leb.writeUleb128(writer, @as(u32, 4));
74627462 } else {
74637463 const encoded_alignment = @ctz(@as(u32, 8));
74647464 try writer.writeByte(std.wasm.opcode(.i64_const));
......@@ -7471,20 +7471,20 @@ fn getTagNameFunction(func: *CodeGen, enum_ty: Type) InnerError!u32 {
74717471
74727472 // store pointer
74737473 try writer.writeByte(std.wasm.opcode(.i64_store));
7474 try leb.writeULEB128(writer, encoded_alignment);
7475 try leb.writeULEB128(writer, @as(u32, 0));
7474 try leb.writeUleb128(writer, encoded_alignment);
7475 try leb.writeUleb128(writer, @as(u32, 0));
74767476
74777477 // store length
74787478 try writer.writeByte(std.wasm.opcode(.i64_const));
7479 try leb.writeULEB128(writer, @as(u64, @intCast(tag_name_len)));
7479 try leb.writeUleb128(writer, @as(u64, @intCast(tag_name_len)));
74807480 try writer.writeByte(std.wasm.opcode(.i64_store));
7481 try leb.writeULEB128(writer, encoded_alignment);
7482 try leb.writeULEB128(writer, @as(u32, 8));
7481 try leb.writeUleb128(writer, encoded_alignment);
7482 try leb.writeUleb128(writer, @as(u32, 8));
74837483 }
74847484
74857485 // break outside blocks
74867486 try writer.writeByte(std.wasm.opcode(.br));
7487 try leb.writeULEB128(writer, @as(u32, 1));
7487 try leb.writeUleb128(writer, @as(u32, 1));
74887488
74897489 // end the block for this case
74907490 try writer.writeByte(std.wasm.opcode(.end));
src/arch/wasm/Emit.zig+21-21
......@@ -265,10 +265,10 @@ fn fail(emit: *Emit, comptime format: []const u8, args: anytype) InnerError {
265265
266266fn emitLocals(emit: *Emit) !void {
267267 const writer = emit.code.writer();
268 try leb128.writeULEB128(writer, @as(u32, @intCast(emit.locals.len)));
268 try leb128.writeUleb128(writer, @as(u32, @intCast(emit.locals.len)));
269269 // emit the actual locals amount
270270 for (emit.locals) |local| {
271 try leb128.writeULEB128(writer, @as(u32, 1));
271 try leb128.writeUleb128(writer, @as(u32, 1));
272272 try writer.writeByte(local);
273273 }
274274}
......@@ -290,16 +290,16 @@ fn emitBrTable(emit: *Emit, inst: Mir.Inst.Index) !void {
290290 const writer = emit.code.writer();
291291
292292 try emit.code.append(std.wasm.opcode(.br_table));
293 try leb128.writeULEB128(writer, extra.data.length - 1); // Default label is not part of length/depth
293 try leb128.writeUleb128(writer, extra.data.length - 1); // Default label is not part of length/depth
294294 for (labels) |label| {
295 try leb128.writeULEB128(writer, label);
295 try leb128.writeUleb128(writer, label);
296296 }
297297}
298298
299299fn emitLabel(emit: *Emit, tag: Mir.Inst.Tag, inst: Mir.Inst.Index) !void {
300300 const label = emit.mir.instructions.items(.data)[inst].label;
301301 try emit.code.append(@intFromEnum(tag));
302 try leb128.writeULEB128(emit.code.writer(), label);
302 try leb128.writeUleb128(emit.code.writer(), label);
303303}
304304
305305fn emitGlobal(emit: *Emit, tag: Mir.Inst.Tag, inst: Mir.Inst.Index) !void {
......@@ -324,14 +324,14 @@ fn emitGlobal(emit: *Emit, tag: Mir.Inst.Tag, inst: Mir.Inst.Index) !void {
324324fn emitImm32(emit: *Emit, inst: Mir.Inst.Index) !void {
325325 const value: i32 = emit.mir.instructions.items(.data)[inst].imm32;
326326 try emit.code.append(std.wasm.opcode(.i32_const));
327 try leb128.writeILEB128(emit.code.writer(), value);
327 try leb128.writeIleb128(emit.code.writer(), value);
328328}
329329
330330fn emitImm64(emit: *Emit, inst: Mir.Inst.Index) !void {
331331 const extra_index = emit.mir.instructions.items(.data)[inst].payload;
332332 const value = emit.mir.extraData(Mir.Imm64, extra_index);
333333 try emit.code.append(std.wasm.opcode(.i64_const));
334 try leb128.writeILEB128(emit.code.writer(), @as(i64, @bitCast(value.data.toU64())));
334 try leb128.writeIleb128(emit.code.writer(), @as(i64, @bitCast(value.data.toU64())));
335335}
336336
337337fn emitFloat32(emit: *Emit, inst: Mir.Inst.Index) !void {
......@@ -357,8 +357,8 @@ fn emitMemArg(emit: *Emit, tag: Mir.Inst.Tag, inst: Mir.Inst.Index) !void {
357357fn encodeMemArg(mem_arg: Mir.MemArg, writer: anytype) !void {
358358 // wasm encodes alignment as power of 2, rather than natural alignment
359359 const encoded_alignment = @ctz(mem_arg.alignment);
360 try leb128.writeULEB128(writer, encoded_alignment);
361 try leb128.writeULEB128(writer, mem_arg.offset);
360 try leb128.writeUleb128(writer, encoded_alignment);
361 try leb128.writeUleb128(writer, mem_arg.offset);
362362}
363363
364364fn emitCall(emit: *Emit, inst: Mir.Inst.Index) !void {
......@@ -400,7 +400,7 @@ fn emitCallIndirect(emit: *Emit, inst: Mir.Inst.Index) !void {
400400 .relocation_type = .R_WASM_TYPE_INDEX_LEB,
401401 });
402402 }
403 try leb128.writeULEB128(emit.code.writer(), @as(u32, 0)); // TODO: Emit relocation for table index
403 try leb128.writeUleb128(emit.code.writer(), @as(u32, 0)); // TODO: Emit relocation for table index
404404}
405405
406406fn emitFunctionIndex(emit: *Emit, inst: Mir.Inst.Index) !void {
......@@ -461,24 +461,24 @@ fn emitExtended(emit: *Emit, inst: Mir.Inst.Index) !void {
461461 const opcode = emit.mir.extra[extra_index];
462462 const writer = emit.code.writer();
463463 try emit.code.append(std.wasm.opcode(.misc_prefix));
464 try leb128.writeULEB128(writer, opcode);
464 try leb128.writeUleb128(writer, opcode);
465465 switch (@as(std.wasm.MiscOpcode, @enumFromInt(opcode))) {
466466 // bulk-memory opcodes
467467 .data_drop => {
468468 const segment = emit.mir.extra[extra_index + 1];
469 try leb128.writeULEB128(writer, segment);
469 try leb128.writeUleb128(writer, segment);
470470 },
471471 .memory_init => {
472472 const segment = emit.mir.extra[extra_index + 1];
473 try leb128.writeULEB128(writer, segment);
474 try leb128.writeULEB128(writer, @as(u32, 0)); // memory index
473 try leb128.writeUleb128(writer, segment);
474 try leb128.writeUleb128(writer, @as(u32, 0)); // memory index
475475 },
476476 .memory_fill => {
477 try leb128.writeULEB128(writer, @as(u32, 0)); // memory index
477 try leb128.writeUleb128(writer, @as(u32, 0)); // memory index
478478 },
479479 .memory_copy => {
480 try leb128.writeULEB128(writer, @as(u32, 0)); // dst memory index
481 try leb128.writeULEB128(writer, @as(u32, 0)); // src memory index
480 try leb128.writeUleb128(writer, @as(u32, 0)); // dst memory index
481 try leb128.writeUleb128(writer, @as(u32, 0)); // src memory index
482482 },
483483
484484 // nontrapping-float-to-int-conversion opcodes
......@@ -500,7 +500,7 @@ fn emitSimd(emit: *Emit, inst: Mir.Inst.Index) !void {
500500 const opcode = emit.mir.extra[extra_index];
501501 const writer = emit.code.writer();
502502 try emit.code.append(std.wasm.opcode(.simd_prefix));
503 try leb128.writeULEB128(writer, opcode);
503 try leb128.writeUleb128(writer, opcode);
504504 switch (@as(std.wasm.SimdOpcode, @enumFromInt(opcode))) {
505505 .v128_store,
506506 .v128_load,
......@@ -551,7 +551,7 @@ fn emitAtomic(emit: *Emit, inst: Mir.Inst.Index) !void {
551551 const opcode = emit.mir.extra[extra_index];
552552 const writer = emit.code.writer();
553553 try emit.code.append(std.wasm.opcode(.atomics_prefix));
554 try leb128.writeULEB128(writer, opcode);
554 try leb128.writeUleb128(writer, opcode);
555555 switch (@as(std.wasm.AtomicsOpcode, @enumFromInt(opcode))) {
556556 .i32_atomic_load,
557557 .i64_atomic_load,
......@@ -625,7 +625,7 @@ fn emitAtomic(emit: *Emit, inst: Mir.Inst.Index) !void {
625625 // TODO: When multi-memory proposal is accepted and implemented in the compiler,
626626 // change this to (user-)specified index, rather than hardcode it to memory index 0.
627627 const memory_index: u32 = 0;
628 try leb128.writeULEB128(writer, memory_index);
628 try leb128.writeUleb128(writer, memory_index);
629629 },
630630 else => |tag| return emit.fail("TODO: Implement atomic instruction: {s}", .{@tagName(tag)}),
631631 }
......@@ -637,7 +637,7 @@ fn emitMemFill(emit: *Emit) !void {
637637 // When multi-memory proposal reaches phase 4, we
638638 // can emit a different memory index here.
639639 // For now we will always emit index 0.
640 try leb128.writeULEB128(emit.code.writer(), @as(u32, 0));
640 try leb128.writeUleb128(emit.code.writer(), @as(u32, 0));
641641}
642642
643643fn emitDbgLine(emit: *Emit, inst: Mir.Inst.Index) !void {
src/link/Dwarf.zig+58-58
......@@ -148,7 +148,7 @@ pub const DeclState = struct {
148148 // DW.AT.encoding, DW.FORM.data1
149149 dbg_info_buffer.appendAssumeCapacity(DW.ATE.boolean);
150150 // DW.AT.byte_size, DW.FORM.udata
151 try leb128.writeULEB128(dbg_info_buffer.writer(), ty.abiSize(mod));
151 try leb128.writeUleb128(dbg_info_buffer.writer(), ty.abiSize(mod));
152152 // DW.AT.name, DW.FORM.string
153153 try dbg_info_buffer.writer().print("{}\x00", .{ty.fmt(mod)});
154154 },
......@@ -162,7 +162,7 @@ pub const DeclState = struct {
162162 .unsigned => DW.ATE.unsigned,
163163 });
164164 // DW.AT.byte_size, DW.FORM.udata
165 try leb128.writeULEB128(dbg_info_buffer.writer(), ty.abiSize(mod));
165 try leb128.writeUleb128(dbg_info_buffer.writer(), ty.abiSize(mod));
166166 // DW.AT.name, DW.FORM.string
167167 try dbg_info_buffer.writer().print("{}\x00", .{ty.fmt(mod)});
168168 },
......@@ -173,7 +173,7 @@ pub const DeclState = struct {
173173 // DW.AT.encoding, DW.FORM.data1
174174 dbg_info_buffer.appendAssumeCapacity(DW.ATE.address);
175175 // DW.AT.byte_size, DW.FORM.udata
176 try leb128.writeULEB128(dbg_info_buffer.writer(), ty.abiSize(mod));
176 try leb128.writeUleb128(dbg_info_buffer.writer(), ty.abiSize(mod));
177177 // DW.AT.name, DW.FORM.string
178178 try dbg_info_buffer.writer().print("{}\x00", .{ty.fmt(mod)});
179179 } else {
......@@ -183,7 +183,7 @@ pub const DeclState = struct {
183183 try dbg_info_buffer.append(@intFromEnum(AbbrevCode.struct_type));
184184 // DW.AT.byte_size, DW.FORM.udata
185185 const abi_size = ty.abiSize(mod);
186 try leb128.writeULEB128(dbg_info_buffer.writer(), abi_size);
186 try leb128.writeUleb128(dbg_info_buffer.writer(), abi_size);
187187 // DW.AT.name, DW.FORM.string
188188 try dbg_info_buffer.writer().print("{}\x00", .{ty.fmt(mod)});
189189 // DW.AT.member
......@@ -209,7 +209,7 @@ pub const DeclState = struct {
209209 try self.addTypeRelocGlobal(atom_index, payload_ty, @intCast(index));
210210 // DW.AT.data_member_location, DW.FORM.udata
211211 const offset = abi_size - payload_ty.abiSize(mod);
212 try leb128.writeULEB128(dbg_info_buffer.writer(), offset);
212 try leb128.writeUleb128(dbg_info_buffer.writer(), offset);
213213 // DW.AT.structure_type delimit children
214214 try dbg_info_buffer.append(0);
215215 }
......@@ -223,7 +223,7 @@ pub const DeclState = struct {
223223 try dbg_info_buffer.ensureUnusedCapacity(2);
224224 dbg_info_buffer.appendAssumeCapacity(@intFromEnum(AbbrevCode.struct_type));
225225 // DW.AT.byte_size, DW.FORM.udata
226 try leb128.writeULEB128(dbg_info_buffer.writer(), ty.abiSize(mod));
226 try leb128.writeUleb128(dbg_info_buffer.writer(), ty.abiSize(mod));
227227 // DW.AT.name, DW.FORM.string
228228 try dbg_info_buffer.writer().print("{}\x00", .{ty.fmt(mod)});
229229 // DW.AT.member
......@@ -279,7 +279,7 @@ pub const DeclState = struct {
279279 try self.addTypeRelocGlobal(atom_index, Type.usize, @intCast(index));
280280 // DW.AT.count, DW.FORM.udata
281281 const len = ty.arrayLenIncludingSentinel(mod);
282 try leb128.writeULEB128(dbg_info_buffer.writer(), len);
282 try leb128.writeUleb128(dbg_info_buffer.writer(), len);
283283 // DW.AT.array_type delimit children
284284 try dbg_info_buffer.append(0);
285285 },
......@@ -287,7 +287,7 @@ pub const DeclState = struct {
287287 // DW.AT.structure_type
288288 try dbg_info_buffer.append(@intFromEnum(AbbrevCode.struct_type));
289289 // DW.AT.byte_size, DW.FORM.udata
290 try leb128.writeULEB128(dbg_info_buffer.writer(), ty.abiSize(mod));
290 try leb128.writeUleb128(dbg_info_buffer.writer(), ty.abiSize(mod));
291291
292292 blk: {
293293 switch (ip.indexToKey(ty.ip_index)) {
......@@ -306,7 +306,7 @@ pub const DeclState = struct {
306306 try self.addTypeRelocGlobal(atom_index, Type.fromInterned(field_ty), @intCast(index));
307307 // DW.AT.data_member_location, DW.FORM.udata
308308 const field_off = ty.structFieldOffset(field_index, mod);
309 try leb128.writeULEB128(dbg_info_buffer.writer(), field_off);
309 try leb128.writeUleb128(dbg_info_buffer.writer(), field_off);
310310 }
311311 },
312312 .struct_type => {
......@@ -332,7 +332,7 @@ pub const DeclState = struct {
332332 try dbg_info_buffer.appendNTimes(0, 4);
333333 try self.addTypeRelocGlobal(atom_index, Type.fromInterned(field_ty), @intCast(index));
334334 // DW.AT.data_member_location, DW.FORM.udata
335 try leb128.writeULEB128(dbg_info_buffer.writer(), field_off);
335 try leb128.writeUleb128(dbg_info_buffer.writer(), field_off);
336336 }
337337 } else {
338338 for (
......@@ -352,7 +352,7 @@ pub const DeclState = struct {
352352 try dbg_info_buffer.appendNTimes(0, 4);
353353 try self.addTypeRelocGlobal(atom_index, Type.fromInterned(field_ty), @intCast(index));
354354 // DW.AT.data_member_location, DW.FORM.udata
355 try leb128.writeULEB128(dbg_info_buffer.writer(), field_off);
355 try leb128.writeUleb128(dbg_info_buffer.writer(), field_off);
356356 }
357357 }
358358 },
......@@ -367,7 +367,7 @@ pub const DeclState = struct {
367367 // DW.AT.enumeration_type
368368 try dbg_info_buffer.append(@intFromEnum(AbbrevCode.enum_type));
369369 // DW.AT.byte_size, DW.FORM.udata
370 try leb128.writeULEB128(dbg_info_buffer.writer(), ty.abiSize(mod));
370 try leb128.writeUleb128(dbg_info_buffer.writer(), ty.abiSize(mod));
371371 // DW.AT.name, DW.FORM.string
372372 try ty.print(dbg_info_buffer.writer(), mod);
373373 try dbg_info_buffer.append(0);
......@@ -408,7 +408,7 @@ pub const DeclState = struct {
408408 // DW.AT.structure_type
409409 try dbg_info_buffer.append(@intFromEnum(AbbrevCode.struct_type));
410410 // DW.AT.byte_size, DW.FORM.udata
411 try leb128.writeULEB128(dbg_info_buffer.writer(), layout.abi_size);
411 try leb128.writeUleb128(dbg_info_buffer.writer(), layout.abi_size);
412412 // DW.AT.name, DW.FORM.string
413413 try ty.print(dbg_info_buffer.writer(), mod);
414414 try dbg_info_buffer.append(0);
......@@ -424,13 +424,13 @@ pub const DeclState = struct {
424424 dbg_info_buffer.appendNTimesAssumeCapacity(0, 4);
425425 try self.addTypeRelocLocal(atom_index, @intCast(inner_union_index), 5);
426426 // DW.AT.data_member_location, DW.FORM.udata
427 try leb128.writeULEB128(dbg_info_buffer.writer(), payload_offset);
427 try leb128.writeUleb128(dbg_info_buffer.writer(), payload_offset);
428428 }
429429
430430 // DW.AT.union_type
431431 try dbg_info_buffer.append(@intFromEnum(AbbrevCode.union_type));
432432 // DW.AT.byte_size, DW.FORM.udata,
433 try leb128.writeULEB128(dbg_info_buffer.writer(), layout.payload_size);
433 try leb128.writeUleb128(dbg_info_buffer.writer(), layout.payload_size);
434434 // DW.AT.name, DW.FORM.string
435435 if (is_tagged) {
436436 try dbg_info_buffer.writer().print("AnonUnion\x00", .{});
......@@ -468,7 +468,7 @@ pub const DeclState = struct {
468468 dbg_info_buffer.appendNTimesAssumeCapacity(0, 4);
469469 try self.addTypeRelocGlobal(atom_index, Type.fromInterned(union_obj.enum_tag_ty), @intCast(index));
470470 // DW.AT.data_member_location, DW.FORM.udata
471 try leb128.writeULEB128(dbg_info_buffer.writer(), tag_offset);
471 try leb128.writeUleb128(dbg_info_buffer.writer(), tag_offset);
472472
473473 // DW.AT.structure_type delimit children
474474 try dbg_info_buffer.append(0);
......@@ -487,7 +487,7 @@ pub const DeclState = struct {
487487 // DW.AT.structure_type
488488 try dbg_info_buffer.append(@intFromEnum(AbbrevCode.struct_type));
489489 // DW.AT.byte_size, DW.FORM.udata
490 try leb128.writeULEB128(dbg_info_buffer.writer(), abi_size);
490 try leb128.writeUleb128(dbg_info_buffer.writer(), abi_size);
491491 // DW.AT.name, DW.FORM.string
492492 try ty.print(dbg_info_buffer.writer(), mod);
493493 try dbg_info_buffer.append(0);
......@@ -504,7 +504,7 @@ pub const DeclState = struct {
504504 dbg_info_buffer.appendNTimesAssumeCapacity(0, 4);
505505 try self.addTypeRelocGlobal(atom_index, payload_ty, @intCast(index));
506506 // DW.AT.data_member_location, DW.FORM.udata
507 try leb128.writeULEB128(dbg_info_buffer.writer(), payload_off);
507 try leb128.writeUleb128(dbg_info_buffer.writer(), payload_off);
508508 }
509509
510510 {
......@@ -519,7 +519,7 @@ pub const DeclState = struct {
519519 dbg_info_buffer.appendNTimesAssumeCapacity(0, 4);
520520 try self.addTypeRelocGlobal(atom_index, error_ty, @intCast(index));
521521 // DW.AT.data_member_location, DW.FORM.udata
522 try leb128.writeULEB128(dbg_info_buffer.writer(), error_off);
522 try leb128.writeUleb128(dbg_info_buffer.writer(), error_off);
523523 }
524524
525525 // DW.AT.structure_type delimit children
......@@ -569,14 +569,14 @@ pub const DeclState = struct {
569569 expr_len.writer().writeByte(DW.OP.reg0 + reg) catch unreachable;
570570 } else {
571571 expr_len.writer().writeByte(DW.OP.regx) catch unreachable;
572 leb128.writeULEB128(expr_len.writer(), reg) catch unreachable;
572 leb128.writeUleb128(expr_len.writer(), reg) catch unreachable;
573573 }
574 leb128.writeULEB128(dbg_info.writer(), expr_len.bytes_written) catch unreachable;
574 leb128.writeUleb128(dbg_info.writer(), expr_len.bytes_written) catch unreachable;
575575 if (reg < 32) {
576576 dbg_info.appendAssumeCapacity(DW.OP.reg0 + reg);
577577 } else {
578578 dbg_info.appendAssumeCapacity(DW.OP.regx);
579 leb128.writeULEB128(dbg_info.writer(), reg) catch unreachable;
579 leb128.writeUleb128(dbg_info.writer(), reg) catch unreachable;
580580 }
581581 },
582582 .register_pair => |regs| {
......@@ -592,24 +592,24 @@ pub const DeclState = struct {
592592 expr_len.writer().writeByte(DW.OP.reg0 + reg) catch unreachable;
593593 } else {
594594 expr_len.writer().writeByte(DW.OP.regx) catch unreachable;
595 leb128.writeULEB128(expr_len.writer(), reg) catch unreachable;
595 leb128.writeUleb128(expr_len.writer(), reg) catch unreachable;
596596 }
597597 expr_len.writer().writeByte(DW.OP.piece) catch unreachable;
598 leb128.writeULEB128(
598 leb128.writeUleb128(
599599 expr_len.writer(),
600600 @min(abi_size - reg_i * reg_bytes, reg_bytes),
601601 ) catch unreachable;
602602 }
603 leb128.writeULEB128(dbg_info.writer(), expr_len.bytes_written) catch unreachable;
603 leb128.writeUleb128(dbg_info.writer(), expr_len.bytes_written) catch unreachable;
604604 for (regs, 0..) |reg, reg_i| {
605605 if (reg < 32) {
606606 dbg_info.appendAssumeCapacity(DW.OP.reg0 + reg);
607607 } else {
608608 dbg_info.appendAssumeCapacity(DW.OP.regx);
609 leb128.writeULEB128(dbg_info.writer(), reg) catch unreachable;
609 leb128.writeUleb128(dbg_info.writer(), reg) catch unreachable;
610610 }
611611 dbg_info.appendAssumeCapacity(DW.OP.piece);
612 leb128.writeULEB128(
612 leb128.writeUleb128(
613613 dbg_info.writer(),
614614 @min(abi_size - reg_i * reg_bytes, reg_bytes),
615615 ) catch unreachable;
......@@ -624,20 +624,20 @@ pub const DeclState = struct {
624624 expr_len.writer().writeByte(DW.OP.breg0 + info.fp_register) catch unreachable;
625625 } else {
626626 expr_len.writer().writeByte(DW.OP.bregx) catch unreachable;
627 leb128.writeULEB128(expr_len.writer(), info.fp_register) catch unreachable;
627 leb128.writeUleb128(expr_len.writer(), info.fp_register) catch unreachable;
628628 }
629 leb128.writeILEB128(expr_len.writer(), info.offset) catch unreachable;
630 leb128.writeULEB128(dbg_info.writer(), expr_len.bytes_written) catch unreachable;
629 leb128.writeIleb128(expr_len.writer(), info.offset) catch unreachable;
630 leb128.writeUleb128(dbg_info.writer(), expr_len.bytes_written) catch unreachable;
631631 if (info.fp_register < 32) {
632632 dbg_info.appendAssumeCapacity(DW.OP.breg0 + info.fp_register);
633633 } else {
634634 dbg_info.appendAssumeCapacity(DW.OP.bregx);
635 leb128.writeULEB128(dbg_info.writer(), info.fp_register) catch unreachable;
635 leb128.writeUleb128(dbg_info.writer(), info.fp_register) catch unreachable;
636636 }
637 leb128.writeILEB128(dbg_info.writer(), info.offset) catch unreachable;
637 leb128.writeIleb128(dbg_info.writer(), info.offset) catch unreachable;
638638 },
639639 .wasm_local => |value| {
640 const leb_size = link.File.Wasm.getULEB128Size(value);
640 const leb_size = link.File.Wasm.getUleb128Size(value);
641641 try dbg_info.ensureUnusedCapacity(3 + leb_size);
642642 // wasm locations are encoded as follow:
643643 // DW_OP_WASM_location wasm-op
......@@ -650,7 +650,7 @@ pub const DeclState = struct {
650650 DW.OP.WASM_location,
651651 DW.OP.WASM_local,
652652 });
653 leb128.writeULEB128(dbg_info.writer(), value) catch unreachable;
653 leb128.writeUleb128(dbg_info.writer(), value) catch unreachable;
654654 },
655655 else => unreachable,
656656 }
......@@ -689,14 +689,14 @@ pub const DeclState = struct {
689689 expr_len.writer().writeByte(DW.OP.reg0 + reg) catch unreachable;
690690 } else {
691691 expr_len.writer().writeByte(DW.OP.regx) catch unreachable;
692 leb128.writeULEB128(expr_len.writer(), reg) catch unreachable;
692 leb128.writeUleb128(expr_len.writer(), reg) catch unreachable;
693693 }
694 leb128.writeULEB128(dbg_info.writer(), expr_len.bytes_written) catch unreachable;
694 leb128.writeUleb128(dbg_info.writer(), expr_len.bytes_written) catch unreachable;
695695 if (reg < 32) {
696696 dbg_info.appendAssumeCapacity(DW.OP.reg0 + reg);
697697 } else {
698698 dbg_info.appendAssumeCapacity(DW.OP.regx);
699 leb128.writeULEB128(dbg_info.writer(), reg) catch unreachable;
699 leb128.writeUleb128(dbg_info.writer(), reg) catch unreachable;
700700 }
701701 },
702702
......@@ -712,24 +712,24 @@ pub const DeclState = struct {
712712 expr_len.writer().writeByte(DW.OP.reg0 + reg) catch unreachable;
713713 } else {
714714 expr_len.writer().writeByte(DW.OP.regx) catch unreachable;
715 leb128.writeULEB128(expr_len.writer(), reg) catch unreachable;
715 leb128.writeUleb128(expr_len.writer(), reg) catch unreachable;
716716 }
717717 expr_len.writer().writeByte(DW.OP.piece) catch unreachable;
718 leb128.writeULEB128(
718 leb128.writeUleb128(
719719 expr_len.writer(),
720720 @min(abi_size - reg_i * reg_bytes, reg_bytes),
721721 ) catch unreachable;
722722 }
723 leb128.writeULEB128(dbg_info.writer(), expr_len.bytes_written) catch unreachable;
723 leb128.writeUleb128(dbg_info.writer(), expr_len.bytes_written) catch unreachable;
724724 for (regs, 0..) |reg, reg_i| {
725725 if (reg < 32) {
726726 dbg_info.appendAssumeCapacity(DW.OP.reg0 + reg);
727727 } else {
728728 dbg_info.appendAssumeCapacity(DW.OP.regx);
729 leb128.writeULEB128(dbg_info.writer(), reg) catch unreachable;
729 leb128.writeUleb128(dbg_info.writer(), reg) catch unreachable;
730730 }
731731 dbg_info.appendAssumeCapacity(DW.OP.piece);
732 leb128.writeULEB128(
732 leb128.writeUleb128(
733733 dbg_info.writer(),
734734 @min(abi_size - reg_i * reg_bytes, reg_bytes),
735735 ) catch unreachable;
......@@ -744,21 +744,21 @@ pub const DeclState = struct {
744744 expr_len.writer().writeByte(DW.OP.breg0 + info.fp_register) catch unreachable;
745745 } else {
746746 expr_len.writer().writeByte(DW.OP.bregx) catch unreachable;
747 leb128.writeULEB128(expr_len.writer(), info.fp_register) catch unreachable;
747 leb128.writeUleb128(expr_len.writer(), info.fp_register) catch unreachable;
748748 }
749 leb128.writeILEB128(expr_len.writer(), info.offset) catch unreachable;
750 leb128.writeULEB128(dbg_info.writer(), expr_len.bytes_written) catch unreachable;
749 leb128.writeIleb128(expr_len.writer(), info.offset) catch unreachable;
750 leb128.writeUleb128(dbg_info.writer(), expr_len.bytes_written) catch unreachable;
751751 if (info.fp_register < 32) {
752752 dbg_info.appendAssumeCapacity(DW.OP.breg0 + info.fp_register);
753753 } else {
754754 dbg_info.appendAssumeCapacity(DW.OP.bregx);
755 leb128.writeULEB128(dbg_info.writer(), info.fp_register) catch unreachable;
755 leb128.writeUleb128(dbg_info.writer(), info.fp_register) catch unreachable;
756756 }
757 leb128.writeILEB128(dbg_info.writer(), info.offset) catch unreachable;
757 leb128.writeIleb128(dbg_info.writer(), info.offset) catch unreachable;
758758 },
759759
760760 .wasm_local => |value| {
761 const leb_size = link.File.Wasm.getULEB128Size(value);
761 const leb_size = link.File.Wasm.getUleb128Size(value);
762762 try dbg_info.ensureUnusedCapacity(2 + leb_size);
763763 // wasm locals are encoded as follow:
764764 // DW_OP_WASM_location wasm-op
......@@ -770,7 +770,7 @@ pub const DeclState = struct {
770770 DW.OP.WASM_location,
771771 DW.OP.WASM_local,
772772 });
773 leb128.writeULEB128(dbg_info.writer(), value) catch unreachable;
773 leb128.writeUleb128(dbg_info.writer(), value) catch unreachable;
774774 },
775775
776776 .memory,
......@@ -832,9 +832,9 @@ pub const DeclState = struct {
832832 if (child_ty.isSignedInt(mod)) DW.OP.consts else DW.OP.constu,
833833 });
834834 if (child_ty.isSignedInt(mod)) {
835 try leb128.writeILEB128(dbg_info.writer(), @as(i64, @bitCast(x)));
835 try leb128.writeIleb128(dbg_info.writer(), @as(i64, @bitCast(x)));
836836 } else {
837 try leb128.writeULEB128(dbg_info.writer(), x);
837 try leb128.writeUleb128(dbg_info.writer(), x);
838838 }
839839 try dbg_info.append(DW.OP.stack_value);
840840 dbg_info.items[fixup] += @intCast(dbg_info.items.len - fixup - 2);
......@@ -847,9 +847,9 @@ pub const DeclState = struct {
847847 const abi_size: u32 = @intCast(child_ty.abiSize(mod));
848848 var implicit_value_len = std.ArrayList(u8).init(gpa);
849849 defer implicit_value_len.deinit();
850 try leb128.writeULEB128(implicit_value_len.writer(), abi_size);
850 try leb128.writeUleb128(implicit_value_len.writer(), abi_size);
851851 const total_exprloc_len = 1 + implicit_value_len.items.len + abi_size;
852 try leb128.writeULEB128(dbg_info.writer(), total_exprloc_len);
852 try leb128.writeUleb128(dbg_info.writer(), total_exprloc_len);
853853 try dbg_info.ensureUnusedCapacity(total_exprloc_len);
854854 dbg_info.appendAssumeCapacity(DW.OP.implicit_value);
855855 dbg_info.appendSliceAssumeCapacity(implicit_value_len.items);
......@@ -895,7 +895,7 @@ pub const DeclState = struct {
895895 remaining: {
896896 assert(delta_line != 0);
897897 dbg_line.appendAssumeCapacity(DW.LNS.advance_line);
898 leb128.writeILEB128(dbg_line.writer(), delta_line) catch unreachable;
898 leb128.writeIleb128(dbg_line.writer(), delta_line) catch unreachable;
899899 break :remaining 0;
900900 } else delta_line);
901901
......@@ -904,7 +904,7 @@ pub const DeclState = struct {
904904 const max_op_advance: u9 = (std.math.maxInt(u8) - header.opcode_base) / header.line_range;
905905 const remaining_op_advance: u8 = @intCast(if (op_advance >= 2 * max_op_advance) remaining: {
906906 dbg_line.appendAssumeCapacity(DW.LNS.advance_pc);
907 leb128.writeULEB128(dbg_line.writer(), op_advance) catch unreachable;
907 leb128.writeUleb128(dbg_line.writer(), op_advance) catch unreachable;
908908 break :remaining 0;
909909 } else if (op_advance >= max_op_advance) remaining: {
910910 dbg_line.appendAssumeCapacity(DW.LNS.const_add_pc);
......@@ -922,7 +922,7 @@ pub const DeclState = struct {
922922 pub fn setColumn(self: *DeclState, column: u32) error{OutOfMemory}!void {
923923 try self.dbg_line.ensureUnusedCapacity(1 + 5);
924924 self.dbg_line.appendAssumeCapacity(DW.LNS.set_column);
925 leb128.writeULEB128(self.dbg_line.writer(), column + 1) catch unreachable;
925 leb128.writeUleb128(self.dbg_line.writer(), column + 1) catch unreachable;
926926 }
927927
928928 pub fn setPrologueEnd(self: *DeclState) error{OutOfMemory}!void {
......@@ -1146,7 +1146,7 @@ pub fn initDeclState(self: *Dwarf, mod: *Module, decl_index: InternPool.DeclInde
11461146 leb128.writeUnsignedFixed(4, dbg_line_buffer.addManyAsArrayAssumeCapacity(4), file_index);
11471147
11481148 dbg_line_buffer.appendAssumeCapacity(DW.LNS.set_column);
1149 leb128.writeULEB128(dbg_line_buffer.writer(), func.lbrace_column + 1) catch unreachable;
1149 leb128.writeUleb128(dbg_line_buffer.writer(), func.lbrace_column + 1) catch unreachable;
11501150
11511151 // Emit a line for the begin curly with prologue_end=false. The codegen will
11521152 // do the work of setting prologue_end=true and epilogue_begin=true.
......@@ -2849,7 +2849,7 @@ fn addDbgInfoErrorSetNames(
28492849 try dbg_info_buffer.append(@intFromEnum(AbbrevCode.enum_type));
28502850 // DW.AT.byte_size, DW.FORM.udata
28512851 const abi_size = Type.anyerror.abiSize(mod);
2852 try leb128.writeULEB128(dbg_info_buffer.writer(), abi_size);
2852 try leb128.writeUleb128(dbg_info_buffer.writer(), abi_size);
28532853 // DW.AT.name, DW.FORM.string
28542854 try ty.print(dbg_info_buffer.writer(), mod);
28552855 try dbg_info_buffer.append(0);
src/link/MachO/Dylib.zig+9-9
......@@ -159,11 +159,11 @@ const TrieIterator = struct {
159159 return std.io.fixedBufferStream(it.data[it.pos..]);
160160 }
161161
162 fn readULEB128(it: *TrieIterator) !u64 {
162 fn readUleb128(it: *TrieIterator) !u64 {
163163 var stream = it.getStream();
164164 var creader = std.io.countingReader(stream.reader());
165165 const reader = creader.reader();
166 const value = try std.leb.readULEB128(u64, reader);
166 const value = try std.leb.readUleb128(u64, reader);
167167 it.pos += math.cast(usize, creader.bytes_read) orelse return error.Overflow;
168168 return value;
169169 }
......@@ -207,9 +207,9 @@ fn parseTrieNode(
207207) !void {
208208 const tracy = trace(@src());
209209 defer tracy.end();
210 const size = try it.readULEB128();
210 const size = try it.readUleb128();
211211 if (size > 0) {
212 const flags = try it.readULEB128();
212 const flags = try it.readUleb128();
213213 const kind = flags & macho.EXPORT_SYMBOL_FLAGS_KIND_MASK;
214214 const out_flags = Export.Flags{
215215 .abs = kind == macho.EXPORT_SYMBOL_FLAGS_KIND_ABSOLUTE,
......@@ -217,15 +217,15 @@ fn parseTrieNode(
217217 .weak = flags & macho.EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION != 0,
218218 };
219219 if (flags & macho.EXPORT_SYMBOL_FLAGS_REEXPORT != 0) {
220 _ = try it.readULEB128(); // dylib ordinal
220 _ = try it.readUleb128(); // dylib ordinal
221221 const name = try it.readString();
222222 try self.addExport(allocator, if (name.len > 0) name else prefix, out_flags);
223223 } else if (flags & macho.EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER != 0) {
224 _ = try it.readULEB128(); // stub offset
225 _ = try it.readULEB128(); // resolver offset
224 _ = try it.readUleb128(); // stub offset
225 _ = try it.readUleb128(); // resolver offset
226226 try self.addExport(allocator, prefix, out_flags);
227227 } else {
228 _ = try it.readULEB128(); // VM offset
228 _ = try it.readUleb128(); // VM offset
229229 try self.addExport(allocator, prefix, out_flags);
230230 }
231231 }
......@@ -234,7 +234,7 @@ fn parseTrieNode(
234234
235235 for (0..nedges) |_| {
236236 const label = try it.readString();
237 const off = try it.readULEB128();
237 const off = try it.readUleb128();
238238 const prefix_label = try std.fmt.allocPrint(arena, "{s}{s}", .{ prefix, label });
239239 const curr = it.pos;
240240 it.pos = math.cast(usize, off) orelse return error.Overflow;
src/link/MachO/dwarf.zig+15-15
......@@ -26,7 +26,7 @@ pub const InfoReader = struct {
2626 .dwarf64 => 12,
2727 } + cuh_length;
2828 while (p.pos < end_pos) {
29 const di_code = try p.readULEB128(u64);
29 const di_code = try p.readUleb128(u64);
3030 if (di_code == 0) return error.Eof;
3131 if (di_code == code) return;
3232
......@@ -92,14 +92,14 @@ pub const InfoReader = struct {
9292 dwarf.FORM.block1 => try p.readByte(),
9393 dwarf.FORM.block2 => try p.readInt(u16),
9494 dwarf.FORM.block4 => try p.readInt(u32),
95 dwarf.FORM.block => try p.readULEB128(u64),
95 dwarf.FORM.block => try p.readUleb128(u64),
9696 else => unreachable,
9797 };
9898 return p.readNBytes(len);
9999 }
100100
101101 pub fn readExprLoc(p: *InfoReader) ![]const u8 {
102 const len: u64 = try p.readULEB128(u64);
102 const len: u64 = try p.readUleb128(u64);
103103 return p.readNBytes(len);
104104 }
105105
......@@ -109,8 +109,8 @@ pub const InfoReader = struct {
109109 dwarf.FORM.data2, dwarf.FORM.ref2 => try p.readInt(u16),
110110 dwarf.FORM.data4, dwarf.FORM.ref4 => try p.readInt(u32),
111111 dwarf.FORM.data8, dwarf.FORM.ref8, dwarf.FORM.ref_sig8 => try p.readInt(u64),
112 dwarf.FORM.udata, dwarf.FORM.ref_udata => try p.readULEB128(u64),
113 dwarf.FORM.sdata => @bitCast(try p.readILEB128(i64)),
112 dwarf.FORM.udata, dwarf.FORM.ref_udata => try p.readUleb128(u64),
113 dwarf.FORM.sdata => @bitCast(try p.readIleb128(i64)),
114114 else => return error.UnhandledConstantForm,
115115 };
116116 }
......@@ -160,18 +160,18 @@ pub const InfoReader = struct {
160160 };
161161 }
162162
163 pub fn readULEB128(p: *InfoReader, comptime Type: type) !Type {
163 pub fn readUleb128(p: *InfoReader, comptime Type: type) !Type {
164164 var stream = std.io.fixedBufferStream(p.bytes[p.pos..]);
165165 var creader = std.io.countingReader(stream.reader());
166 const value: Type = try leb.readULEB128(Type, creader.reader());
166 const value: Type = try leb.readUleb128(Type, creader.reader());
167167 p.pos += math.cast(usize, creader.bytes_read) orelse return error.Overflow;
168168 return value;
169169 }
170170
171 pub fn readILEB128(p: *InfoReader, comptime Type: type) !Type {
171 pub fn readIleb128(p: *InfoReader, comptime Type: type) !Type {
172172 var stream = std.io.fixedBufferStream(p.bytes[p.pos..]);
173173 var creader = std.io.countingReader(stream.reader());
174 const value: Type = try leb.readILEB128(Type, creader.reader());
174 const value: Type = try leb.readIleb128(Type, creader.reader());
175175 p.pos += math.cast(usize, creader.bytes_read) orelse return error.Overflow;
176176 return value;
177177 }
......@@ -191,10 +191,10 @@ pub const AbbrevReader = struct {
191191
192192 pub fn readDecl(p: *AbbrevReader) !?AbbrevDecl {
193193 const pos = p.pos;
194 const code = try p.readULEB128(Code);
194 const code = try p.readUleb128(Code);
195195 if (code == 0) return null;
196196
197 const tag = try p.readULEB128(Tag);
197 const tag = try p.readUleb128(Tag);
198198 const has_children = (try p.readByte()) > 0;
199199 return .{
200200 .code = code,
......@@ -207,8 +207,8 @@ pub const AbbrevReader = struct {
207207
208208 pub fn readAttr(p: *AbbrevReader) !?AbbrevAttr {
209209 const pos = p.pos;
210 const at = try p.readULEB128(At);
211 const form = try p.readULEB128(Form);
210 const at = try p.readUleb128(At);
211 const form = try p.readUleb128(Form);
212212 return if (at == 0 and form == 0) null else .{
213213 .at = at,
214214 .form = form,
......@@ -223,10 +223,10 @@ pub const AbbrevReader = struct {
223223 return p.bytes[p.pos];
224224 }
225225
226 pub fn readULEB128(p: *AbbrevReader, comptime Type: type) !Type {
226 pub fn readUleb128(p: *AbbrevReader, comptime Type: type) !Type {
227227 var stream = std.io.fixedBufferStream(p.bytes[p.pos..]);
228228 var creader = std.io.countingReader(stream.reader());
229 const value: Type = try leb.readULEB128(Type, creader.reader());
229 const value: Type = try leb.readUleb128(Type, creader.reader());
230230 p.pos += math.cast(usize, creader.bytes_read) orelse return error.Overflow;
231231 return value;
232232 }
src/link/MachO/dyld_info/Rebase.zig+6-6
......@@ -153,13 +153,13 @@ fn setTypePointer(writer: anytype) !void {
153153fn setSegmentOffset(segment_id: u8, offset: u64, writer: anytype) !void {
154154 log.debug(">>> set segment: {d} and offset: {x}", .{ segment_id, offset });
155155 try writer.writeByte(macho.REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB | @as(u4, @truncate(segment_id)));
156 try std.leb.writeULEB128(writer, offset);
156 try std.leb.writeUleb128(writer, offset);
157157}
158158
159159fn rebaseAddAddr(addr: u64, writer: anytype) !void {
160160 log.debug(">>> rebase with add: {x}", .{addr});
161161 try writer.writeByte(macho.REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB);
162 try std.leb.writeULEB128(writer, addr);
162 try std.leb.writeUleb128(writer, addr);
163163}
164164
165165fn rebaseTimes(count: usize, writer: anytype) !void {
......@@ -168,15 +168,15 @@ fn rebaseTimes(count: usize, writer: anytype) !void {
168168 try writer.writeByte(macho.REBASE_OPCODE_DO_REBASE_IMM_TIMES | @as(u4, @truncate(count)));
169169 } else {
170170 try writer.writeByte(macho.REBASE_OPCODE_DO_REBASE_ULEB_TIMES);
171 try std.leb.writeULEB128(writer, count);
171 try std.leb.writeUleb128(writer, count);
172172 }
173173}
174174
175175fn rebaseTimesSkip(count: usize, skip: u64, writer: anytype) !void {
176176 log.debug(">>> rebase with count: {d} and skip: {x}", .{ count, skip });
177177 try writer.writeByte(macho.REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB);
178 try std.leb.writeULEB128(writer, count);
179 try std.leb.writeULEB128(writer, skip);
178 try std.leb.writeUleb128(writer, count);
179 try std.leb.writeUleb128(writer, skip);
180180}
181181
182182fn addAddr(addr: u64, writer: anytype) !void {
......@@ -189,7 +189,7 @@ fn addAddr(addr: u64, writer: anytype) !void {
189189 }
190190 }
191191 try writer.writeByte(macho.REBASE_OPCODE_ADD_ADDR_ULEB);
192 try std.leb.writeULEB128(writer, addr);
192 try std.leb.writeUleb128(writer, addr);
193193}
194194
195195fn done(writer: anytype) !void {
src/link/MachO/dyld_info/Trie.zig+12-12
......@@ -133,14 +133,14 @@ pub const Node = struct {
133133
134134 var nread: usize = 0;
135135
136 const node_size = try leb.readULEB128(u64, reader);
136 const node_size = try leb.readUleb128(u64, reader);
137137 if (node_size > 0) {
138 const export_flags = try leb.readULEB128(u64, reader);
138 const export_flags = try leb.readUleb128(u64, reader);
139139 // TODO Parse special flags.
140140 assert(export_flags & macho.EXPORT_SYMBOL_FLAGS_REEXPORT == 0 and
141141 export_flags & macho.EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER == 0);
142142
143 const vmaddr_offset = try leb.readULEB128(u64, reader);
143 const vmaddr_offset = try leb.readUleb128(u64, reader);
144144
145145 self.terminal_info = .{
146146 .export_flags = export_flags,
......@@ -168,7 +168,7 @@ pub const Node = struct {
168168 break :blk try label_buf.toOwnedSlice();
169169 };
170170
171 const seek_to = try leb.readULEB128(u64, reader);
171 const seek_to = try leb.readUleb128(u64, reader);
172172 const return_pos = try reader.context.getPos();
173173
174174 nread += return_pos - edge_start_pos;
......@@ -204,13 +204,13 @@ pub const Node = struct {
204204 // TODO Implement for special flags.
205205 assert(info.export_flags & macho.EXPORT_SYMBOL_FLAGS_REEXPORT == 0 and
206206 info.export_flags & macho.EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER == 0);
207 try leb.writeULEB128(info_stream.writer(), info.export_flags);
208 try leb.writeULEB128(info_stream.writer(), info.vmaddr_offset);
207 try leb.writeUleb128(info_stream.writer(), info.export_flags);
208 try leb.writeUleb128(info_stream.writer(), info.vmaddr_offset);
209209
210210 // Encode the size of the terminal node info.
211211 var size_buf: [@sizeOf(u64)]u8 = undefined;
212212 var size_stream = std.io.fixedBufferStream(&size_buf);
213 try leb.writeULEB128(size_stream.writer(), info_stream.pos);
213 try leb.writeUleb128(size_stream.writer(), info_stream.pos);
214214
215215 // Now, write them to the output stream.
216216 try writer.writeAll(size_buf[0..size_stream.pos]);
......@@ -226,7 +226,7 @@ pub const Node = struct {
226226 // Write edge label and offset to next node in trie.
227227 try writer.writeAll(edge.label);
228228 try writer.writeByte(0);
229 try leb.writeULEB128(writer, edge.to.trie_offset.?);
229 try leb.writeUleb128(writer, edge.to.trie_offset.?);
230230 }
231231 }
232232
......@@ -246,9 +246,9 @@ pub const Node = struct {
246246
247247 var node_size: u64 = 0;
248248 if (self.terminal_info) |info| {
249 try leb.writeULEB128(writer, info.export_flags);
250 try leb.writeULEB128(writer, info.vmaddr_offset);
251 try leb.writeULEB128(writer, stream.bytes_written);
249 try leb.writeUleb128(writer, info.export_flags);
250 try leb.writeUleb128(writer, info.vmaddr_offset);
251 try leb.writeUleb128(writer, stream.bytes_written);
252252 } else {
253253 node_size += 1; // 0x0 for non-terminal nodes
254254 }
......@@ -257,7 +257,7 @@ pub const Node = struct {
257257 for (self.edges.items) |edge| {
258258 const next_node_offset = edge.to.trie_offset orelse 0;
259259 node_size += edge.label.len + 1;
260 try leb.writeULEB128(writer, next_node_offset);
260 try leb.writeUleb128(writer, next_node_offset);
261261 }
262262
263263 const trie_offset = self.trie_offset orelse 0;
src/link/MachO/dyld_info/bind.zig+7-7
......@@ -392,7 +392,7 @@ pub const LazyBind = struct {
392392fn setSegmentOffset(segment_id: u8, offset: u64, writer: anytype) !void {
393393 log.debug(">>> set segment: {d} and offset: {x}", .{ segment_id, offset });
394394 try writer.writeByte(macho.BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB | @as(u4, @truncate(segment_id)));
395 try std.leb.writeULEB128(writer, offset);
395 try std.leb.writeUleb128(writer, offset);
396396}
397397
398398fn setSymbol(name: []const u8, flags: u8, writer: anytype) !void {
......@@ -426,7 +426,7 @@ fn setDylibOrdinal(ordinal: i16, writer: anytype) !void {
426426 try writer.writeByte(macho.BIND_OPCODE_SET_DYLIB_ORDINAL_IMM | @as(u4, @truncate(cast)));
427427 } else {
428428 try writer.writeByte(macho.BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB);
429 try std.leb.writeULEB128(writer, cast);
429 try std.leb.writeUleb128(writer, cast);
430430 }
431431 }
432432}
......@@ -434,7 +434,7 @@ fn setDylibOrdinal(ordinal: i16, writer: anytype) !void {
434434fn setAddend(addend: i64, writer: anytype) !void {
435435 log.debug(">>> set addend: {x}", .{addend});
436436 try writer.writeByte(macho.BIND_OPCODE_SET_ADDEND_SLEB);
437 try std.leb.writeILEB128(writer, addend);
437 try std.leb.writeIleb128(writer, addend);
438438}
439439
440440fn doBind(writer: anytype) !void {
......@@ -454,20 +454,20 @@ fn doBindAddAddr(addr: u64, writer: anytype) !void {
454454 }
455455 }
456456 try writer.writeByte(macho.BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB);
457 try std.leb.writeULEB128(writer, addr);
457 try std.leb.writeUleb128(writer, addr);
458458}
459459
460460fn doBindTimesSkip(count: usize, skip: u64, writer: anytype) !void {
461461 log.debug(">>> bind with count: {d} and skip: {x}", .{ count, skip });
462462 try writer.writeByte(macho.BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB);
463 try std.leb.writeULEB128(writer, count);
464 try std.leb.writeULEB128(writer, skip);
463 try std.leb.writeUleb128(writer, count);
464 try std.leb.writeUleb128(writer, skip);
465465}
466466
467467fn addAddr(addr: u64, writer: anytype) !void {
468468 log.debug(">>> add: {x}", .{addr});
469469 try writer.writeByte(macho.BIND_OPCODE_ADD_ADDR_ULEB);
470 try std.leb.writeULEB128(writer, addr);
470 try std.leb.writeUleb128(writer, addr);
471471}
472472
473473fn done(writer: anytype) !void {
src/link/MachO/eh_frame.zig+5-5
......@@ -21,10 +21,10 @@ pub const Cie = struct {
2121 var creader = std.io.countingReader(stream.reader());
2222 const reader = creader.reader();
2323
24 _ = try leb.readULEB128(u64, reader); // code alignment factor
25 _ = try leb.readULEB128(u64, reader); // data alignment factor
26 _ = try leb.readULEB128(u64, reader); // return address register
27 _ = try leb.readULEB128(u64, reader); // augmentation data length
24 _ = try leb.readUleb128(u64, reader); // code alignment factor
25 _ = try leb.readUleb128(u64, reader); // data alignment factor
26 _ = try leb.readUleb128(u64, reader); // return address register
27 _ = try leb.readUleb128(u64, reader); // augmentation data length
2828
2929 for (aug[1..]) |ch| switch (ch) {
3030 'R' => {
......@@ -185,7 +185,7 @@ pub const Fde = struct {
185185 var stream = std.io.fixedBufferStream(data[24..]);
186186 var creader = std.io.countingReader(stream.reader());
187187 const reader = creader.reader();
188 _ = try leb.readULEB128(u64, reader); // augmentation length
188 _ = try leb.readUleb128(u64, reader); // augmentation length
189189 fde.lsda_ptr_offset = @intCast(creader.bytes_read + 24);
190190 const lsda_ptr = switch (lsda_size) {
191191 .p32 => try reader.readInt(i32, .little),
src/link/Wasm.zig+128-128
......@@ -952,7 +952,7 @@ fn resolveSymbolsInArchives(wasm: *Wasm) !void {
952952/// Writes an unsigned 32-bit integer as a LEB128-encoded 'i32.const' value.
953953fn writeI32Const(writer: anytype, val: u32) !void {
954954 try writer.writeByte(std.wasm.opcode(.i32_const));
955 try leb.writeILEB128(writer, @as(i32, @bitCast(val)));
955 try leb.writeIleb128(writer, @as(i32, @bitCast(val)));
956956}
957957
958958fn setupInitMemoryFunction(wasm: *Wasm) !void {
......@@ -984,7 +984,7 @@ fn setupInitMemoryFunction(wasm: *Wasm) !void {
984984 const writer = function_body.writer();
985985
986986 // we have 0 locals
987 try leb.writeULEB128(writer, @as(u32, 0));
987 try leb.writeUleb128(writer, @as(u32, 0));
988988
989989 if (shared_memory) {
990990 // destination blocks
......@@ -1003,16 +1003,16 @@ fn setupInitMemoryFunction(wasm: *Wasm) !void {
10031003 try writeI32Const(writer, 0);
10041004 try writeI32Const(writer, 1);
10051005 try writer.writeByte(std.wasm.opcode(.atomics_prefix));
1006 try leb.writeULEB128(writer, std.wasm.atomicsOpcode(.i32_atomic_rmw_cmpxchg));
1007 try leb.writeULEB128(writer, @as(u32, 2)); // alignment
1008 try leb.writeULEB128(writer, @as(u32, 0)); // offset
1006 try leb.writeUleb128(writer, std.wasm.atomicsOpcode(.i32_atomic_rmw_cmpxchg));
1007 try leb.writeUleb128(writer, @as(u32, 2)); // alignment
1008 try leb.writeUleb128(writer, @as(u32, 0)); // offset
10091009
10101010 // based on the value from the atomic check, jump to the label.
10111011 try writer.writeByte(std.wasm.opcode(.br_table));
1012 try leb.writeULEB128(writer, @as(u32, 2)); // length of the table (we have 3 blocks but because of the mandatory default the length is 2).
1013 try leb.writeULEB128(writer, @as(u32, 0)); // $init
1014 try leb.writeULEB128(writer, @as(u32, 1)); // $wait
1015 try leb.writeULEB128(writer, @as(u32, 2)); // $drop
1012 try leb.writeUleb128(writer, @as(u32, 2)); // length of the table (we have 3 blocks but because of the mandatory default the length is 2).
1013 try leb.writeUleb128(writer, @as(u32, 0)); // $init
1014 try leb.writeUleb128(writer, @as(u32, 1)); // $wait
1015 try leb.writeUleb128(writer, @as(u32, 2)); // $drop
10161016 try writer.writeByte(std.wasm.opcode(.end));
10171017 }
10181018
......@@ -1034,7 +1034,7 @@ fn setupInitMemoryFunction(wasm: *Wasm) !void {
10341034 try writeI32Const(writer, segment.offset);
10351035 try writer.writeByte(std.wasm.opcode(.global_set));
10361036 const loc = wasm.findGlobalSymbol("__tls_base").?;
1037 try leb.writeULEB128(writer, loc.getSymbol(wasm).index);
1037 try leb.writeUleb128(writer, loc.getSymbol(wasm).index);
10381038 }
10391039
10401040 try writeI32Const(writer, 0);
......@@ -1042,11 +1042,11 @@ fn setupInitMemoryFunction(wasm: *Wasm) !void {
10421042 try writer.writeByte(std.wasm.opcode(.misc_prefix));
10431043 if (std.mem.eql(u8, entry.key_ptr.*, ".bss")) {
10441044 // fill bss segment with zeroes
1045 try leb.writeULEB128(writer, std.wasm.miscOpcode(.memory_fill));
1045 try leb.writeUleb128(writer, std.wasm.miscOpcode(.memory_fill));
10461046 } else {
10471047 // initialize the segment
1048 try leb.writeULEB128(writer, std.wasm.miscOpcode(.memory_init));
1049 try leb.writeULEB128(writer, segment_index);
1048 try leb.writeUleb128(writer, std.wasm.miscOpcode(.memory_init));
1049 try leb.writeUleb128(writer, segment_index);
10501050 }
10511051 try writer.writeByte(0); // memory index immediate
10521052 }
......@@ -1057,34 +1057,34 @@ fn setupInitMemoryFunction(wasm: *Wasm) !void {
10571057 try writeI32Const(writer, flag_address);
10581058 try writeI32Const(writer, 2);
10591059 try writer.writeByte(std.wasm.opcode(.atomics_prefix));
1060 try leb.writeULEB128(writer, std.wasm.atomicsOpcode(.i32_atomic_store));
1061 try leb.writeULEB128(writer, @as(u32, 2)); // alignment
1062 try leb.writeULEB128(writer, @as(u32, 0)); // offset
1060 try leb.writeUleb128(writer, std.wasm.atomicsOpcode(.i32_atomic_store));
1061 try leb.writeUleb128(writer, @as(u32, 2)); // alignment
1062 try leb.writeUleb128(writer, @as(u32, 0)); // offset
10631063
10641064 // notify any waiters for segment initialization completion
10651065 try writeI32Const(writer, flag_address);
10661066 try writer.writeByte(std.wasm.opcode(.i32_const));
1067 try leb.writeILEB128(writer, @as(i32, -1)); // number of waiters
1067 try leb.writeIleb128(writer, @as(i32, -1)); // number of waiters
10681068 try writer.writeByte(std.wasm.opcode(.atomics_prefix));
1069 try leb.writeULEB128(writer, std.wasm.atomicsOpcode(.memory_atomic_notify));
1070 try leb.writeULEB128(writer, @as(u32, 2)); // alignment
1071 try leb.writeULEB128(writer, @as(u32, 0)); // offset
1069 try leb.writeUleb128(writer, std.wasm.atomicsOpcode(.memory_atomic_notify));
1070 try leb.writeUleb128(writer, @as(u32, 2)); // alignment
1071 try leb.writeUleb128(writer, @as(u32, 0)); // offset
10721072 try writer.writeByte(std.wasm.opcode(.drop));
10731073
10741074 // branch and drop segments
10751075 try writer.writeByte(std.wasm.opcode(.br));
1076 try leb.writeULEB128(writer, @as(u32, 1));
1076 try leb.writeUleb128(writer, @as(u32, 1));
10771077
10781078 // wait for thread to initialize memory segments
10791079 try writer.writeByte(std.wasm.opcode(.end)); // end $wait
10801080 try writeI32Const(writer, flag_address);
10811081 try writeI32Const(writer, 1); // expected flag value
10821082 try writer.writeByte(std.wasm.opcode(.i64_const));
1083 try leb.writeILEB128(writer, @as(i64, -1)); // timeout
1083 try leb.writeIleb128(writer, @as(i64, -1)); // timeout
10841084 try writer.writeByte(std.wasm.opcode(.atomics_prefix));
1085 try leb.writeULEB128(writer, std.wasm.atomicsOpcode(.memory_atomic_wait32));
1086 try leb.writeULEB128(writer, @as(u32, 2)); // alignment
1087 try leb.writeULEB128(writer, @as(u32, 0)); // offset
1085 try leb.writeUleb128(writer, std.wasm.atomicsOpcode(.memory_atomic_wait32));
1086 try leb.writeUleb128(writer, @as(u32, 2)); // alignment
1087 try leb.writeUleb128(writer, @as(u32, 0)); // offset
10881088 try writer.writeByte(std.wasm.opcode(.drop));
10891089
10901090 try writer.writeByte(std.wasm.opcode(.end)); // end $drop
......@@ -1105,8 +1105,8 @@ fn setupInitMemoryFunction(wasm: *Wasm) !void {
11051105 }
11061106
11071107 try writer.writeByte(std.wasm.opcode(.misc_prefix));
1108 try leb.writeULEB128(writer, std.wasm.miscOpcode(.data_drop));
1109 try leb.writeULEB128(writer, segment_index);
1108 try leb.writeUleb128(writer, std.wasm.miscOpcode(.data_drop));
1109 try leb.writeUleb128(writer, segment_index);
11101110 }
11111111 }
11121112
......@@ -1147,18 +1147,18 @@ fn setupTLSRelocationsFunction(wasm: *Wasm) !void {
11471147 if (sym.tag == .data and sym.isDefined()) {
11481148 // get __tls_base
11491149 try writer.writeByte(std.wasm.opcode(.global_get));
1150 try leb.writeULEB128(writer, wasm.findGlobalSymbol("__tls_base").?.getSymbol(wasm).index);
1150 try leb.writeUleb128(writer, wasm.findGlobalSymbol("__tls_base").?.getSymbol(wasm).index);
11511151
11521152 // add the virtual address of the symbol
11531153 try writer.writeByte(std.wasm.opcode(.i32_const));
1154 try leb.writeULEB128(writer, sym.virtual_address);
1154 try leb.writeUleb128(writer, sym.virtual_address);
11551155 } else if (sym.tag == .function) {
11561156 @panic("TODO: relocate GOT entry of function");
11571157 } else continue;
11581158
11591159 try writer.writeByte(std.wasm.opcode(.i32_add));
11601160 try writer.writeByte(std.wasm.opcode(.global_set));
1161 try leb.writeULEB128(writer, wasm.imported_globals_count + @as(u32, @intCast(wasm.wasm_globals.items.len + got_index)));
1161 try leb.writeUleb128(writer, wasm.imported_globals_count + @as(u32, @intCast(wasm.wasm_globals.items.len + got_index)));
11621162 }
11631163 try writer.writeByte(std.wasm.opcode(.end));
11641164
......@@ -1801,7 +1801,7 @@ fn initializeCallCtorsFunction(wasm: *Wasm) !void {
18011801 // Create the function body
18021802 {
18031803 // Write locals count (we have none)
1804 try leb.writeULEB128(writer, @as(u32, 0));
1804 try leb.writeUleb128(writer, @as(u32, 0));
18051805
18061806 // call constructors
18071807 for (wasm.init_funcs.items) |init_func_loc| {
......@@ -1811,7 +1811,7 @@ fn initializeCallCtorsFunction(wasm: *Wasm) !void {
18111811
18121812 // Call function by its function index
18131813 try writer.writeByte(std.wasm.opcode(.call));
1814 try leb.writeULEB128(writer, symbol.index);
1814 try leb.writeUleb128(writer, symbol.index);
18151815
18161816 // drop all returned values from the stack as __wasm_call_ctors has no return value
18171817 for (ty.returns) |_| {
......@@ -1905,31 +1905,31 @@ fn initializeTLSFunction(wasm: *Wasm) !void {
19051905 const param_local: u32 = 0;
19061906
19071907 try writer.writeByte(std.wasm.opcode(.local_get));
1908 try leb.writeULEB128(writer, param_local);
1908 try leb.writeUleb128(writer, param_local);
19091909
19101910 const tls_base_loc = wasm.findGlobalSymbol("__tls_base").?;
19111911 try writer.writeByte(std.wasm.opcode(.global_set));
1912 try leb.writeULEB128(writer, tls_base_loc.getSymbol(wasm).index);
1912 try leb.writeUleb128(writer, tls_base_loc.getSymbol(wasm).index);
19131913
19141914 // load stack values for the bulk-memory operation
19151915 {
19161916 try writer.writeByte(std.wasm.opcode(.local_get));
1917 try leb.writeULEB128(writer, param_local);
1917 try leb.writeUleb128(writer, param_local);
19181918
19191919 try writer.writeByte(std.wasm.opcode(.i32_const));
1920 try leb.writeULEB128(writer, @as(u32, 0)); //segment offset
1920 try leb.writeUleb128(writer, @as(u32, 0)); //segment offset
19211921
19221922 try writer.writeByte(std.wasm.opcode(.i32_const));
1923 try leb.writeULEB128(writer, @as(u32, segment.size)); //segment offset
1923 try leb.writeUleb128(writer, @as(u32, segment.size)); //segment offset
19241924 }
19251925
19261926 // perform the bulk-memory operation to initialize the data segment
19271927 try writer.writeByte(std.wasm.opcode(.misc_prefix));
1928 try leb.writeULEB128(writer, std.wasm.miscOpcode(.memory_init));
1928 try leb.writeUleb128(writer, std.wasm.miscOpcode(.memory_init));
19291929 // segment immediate
1930 try leb.writeULEB128(writer, @as(u32, @intCast(data_index)));
1930 try leb.writeUleb128(writer, @as(u32, @intCast(data_index)));
19311931 // memory index immediate (always 0)
1932 try leb.writeULEB128(writer, @as(u32, 0));
1932 try leb.writeUleb128(writer, @as(u32, 0));
19331933 }
19341934
19351935 // If we have to perform any TLS relocations, call the corresponding function
......@@ -1937,7 +1937,7 @@ fn initializeTLSFunction(wasm: *Wasm) !void {
19371937 // generated by the linker.
19381938 if (wasm.findGlobalSymbol("__wasm_apply_global_tls_relocs")) |loc| {
19391939 try writer.writeByte(std.wasm.opcode(.call));
1940 try leb.writeULEB128(writer, loc.getSymbol(wasm).index);
1940 try leb.writeUleb128(writer, loc.getSymbol(wasm).index);
19411941 loc.getSymbol(wasm).mark();
19421942 }
19431943
......@@ -2642,14 +2642,14 @@ fn writeToFile(
26422642 const header_offset = try reserveVecSectionHeader(&binary_bytes);
26432643 log.debug("Writing type section. Count: ({d})", .{wasm.func_types.items.len});
26442644 for (wasm.func_types.items) |func_type| {
2645 try leb.writeULEB128(binary_writer, std.wasm.function_type);
2646 try leb.writeULEB128(binary_writer, @as(u32, @intCast(func_type.params.len)));
2645 try leb.writeUleb128(binary_writer, std.wasm.function_type);
2646 try leb.writeUleb128(binary_writer, @as(u32, @intCast(func_type.params.len)));
26472647 for (func_type.params) |param_ty| {
2648 try leb.writeULEB128(binary_writer, std.wasm.valtype(param_ty));
2648 try leb.writeUleb128(binary_writer, std.wasm.valtype(param_ty));
26492649 }
2650 try leb.writeULEB128(binary_writer, @as(u32, @intCast(func_type.returns.len)));
2650 try leb.writeUleb128(binary_writer, @as(u32, @intCast(func_type.returns.len)));
26512651 for (func_type.returns) |ret_ty| {
2652 try leb.writeULEB128(binary_writer, std.wasm.valtype(ret_ty));
2652 try leb.writeUleb128(binary_writer, std.wasm.valtype(ret_ty));
26532653 }
26542654 }
26552655
......@@ -2698,7 +2698,7 @@ fn writeToFile(
26982698 if (wasm.functions.count() != 0) {
26992699 const header_offset = try reserveVecSectionHeader(&binary_bytes);
27002700 for (wasm.functions.values()) |function| {
2701 try leb.writeULEB128(binary_writer, function.func.type_index);
2701 try leb.writeUleb128(binary_writer, function.func.type_index);
27022702 }
27032703
27042704 try writeVecSectionHeader(
......@@ -2716,7 +2716,7 @@ fn writeToFile(
27162716 const header_offset = try reserveVecSectionHeader(&binary_bytes);
27172717
27182718 for (wasm.tables.items) |table| {
2719 try leb.writeULEB128(binary_writer, std.wasm.reftype(table.reftype));
2719 try leb.writeUleb128(binary_writer, std.wasm.reftype(table.reftype));
27202720 try emitLimits(binary_writer, table.limits);
27212721 }
27222722
......@@ -2771,17 +2771,17 @@ fn writeToFile(
27712771
27722772 for (wasm.exports.items) |exp| {
27732773 const name = wasm.string_table.get(exp.name);
2774 try leb.writeULEB128(binary_writer, @as(u32, @intCast(name.len)));
2774 try leb.writeUleb128(binary_writer, @as(u32, @intCast(name.len)));
27752775 try binary_writer.writeAll(name);
2776 try leb.writeULEB128(binary_writer, @intFromEnum(exp.kind));
2777 try leb.writeULEB128(binary_writer, exp.index);
2776 try leb.writeUleb128(binary_writer, @intFromEnum(exp.kind));
2777 try leb.writeUleb128(binary_writer, exp.index);
27782778 }
27792779
27802780 if (export_memory) {
2781 try leb.writeULEB128(binary_writer, @as(u32, @intCast("memory".len)));
2781 try leb.writeUleb128(binary_writer, @as(u32, @intCast("memory".len)));
27822782 try binary_writer.writeAll("memory");
27832783 try binary_writer.writeByte(std.wasm.externalKind(.memory));
2784 try leb.writeULEB128(binary_writer, @as(u32, 0));
2784 try leb.writeUleb128(binary_writer, @as(u32, 0));
27852785 }
27862786
27872787 try writeVecSectionHeader(
......@@ -2813,21 +2813,21 @@ fn writeToFile(
28132813 const table_sym = table_loc.getSymbol(wasm);
28142814
28152815 const flags: u32 = if (table_sym.index == 0) 0x0 else 0x02; // passive with implicit 0-index table or set table index manually
2816 try leb.writeULEB128(binary_writer, flags);
2816 try leb.writeUleb128(binary_writer, flags);
28172817 if (flags == 0x02) {
2818 try leb.writeULEB128(binary_writer, table_sym.index);
2818 try leb.writeUleb128(binary_writer, table_sym.index);
28192819 }
28202820 try emitInit(binary_writer, .{ .i32_const = 1 }); // We start at index 1, so unresolved function pointers are invalid
28212821 if (flags == 0x02) {
2822 try leb.writeULEB128(binary_writer, @as(u8, 0)); // represents funcref
2822 try leb.writeUleb128(binary_writer, @as(u8, 0)); // represents funcref
28232823 }
2824 try leb.writeULEB128(binary_writer, @as(u32, @intCast(wasm.function_table.count())));
2824 try leb.writeUleb128(binary_writer, @as(u32, @intCast(wasm.function_table.count())));
28252825 var symbol_it = wasm.function_table.keyIterator();
28262826 while (symbol_it.next()) |symbol_loc_ptr| {
28272827 const sym = symbol_loc_ptr.getSymbol(wasm);
28282828 std.debug.assert(sym.isAlive());
28292829 std.debug.assert(sym.index < wasm.functions.count() + wasm.imported_functions_count);
2830 try leb.writeULEB128(binary_writer, sym.index);
2830 try leb.writeUleb128(binary_writer, sym.index);
28312831 }
28322832
28332833 try writeVecSectionHeader(
......@@ -2868,7 +2868,7 @@ fn writeToFile(
28682868 atom.resolveRelocs(wasm);
28692869 }
28702870 atom.offset = @intCast(binary_bytes.items.len - start_offset);
2871 try leb.writeULEB128(binary_writer, atom.size);
2871 try leb.writeUleb128(binary_writer, atom.size);
28722872 try binary_writer.writeAll(atom.code.items);
28732873 }
28742874
......@@ -2899,16 +2899,16 @@ fn writeToFile(
28992899 segment_count += 1;
29002900 var atom_index = wasm.atoms.get(segment_index).?;
29012901
2902 try leb.writeULEB128(binary_writer, segment.flags);
2902 try leb.writeUleb128(binary_writer, segment.flags);
29032903 if (segment.flags & @intFromEnum(Wasm.Segment.Flag.WASM_DATA_SEGMENT_HAS_MEMINDEX) != 0) {
2904 try leb.writeULEB128(binary_writer, @as(u32, 0)); // memory is always index 0 as we only have 1 memory entry
2904 try leb.writeUleb128(binary_writer, @as(u32, 0)); // memory is always index 0 as we only have 1 memory entry
29052905 }
29062906 // when a segment is passive, it's initialized during runtime.
29072907 if (!segment.isPassive()) {
29082908 try emitInit(binary_writer, .{ .i32_const = @as(i32, @bitCast(segment.offset)) });
29092909 }
29102910 // offset into data section
2911 try leb.writeULEB128(binary_writer, segment.size);
2911 try leb.writeUleb128(binary_writer, segment.size);
29122912
29132913 // fill in the offset table and the data segments
29142914 var current_offset: u32 = 0;
......@@ -3058,7 +3058,7 @@ fn emitDebugSection(binary_bytes: *std.ArrayList(u8), data: []const u8, name: []
30583058 if (data.len == 0) return;
30593059 const header_offset = try reserveCustomSectionHeader(binary_bytes);
30603060 const writer = binary_bytes.writer();
3061 try leb.writeULEB128(writer, @as(u32, @intCast(name.len)));
3061 try leb.writeUleb128(writer, @as(u32, @intCast(name.len)));
30623062 try writer.writeAll(name);
30633063
30643064 const start = binary_bytes.items.len - header_offset;
......@@ -3077,10 +3077,10 @@ fn emitProducerSection(binary_bytes: *std.ArrayList(u8)) !void {
30773077
30783078 const writer = binary_bytes.writer();
30793079 const producers = "producers";
3080 try leb.writeULEB128(writer, @as(u32, @intCast(producers.len)));
3080 try leb.writeUleb128(writer, @as(u32, @intCast(producers.len)));
30813081 try writer.writeAll(producers);
30823082
3083 try leb.writeULEB128(writer, @as(u32, 2)); // 2 fields: Language + processed-by
3083 try leb.writeUleb128(writer, @as(u32, 2)); // 2 fields: Language + processed-by
30843084
30853085 // used for the Zig version
30863086 var version_buf: [100]u8 = undefined;
......@@ -3089,18 +3089,18 @@ fn emitProducerSection(binary_bytes: *std.ArrayList(u8)) !void {
30893089 // language field
30903090 {
30913091 const language = "language";
3092 try leb.writeULEB128(writer, @as(u32, @intCast(language.len)));
3092 try leb.writeUleb128(writer, @as(u32, @intCast(language.len)));
30933093 try writer.writeAll(language);
30943094
30953095 // field_value_count (TODO: Parse object files for producer sections to detect their language)
3096 try leb.writeULEB128(writer, @as(u32, 1));
3096 try leb.writeUleb128(writer, @as(u32, 1));
30973097
30983098 // versioned name
30993099 {
3100 try leb.writeULEB128(writer, @as(u32, 3)); // len of "Zig"
3100 try leb.writeUleb128(writer, @as(u32, 3)); // len of "Zig"
31013101 try writer.writeAll("Zig");
31023102
3103 try leb.writeULEB128(writer, @as(u32, @intCast(version.len)));
3103 try leb.writeUleb128(writer, @as(u32, @intCast(version.len)));
31043104 try writer.writeAll(version);
31053105 }
31063106 }
......@@ -3108,18 +3108,18 @@ fn emitProducerSection(binary_bytes: *std.ArrayList(u8)) !void {
31083108 // processed-by field
31093109 {
31103110 const processed_by = "processed-by";
3111 try leb.writeULEB128(writer, @as(u32, @intCast(processed_by.len)));
3111 try leb.writeUleb128(writer, @as(u32, @intCast(processed_by.len)));
31123112 try writer.writeAll(processed_by);
31133113
31143114 // field_value_count (TODO: Parse object files for producer sections to detect other used tools)
3115 try leb.writeULEB128(writer, @as(u32, 1));
3115 try leb.writeUleb128(writer, @as(u32, 1));
31163116
31173117 // versioned name
31183118 {
3119 try leb.writeULEB128(writer, @as(u32, 3)); // len of "Zig"
3119 try leb.writeUleb128(writer, @as(u32, 3)); // len of "Zig"
31203120 try writer.writeAll("Zig");
31213121
3122 try leb.writeULEB128(writer, @as(u32, @intCast(version.len)));
3122 try leb.writeUleb128(writer, @as(u32, @intCast(version.len)));
31233123 try writer.writeAll(version);
31243124 }
31253125 }
......@@ -3136,11 +3136,11 @@ fn emitBuildIdSection(binary_bytes: *std.ArrayList(u8), build_id: []const u8) !v
31363136
31373137 const writer = binary_bytes.writer();
31383138 const hdr_build_id = "build_id";
3139 try leb.writeULEB128(writer, @as(u32, @intCast(hdr_build_id.len)));
3139 try leb.writeUleb128(writer, @as(u32, @intCast(hdr_build_id.len)));
31403140 try writer.writeAll(hdr_build_id);
31413141
3142 try leb.writeULEB128(writer, @as(u32, 1));
3143 try leb.writeULEB128(writer, @as(u32, @intCast(build_id.len)));
3142 try leb.writeUleb128(writer, @as(u32, 1));
3143 try leb.writeUleb128(writer, @as(u32, @intCast(build_id.len)));
31443144 try writer.writeAll(build_id);
31453145
31463146 try writeCustomSectionHeader(
......@@ -3155,17 +3155,17 @@ fn emitFeaturesSection(binary_bytes: *std.ArrayList(u8), enabled_features: []con
31553155
31563156 const writer = binary_bytes.writer();
31573157 const target_features = "target_features";
3158 try leb.writeULEB128(writer, @as(u32, @intCast(target_features.len)));
3158 try leb.writeUleb128(writer, @as(u32, @intCast(target_features.len)));
31593159 try writer.writeAll(target_features);
31603160
3161 try leb.writeULEB128(writer, features_count);
3161 try leb.writeUleb128(writer, features_count);
31623162 for (enabled_features, 0..) |enabled, feature_index| {
31633163 if (enabled) {
31643164 const feature: types.Feature = .{ .prefix = .used, .tag = @as(types.Feature.Tag, @enumFromInt(feature_index)) };
3165 try leb.writeULEB128(writer, @intFromEnum(feature.prefix));
3165 try leb.writeUleb128(writer, @intFromEnum(feature.prefix));
31663166 var buf: [100]u8 = undefined;
31673167 const string = try std.fmt.bufPrint(&buf, "{}", .{feature.tag});
3168 try leb.writeULEB128(writer, @as(u32, @intCast(string.len)));
3168 try leb.writeUleb128(writer, @as(u32, @intCast(string.len)));
31693169 try writer.writeAll(string);
31703170 }
31713171 }
......@@ -3228,7 +3228,7 @@ fn emitNameSection(wasm: *Wasm, binary_bytes: *std.ArrayList(u8), arena: std.mem
32283228
32293229 const header_offset = try reserveCustomSectionHeader(binary_bytes);
32303230 const writer = binary_bytes.writer();
3231 try leb.writeULEB128(writer, @as(u32, @intCast("name".len)));
3231 try leb.writeUleb128(writer, @as(u32, @intCast("name".len)));
32323232 try writer.writeAll("name");
32333233
32343234 try wasm.emitNameSubsection(.function, funcs.values(), writer);
......@@ -3250,25 +3250,25 @@ fn emitNameSubsection(wasm: *Wasm, section_id: std.wasm.NameSubsection, names: a
32503250 defer section_list.deinit();
32513251 const sub_writer = section_list.writer();
32523252
3253 try leb.writeULEB128(sub_writer, @as(u32, @intCast(names.len)));
3253 try leb.writeUleb128(sub_writer, @as(u32, @intCast(names.len)));
32543254 for (names) |name| {
32553255 log.debug("Emit symbol '{s}' type({s})", .{ name.name, @tagName(section_id) });
3256 try leb.writeULEB128(sub_writer, name.index);
3257 try leb.writeULEB128(sub_writer, @as(u32, @intCast(name.name.len)));
3256 try leb.writeUleb128(sub_writer, name.index);
3257 try leb.writeUleb128(sub_writer, @as(u32, @intCast(name.name.len)));
32583258 try sub_writer.writeAll(name.name);
32593259 }
32603260
32613261 // From now, write to the actual writer
3262 try leb.writeULEB128(writer, @intFromEnum(section_id));
3263 try leb.writeULEB128(writer, @as(u32, @intCast(section_list.items.len)));
3262 try leb.writeUleb128(writer, @intFromEnum(section_id));
3263 try leb.writeUleb128(writer, @as(u32, @intCast(section_list.items.len)));
32643264 try writer.writeAll(section_list.items);
32653265}
32663266
32673267fn emitLimits(writer: anytype, limits: std.wasm.Limits) !void {
32683268 try writer.writeByte(limits.flags);
3269 try leb.writeULEB128(writer, limits.min);
3269 try leb.writeUleb128(writer, limits.min);
32703270 if (limits.hasFlag(.WASM_LIMITS_FLAG_HAS_MAX)) {
3271 try leb.writeULEB128(writer, limits.max);
3271 try leb.writeUleb128(writer, limits.max);
32723272 }
32733273}
32743274
......@@ -3276,11 +3276,11 @@ fn emitInit(writer: anytype, init_expr: std.wasm.InitExpression) !void {
32763276 switch (init_expr) {
32773277 .i32_const => |val| {
32783278 try writer.writeByte(std.wasm.opcode(.i32_const));
3279 try leb.writeILEB128(writer, val);
3279 try leb.writeIleb128(writer, val);
32803280 },
32813281 .i64_const => |val| {
32823282 try writer.writeByte(std.wasm.opcode(.i64_const));
3283 try leb.writeILEB128(writer, val);
3283 try leb.writeIleb128(writer, val);
32843284 },
32853285 .f32_const => |val| {
32863286 try writer.writeByte(std.wasm.opcode(.f32_const));
......@@ -3292,7 +3292,7 @@ fn emitInit(writer: anytype, init_expr: std.wasm.InitExpression) !void {
32923292 },
32933293 .global_get => |val| {
32943294 try writer.writeByte(std.wasm.opcode(.global_get));
3295 try leb.writeULEB128(writer, val);
3295 try leb.writeUleb128(writer, val);
32963296 },
32973297 }
32983298 try writer.writeByte(std.wasm.opcode(.end));
......@@ -3300,22 +3300,22 @@ fn emitInit(writer: anytype, init_expr: std.wasm.InitExpression) !void {
33003300
33013301fn emitImport(wasm: *Wasm, writer: anytype, import: types.Import) !void {
33023302 const module_name = wasm.string_table.get(import.module_name);
3303 try leb.writeULEB128(writer, @as(u32, @intCast(module_name.len)));
3303 try leb.writeUleb128(writer, @as(u32, @intCast(module_name.len)));
33043304 try writer.writeAll(module_name);
33053305
33063306 const name = wasm.string_table.get(import.name);
3307 try leb.writeULEB128(writer, @as(u32, @intCast(name.len)));
3307 try leb.writeUleb128(writer, @as(u32, @intCast(name.len)));
33083308 try writer.writeAll(name);
33093309
33103310 try writer.writeByte(@intFromEnum(import.kind));
33113311 switch (import.kind) {
3312 .function => |type_index| try leb.writeULEB128(writer, type_index),
3312 .function => |type_index| try leb.writeUleb128(writer, type_index),
33133313 .global => |global_type| {
3314 try leb.writeULEB128(writer, std.wasm.valtype(global_type.valtype));
3314 try leb.writeUleb128(writer, std.wasm.valtype(global_type.valtype));
33153315 try writer.writeByte(@intFromBool(global_type.mutable));
33163316 },
33173317 .table => |table| {
3318 try leb.writeULEB128(writer, std.wasm.reftype(table.reftype));
3318 try leb.writeUleb128(writer, std.wasm.reftype(table.reftype));
33193319 try emitLimits(writer, table.limits);
33203320 },
33213321 .memory => |limits| {
......@@ -3767,11 +3767,11 @@ fn emitLinkSection(wasm: *Wasm, binary_bytes: *std.ArrayList(u8), symbol_table:
37673767 const writer = binary_bytes.writer();
37683768 // emit "linking" custom section name
37693769 const section_name = "linking";
3770 try leb.writeULEB128(writer, section_name.len);
3770 try leb.writeUleb128(writer, section_name.len);
37713771 try writer.writeAll(section_name);
37723772
37733773 // meta data version, which is currently '2'
3774 try leb.writeULEB128(writer, @as(u32, 2));
3774 try leb.writeUleb128(writer, @as(u32, 2));
37753775
37763776 // For each subsection type (found in types.Subsection) we can emit a section.
37773777 // Currently, we only support emitting segment info and the symbol table.
......@@ -3785,7 +3785,7 @@ fn emitLinkSection(wasm: *Wasm, binary_bytes: *std.ArrayList(u8), symbol_table:
37853785fn emitSymbolTable(wasm: *Wasm, binary_bytes: *std.ArrayList(u8), symbol_table: *std.AutoArrayHashMap(SymbolLoc, u32)) !void {
37863786 const writer = binary_bytes.writer();
37873787
3788 try leb.writeULEB128(writer, @intFromEnum(types.SubsectionType.WASM_SYMBOL_TABLE));
3788 try leb.writeUleb128(writer, @intFromEnum(types.SubsectionType.WASM_SYMBOL_TABLE));
37893789 const table_offset = binary_bytes.items.len;
37903790
37913791 var symbol_count: u32 = 0;
......@@ -3795,30 +3795,30 @@ fn emitSymbolTable(wasm: *Wasm, binary_bytes: *std.ArrayList(u8), symbol_table:
37953795 try symbol_table.putNoClobber(sym_loc, symbol_count);
37963796 symbol_count += 1;
37973797 log.debug("Emit symbol: {}", .{symbol});
3798 try leb.writeULEB128(writer, @intFromEnum(symbol.tag));
3799 try leb.writeULEB128(writer, symbol.flags);
3798 try leb.writeUleb128(writer, @intFromEnum(symbol.tag));
3799 try leb.writeUleb128(writer, symbol.flags);
38003800
38013801 const sym_name = sym_loc.getName(wasm);
38023802 switch (symbol.tag) {
38033803 .data => {
3804 try leb.writeULEB128(writer, @as(u32, @intCast(sym_name.len)));
3804 try leb.writeUleb128(writer, @as(u32, @intCast(sym_name.len)));
38053805 try writer.writeAll(sym_name);
38063806
38073807 if (symbol.isDefined()) {
3808 try leb.writeULEB128(writer, symbol.index);
3808 try leb.writeUleb128(writer, symbol.index);
38093809 const atom_index = wasm.symbol_atom.get(sym_loc).?;
38103810 const atom = wasm.getAtom(atom_index);
3811 try leb.writeULEB128(writer, @as(u32, atom.offset));
3812 try leb.writeULEB128(writer, @as(u32, atom.size));
3811 try leb.writeUleb128(writer, @as(u32, atom.offset));
3812 try leb.writeUleb128(writer, @as(u32, atom.size));
38133813 }
38143814 },
38153815 .section => {
3816 try leb.writeULEB128(writer, symbol.index);
3816 try leb.writeUleb128(writer, symbol.index);
38173817 },
38183818 else => {
3819 try leb.writeULEB128(writer, symbol.index);
3819 try leb.writeUleb128(writer, symbol.index);
38203820 if (symbol.isDefined()) {
3821 try leb.writeULEB128(writer, @as(u32, @intCast(sym_name.len)));
3821 try leb.writeUleb128(writer, @as(u32, @intCast(sym_name.len)));
38223822 try writer.writeAll(sym_name);
38233823 }
38243824 },
......@@ -3833,20 +3833,20 @@ fn emitSymbolTable(wasm: *Wasm, binary_bytes: *std.ArrayList(u8), symbol_table:
38333833
38343834fn emitSegmentInfo(wasm: *Wasm, binary_bytes: *std.ArrayList(u8)) !void {
38353835 const writer = binary_bytes.writer();
3836 try leb.writeULEB128(writer, @intFromEnum(types.SubsectionType.WASM_SEGMENT_INFO));
3836 try leb.writeUleb128(writer, @intFromEnum(types.SubsectionType.WASM_SEGMENT_INFO));
38373837 const segment_offset = binary_bytes.items.len;
38383838
3839 try leb.writeULEB128(writer, @as(u32, @intCast(wasm.segment_info.count())));
3839 try leb.writeUleb128(writer, @as(u32, @intCast(wasm.segment_info.count())));
38403840 for (wasm.segment_info.values()) |segment_info| {
38413841 log.debug("Emit segment: {s} align({d}) flags({b})", .{
38423842 segment_info.name,
38433843 segment_info.alignment,
38443844 segment_info.flags,
38453845 });
3846 try leb.writeULEB128(writer, @as(u32, @intCast(segment_info.name.len)));
3846 try leb.writeUleb128(writer, @as(u32, @intCast(segment_info.name.len)));
38473847 try writer.writeAll(segment_info.name);
3848 try leb.writeULEB128(writer, segment_info.alignment.toLog2Units());
3849 try leb.writeULEB128(writer, segment_info.flags);
3848 try leb.writeUleb128(writer, segment_info.alignment.toLog2Units());
3849 try leb.writeUleb128(writer, segment_info.flags);
38503850 }
38513851
38523852 var buf: [5]u8 = undefined;
......@@ -3854,7 +3854,7 @@ fn emitSegmentInfo(wasm: *Wasm, binary_bytes: *std.ArrayList(u8)) !void {
38543854 try binary_bytes.insertSlice(segment_offset, &buf);
38553855}
38563856
3857pub fn getULEB128Size(uint_value: anytype) u32 {
3857pub fn getUleb128Size(uint_value: anytype) u32 {
38583858 const T = @TypeOf(uint_value);
38593859 const U = if (@typeInfo(T).Int.bits < 8) u8 else T;
38603860 var value = @as(U, @intCast(uint_value));
......@@ -3879,9 +3879,9 @@ fn emitCodeRelocations(
38793879
38803880 // write custom section information
38813881 const name = "reloc.CODE";
3882 try leb.writeULEB128(writer, @as(u32, @intCast(name.len)));
3882 try leb.writeUleb128(writer, @as(u32, @intCast(name.len)));
38833883 try writer.writeAll(name);
3884 try leb.writeULEB128(writer, section_index);
3884 try leb.writeUleb128(writer, section_index);
38853885 const reloc_start = binary_bytes.items.len;
38863886
38873887 var count: u32 = 0;
......@@ -3889,17 +3889,17 @@ fn emitCodeRelocations(
38893889 // for each atom, we calculate the uleb size and append that
38903890 var size_offset: u32 = 5; // account for code section size leb128
38913891 while (true) {
3892 size_offset += getULEB128Size(atom.size);
3892 size_offset += getUleb128Size(atom.size);
38933893 for (atom.relocs.items) |relocation| {
38943894 count += 1;
38953895 const sym_loc: SymbolLoc = .{ .file = atom.file, .index = @enumFromInt(relocation.index) };
38963896 const symbol_index = symbol_table.get(sym_loc).?;
3897 try leb.writeULEB128(writer, @intFromEnum(relocation.relocation_type));
3897 try leb.writeUleb128(writer, @intFromEnum(relocation.relocation_type));
38983898 const offset = atom.offset + relocation.offset + size_offset;
3899 try leb.writeULEB128(writer, offset);
3900 try leb.writeULEB128(writer, symbol_index);
3899 try leb.writeUleb128(writer, offset);
3900 try leb.writeUleb128(writer, symbol_index);
39013901 if (relocation.relocation_type.addendIsPresent()) {
3902 try leb.writeILEB128(writer, relocation.addend);
3902 try leb.writeIleb128(writer, relocation.addend);
39033903 }
39043904 log.debug("Emit relocation: {}", .{relocation});
39053905 }
......@@ -3926,9 +3926,9 @@ fn emitDataRelocations(
39263926
39273927 // write custom section information
39283928 const name = "reloc.DATA";
3929 try leb.writeULEB128(writer, @as(u32, @intCast(name.len)));
3929 try leb.writeUleb128(writer, @as(u32, @intCast(name.len)));
39303930 try writer.writeAll(name);
3931 try leb.writeULEB128(writer, section_index);
3931 try leb.writeUleb128(writer, section_index);
39323932 const reloc_start = binary_bytes.items.len;
39333933
39343934 var count: u32 = 0;
......@@ -3937,17 +3937,17 @@ fn emitDataRelocations(
39373937 for (wasm.data_segments.values()) |segment_index| {
39383938 var atom: *Atom = wasm.getAtomPtr(wasm.atoms.get(segment_index).?);
39393939 while (true) {
3940 size_offset += getULEB128Size(atom.size);
3940 size_offset += getUleb128Size(atom.size);
39413941 for (atom.relocs.items) |relocation| {
39423942 count += 1;
39433943 const sym_loc: SymbolLoc = .{ .file = atom.file, .index = @enumFromInt(relocation.index) };
39443944 const symbol_index = symbol_table.get(sym_loc).?;
3945 try leb.writeULEB128(writer, @intFromEnum(relocation.relocation_type));
3945 try leb.writeUleb128(writer, @intFromEnum(relocation.relocation_type));
39463946 const offset = atom.offset + relocation.offset + size_offset;
3947 try leb.writeULEB128(writer, offset);
3948 try leb.writeULEB128(writer, symbol_index);
3947 try leb.writeUleb128(writer, offset);
3948 try leb.writeUleb128(writer, symbol_index);
39493949 if (relocation.relocation_type.addendIsPresent()) {
3950 try leb.writeILEB128(writer, relocation.addend);
3950 try leb.writeIleb128(writer, relocation.addend);
39513951 }
39523952 log.debug("Emit relocation: {}", .{relocation});
39533953 }
src/link/Wasm/Object.zig+32-32
......@@ -590,7 +590,7 @@ fn Parser(comptime ReaderType: type) type {
590590 const reader = parser.reader.reader();
591591 for (try readVec(&parser.object.features, reader, gpa)) |*feature| {
592592 const prefix = try readEnum(types.Feature.Prefix, reader);
593 const name_len = try leb.readULEB128(u32, reader);
593 const name_len = try leb.readUleb128(u32, reader);
594594 const name = try gpa.alloc(u8, name_len);
595595 defer gpa.free(name);
596596 try reader.readNoEof(name);
......@@ -613,8 +613,8 @@ fn Parser(comptime ReaderType: type) type {
613613 /// they apply to.
614614 fn parseRelocations(parser: *ObjectParser, gpa: Allocator) !void {
615615 const reader = parser.reader.reader();
616 const section = try leb.readULEB128(u32, reader);
617 const count = try leb.readULEB128(u32, reader);
616 const section = try leb.readUleb128(u32, reader);
617 const count = try leb.readUleb128(u32, reader);
618618 const relocations = try gpa.alloc(types.Relocation, count);
619619 errdefer gpa.free(relocations);
620620
......@@ -628,9 +628,9 @@ fn Parser(comptime ReaderType: type) type {
628628 const rel_type_enum = std.meta.intToEnum(types.Relocation.RelocationType, rel_type) catch return error.MalformedSection;
629629 relocation.* = .{
630630 .relocation_type = rel_type_enum,
631 .offset = try leb.readULEB128(u32, reader),
632 .index = try leb.readULEB128(u32, reader),
633 .addend = if (rel_type_enum.addendIsPresent()) try leb.readILEB128(i32, reader) else 0,
631 .offset = try leb.readUleb128(u32, reader),
632 .index = try leb.readUleb128(u32, reader),
633 .addend = if (rel_type_enum.addendIsPresent()) try leb.readIleb128(i32, reader) else 0,
634634 };
635635 log.debug("Found relocation: type({s}) offset({d}) index({d}) addend({?d})", .{
636636 @tagName(relocation.relocation_type),
......@@ -651,7 +651,7 @@ fn Parser(comptime ReaderType: type) type {
651651 var limited = std.io.limitedReader(parser.reader.reader(), payload_size);
652652 const limited_reader = limited.reader();
653653
654 const version = try leb.readULEB128(u32, limited_reader);
654 const version = try leb.readUleb128(u32, limited_reader);
655655 log.debug("Link meta data version: {d}", .{version});
656656 if (version != 2) return error.UnsupportedVersion;
657657
......@@ -667,30 +667,30 @@ fn Parser(comptime ReaderType: type) type {
667667 /// `parser` is used to provide access to other sections that may be needed,
668668 /// such as access to the `import` section to find the name of a symbol.
669669 fn parseSubsection(parser: *ObjectParser, gpa: Allocator, reader: anytype) !void {
670 const sub_type = try leb.readULEB128(u8, reader);
670 const sub_type = try leb.readUleb128(u8, reader);
671671 log.debug("Found subsection: {s}", .{@tagName(@as(types.SubsectionType, @enumFromInt(sub_type)))});
672 const payload_len = try leb.readULEB128(u32, reader);
672 const payload_len = try leb.readUleb128(u32, reader);
673673 if (payload_len == 0) return;
674674
675675 var limited = std.io.limitedReader(reader, payload_len);
676676 const limited_reader = limited.reader();
677677
678678 // every subsection contains a 'count' field
679 const count = try leb.readULEB128(u32, limited_reader);
679 const count = try leb.readUleb128(u32, limited_reader);
680680
681681 switch (@as(types.SubsectionType, @enumFromInt(sub_type))) {
682682 .WASM_SEGMENT_INFO => {
683683 const segments = try gpa.alloc(types.Segment, count);
684684 errdefer gpa.free(segments);
685685 for (segments) |*segment| {
686 const name_len = try leb.readULEB128(u32, reader);
686 const name_len = try leb.readUleb128(u32, reader);
687687 const name = try gpa.alloc(u8, name_len);
688688 errdefer gpa.free(name);
689689 try reader.readNoEof(name);
690690 segment.* = .{
691691 .name = name,
692 .alignment = @enumFromInt(try leb.readULEB128(u32, reader)),
693 .flags = try leb.readULEB128(u32, reader),
692 .alignment = @enumFromInt(try leb.readUleb128(u32, reader)),
693 .flags = try leb.readUleb128(u32, reader),
694694 };
695695 log.debug("Found segment: {s} align({d}) flags({b})", .{
696696 segment.name,
......@@ -711,8 +711,8 @@ fn Parser(comptime ReaderType: type) type {
711711 errdefer gpa.free(funcs);
712712 for (funcs) |*func| {
713713 func.* = .{
714 .priority = try leb.readULEB128(u32, reader),
715 .symbol_index = try leb.readULEB128(u32, reader),
714 .priority = try leb.readUleb128(u32, reader),
715 .symbol_index = try leb.readUleb128(u32, reader),
716716 };
717717 log.debug("Found function - prio: {d}, index: {d}", .{ func.priority, func.symbol_index });
718718 }
......@@ -722,23 +722,23 @@ fn Parser(comptime ReaderType: type) type {
722722 const comdats = try gpa.alloc(types.Comdat, count);
723723 errdefer gpa.free(comdats);
724724 for (comdats) |*comdat| {
725 const name_len = try leb.readULEB128(u32, reader);
725 const name_len = try leb.readUleb128(u32, reader);
726726 const name = try gpa.alloc(u8, name_len);
727727 errdefer gpa.free(name);
728728 try reader.readNoEof(name);
729729
730 const flags = try leb.readULEB128(u32, reader);
730 const flags = try leb.readUleb128(u32, reader);
731731 if (flags != 0) {
732732 return error.UnexpectedValue;
733733 }
734734
735 const symbol_count = try leb.readULEB128(u32, reader);
735 const symbol_count = try leb.readUleb128(u32, reader);
736736 const symbols = try gpa.alloc(types.ComdatSym, symbol_count);
737737 errdefer gpa.free(symbols);
738738 for (symbols) |*symbol| {
739739 symbol.* = .{
740 .kind = @as(types.ComdatSym.Type, @enumFromInt(try leb.readULEB128(u8, reader))),
741 .index = try leb.readULEB128(u32, reader),
740 .kind = @as(types.ComdatSym.Type, @enumFromInt(try leb.readUleb128(u8, reader))),
741 .index = try leb.readUleb128(u32, reader),
742742 };
743743 }
744744
......@@ -799,8 +799,8 @@ fn Parser(comptime ReaderType: type) type {
799799 /// requires access to `Object` to find the name of a symbol when it's
800800 /// an import and flag `WASM_SYM_EXPLICIT_NAME` is not set.
801801 fn parseSymbol(parser: *ObjectParser, gpa: Allocator, reader: anytype) !Symbol {
802 const tag = @as(Symbol.Tag, @enumFromInt(try leb.readULEB128(u8, reader)));
803 const flags = try leb.readULEB128(u32, reader);
802 const tag = @as(Symbol.Tag, @enumFromInt(try leb.readUleb128(u8, reader)));
803 const flags = try leb.readUleb128(u32, reader);
804804 var symbol: Symbol = .{
805805 .flags = flags,
806806 .tag = tag,
......@@ -811,7 +811,7 @@ fn Parser(comptime ReaderType: type) type {
811811
812812 switch (tag) {
813813 .data => {
814 const name_len = try leb.readULEB128(u32, reader);
814 const name_len = try leb.readUleb128(u32, reader);
815815 const name = try gpa.alloc(u8, name_len);
816816 defer gpa.free(name);
817817 try reader.readNoEof(name);
......@@ -819,14 +819,14 @@ fn Parser(comptime ReaderType: type) type {
819819
820820 // Data symbols only have the following fields if the symbol is defined
821821 if (symbol.isDefined()) {
822 symbol.index = try leb.readULEB128(u32, reader);
822 symbol.index = try leb.readUleb128(u32, reader);
823823 // @TODO: We should verify those values
824 _ = try leb.readULEB128(u32, reader);
825 _ = try leb.readULEB128(u32, reader);
824 _ = try leb.readUleb128(u32, reader);
825 _ = try leb.readUleb128(u32, reader);
826826 }
827827 },
828828 .section => {
829 symbol.index = try leb.readULEB128(u32, reader);
829 symbol.index = try leb.readUleb128(u32, reader);
830830 const section_data = parser.object.relocatable_data.get(.custom).?;
831831 for (section_data) |*data| {
832832 if (data.section_index == symbol.index) {
......@@ -837,11 +837,11 @@ fn Parser(comptime ReaderType: type) type {
837837 }
838838 },
839839 else => {
840 symbol.index = try leb.readULEB128(u32, reader);
840 symbol.index = try leb.readUleb128(u32, reader);
841841 const is_undefined = symbol.isUndefined();
842842 const explicit_name = symbol.hasFlag(.WASM_SYM_EXPLICIT_NAME);
843843 symbol.name = if (!is_undefined or (is_undefined and explicit_name)) name: {
844 const name_len = try leb.readULEB128(u32, reader);
844 const name_len = try leb.readUleb128(u32, reader);
845845 const name = try gpa.alloc(u8, name_len);
846846 defer gpa.free(name);
847847 try reader.readNoEof(name);
......@@ -867,13 +867,13 @@ fn ElementType(comptime ptr: type) type {
867867 return meta.Elem(meta.Child(ptr));
868868}
869869
870/// Uses either `readILEB128` or `readULEB128` depending on the
870/// Uses either `readIleb128` or `readUleb128` depending on the
871871/// signedness of the given type `T`.
872872/// Asserts `T` is an integer.
873873fn readLeb(comptime T: type, reader: anytype) !T {
874874 return switch (@typeInfo(T).Int.signedness) {
875 .signed => try leb.readILEB128(T, reader),
876 .unsigned => try leb.readULEB128(T, reader),
875 .signed => try leb.readIleb128(T, reader),
876 .unsigned => try leb.readUleb128(T, reader),
877877 };
878878}
879879