diff options
| author | Andrew Kelley <andrew@ziglang.org> | 2023-10-31 13:02:38 -0700 |
|---|---|---|
| committer | Jacob Young <jacobly0@users.noreply.github.com> | 2023-10-31 21:37:35 -0400 |
| commit | 3fc6fc68129219a026ae3d7dff82513758e33a21 (patch) | |
| tree | ab1a4fdc8886513ddbbfa7167ecf92eede629cfd /src | |
| parent | 149200aac5f7f78fbb3427e3a9445c80efd2116b (diff) | |
| download | zig-3fc6fc68129219a026ae3d7dff82513758e33a21.tar.gz zig-3fc6fc68129219a026ae3d7dff82513758e33a21.zip | |
std.builtin.Endian: make the tags lower case
Let's take this breaking change opportunity to fix the style of this
enum.
Diffstat (limited to 'src')
41 files changed, 442 insertions, 442 deletions
diff --git a/src/Package/Fetch/git.zig b/src/Package/Fetch/git.zig index b584a9b64e..2a5344eaa4 100644 --- a/src/Package/Fetch/git.zig +++ b/src/Package/Fetch/git.zig @@ -305,12 +305,12 @@ const Odb = struct { const n_objects = odb.index_header.fan_out_table[255]; const offset_values_start = IndexHeader.size + n_objects * (oid_length + 4); try odb.index_file.seekTo(offset_values_start + found_index * 4); - const l1_offset: packed struct { value: u31, big: bool } = @bitCast(try odb.index_file.reader().readInt(u32, .Big)); + const l1_offset: packed struct { value: u31, big: bool } = @bitCast(try odb.index_file.reader().readInt(u32, .big)); const pack_offset = pack_offset: { if (l1_offset.big) { const l2_offset_values_start = offset_values_start + n_objects * 4; try odb.index_file.seekTo(l2_offset_values_start + l1_offset.value * 4); - break :pack_offset try odb.index_file.reader().readInt(u64, .Big); + break :pack_offset try odb.index_file.reader().readInt(u64, .big); } else { break :pack_offset l1_offset.value; } @@ -845,12 +845,12 @@ const PackHeader = struct { else => |other| return other, }; if (!mem.eql(u8, &actual_signature, signature)) return error.InvalidHeader; - const version = reader.readInt(u32, .Big) catch |e| switch (e) { + const version = reader.readInt(u32, .big) catch |e| switch (e) { error.EndOfStream => return error.InvalidHeader, else => |other| return other, }; if (version != supported_version) return error.UnsupportedVersion; - const total_objects = reader.readInt(u32, .Big) catch |e| switch (e) { + const total_objects = reader.readInt(u32, .big) catch |e| switch (e) { error.EndOfStream => return error.InvalidHeader, else => |other| return other, }; @@ -966,14 +966,14 @@ const IndexHeader = struct { fn read(reader: anytype) !IndexHeader { var header_bytes = try reader.readBytesNoEof(size); if (!mem.eql(u8, header_bytes[0..4], signature)) return error.InvalidHeader; - const version = mem.readInt(u32, header_bytes[4..8], .Big); + const version = mem.readInt(u32, header_bytes[4..8], .big); if (version != supported_version) return error.UnsupportedVersion; var fan_out_table: [256]u32 = undefined; var fan_out_table_stream = std.io.fixedBufferStream(header_bytes[8..]); const fan_out_table_reader = fan_out_table_stream.reader(); for (&fan_out_table) |*entry| { - entry.* = fan_out_table_reader.readInt(u32, .Big) catch unreachable; + entry.* = fan_out_table_reader.readInt(u32, .big) catch unreachable; } return .{ .fan_out_table = fan_out_table }; } @@ -1041,9 +1041,9 @@ pub fn indexPack(allocator: Allocator, pack: std.fs.File, index_writer: anytype) var index_hashed_writer = hashedWriter(index_writer, Sha1.init(.{})); const writer = index_hashed_writer.writer(); try writer.writeAll(IndexHeader.signature); - try writer.writeInt(u32, IndexHeader.supported_version, .Big); + try writer.writeInt(u32, IndexHeader.supported_version, .big); for (fan_out_table) |fan_out_entry| { - try writer.writeInt(u32, fan_out_entry, .Big); + try writer.writeInt(u32, fan_out_entry, .big); } for (oids.items) |oid| { @@ -1051,7 +1051,7 @@ pub fn indexPack(allocator: Allocator, pack: std.fs.File, index_writer: anytype) } for (oids.items) |oid| { - try writer.writeInt(u32, index_entries.get(oid).?.crc32, .Big); + try writer.writeInt(u32, index_entries.get(oid).?.crc32, .big); } var big_offsets = std.ArrayListUnmanaged(u64){}; @@ -1059,15 +1059,15 @@ pub fn indexPack(allocator: Allocator, pack: std.fs.File, index_writer: anytype) for (oids.items) |oid| { const offset = index_entries.get(oid).?.offset; if (offset <= std.math.maxInt(u31)) { - try writer.writeInt(u32, @intCast(offset), .Big); + try writer.writeInt(u32, @intCast(offset), .big); } else { const index = big_offsets.items.len; try big_offsets.append(allocator, offset); - try writer.writeInt(u32, @as(u32, @intCast(index)) | (1 << 31), .Big); + try writer.writeInt(u32, @as(u32, @intCast(index)) | (1 << 31), .big); } } for (big_offsets.items) |offset| { - try writer.writeInt(u64, offset, .Big); + try writer.writeInt(u64, offset, .big); } try writer.writeAll(&pack_checksum); diff --git a/src/Sema.zig b/src/Sema.zig index 293633dbc0..e8eeb78c71 100644 --- a/src/Sema.zig +++ b/src/Sema.zig @@ -26835,7 +26835,7 @@ fn structFieldPtrByIndex( // cause miscompilations; it only means the field pointer uses bit masking when it // might not be strictly necessary. if (parent_align != .none and ptr_ty_data.packed_offset.bit_offset % 8 == 0 and - target.cpu.arch.endian() == .Little) + target.cpu.arch.endian() == .little) { const elem_size_bytes = try sema.typeAbiSize(ptr_ty_data.child.toType()); const elem_size_bits = ptr_ty_data.child.toType().bitSize(mod); @@ -30736,8 +30736,8 @@ fn bitCastUnionFieldVal( if (field_size > old_size) { const min_size = @max(old_size, 1); switch (endian) { - .Little => @memset(buffer[min_size - 1 ..], 0xaa), - .Big => @memset(buffer[0 .. buffer.len - min_size + 1], 0xaa), + .little => @memset(buffer[min_size - 1 ..], 0xaa), + .big => @memset(buffer[0 .. buffer.len - min_size + 1], 0xaa), } } @@ -30746,7 +30746,7 @@ fn bitCastUnionFieldVal( error.ReinterpretDeclRef => return null, }; - break :offset if (endian == .Big) buffer.len - field_size else 0; + break :offset if (endian == .big) buffer.len - field_size else 0; }, .Auto => unreachable, }; diff --git a/src/arch/sparc64/CodeGen.zig b/src/arch/sparc64/CodeGen.zig index 26872ef29a..40f134ec90 100644 --- a/src/arch/sparc64/CodeGen.zig +++ b/src/arch/sparc64/CodeGen.zig @@ -1231,8 +1231,8 @@ fn airByteSwap(self: *Self, inst: Air.Inst.Index) !void { const abi_size = int_info.bits >> 3; const abi_align = operand_ty.abiAlignment(mod); const opposite_endian_asi = switch (self.target.cpu.arch.endian()) { - Endian.Big => ASI.asi_primary_little, - Endian.Little => ASI.asi_primary, + Endian.big => ASI.asi_primary_little, + Endian.little => ASI.asi_primary, }; switch (operand) { diff --git a/src/arch/sparc64/Emit.zig b/src/arch/sparc64/Emit.zig index 2c39c70269..4701035bc9 100644 --- a/src/arch/sparc64/Emit.zig +++ b/src/arch/sparc64/Emit.zig @@ -677,7 +677,7 @@ fn writeInstruction(emit: *Emit, instruction: Instruction) !void { // SPARCv9 instructions are always arranged in BE regardless of the // endianness mode the CPU is running in (Section 3.1 of the ISA specification). // This is to ease porting in case someone wants to do a LE SPARCv9 backend. - const endian = Endian.Big; + const endian = Endian.big; std.mem.writeInt(u32, try emit.code.addManyAsArray(4), instruction.toU32(), endian); } diff --git a/src/arch/wasm/CodeGen.zig b/src/arch/wasm/CodeGen.zig index 3d12a015ed..9da4d3003b 100644 --- a/src/arch/wasm/CodeGen.zig +++ b/src/arch/wasm/CodeGen.zig @@ -3364,7 +3364,7 @@ fn lowerConstant(func: *CodeGen, val: Value, ty: Type) InnerError!WValue { const backing_int_ty = struct_type.backingIntType(ip).toType(); const int_val = try mod.intValue( backing_int_ty, - mem.readInt(u64, &buf, .Little), + mem.readInt(u64, &buf, .little), ); return func.lowerConstant(int_val, backing_int_ty); }, diff --git a/src/arch/wasm/Emit.zig b/src/arch/wasm/Emit.zig index 80f44d8ce2..1d0c461c96 100644 --- a/src/arch/wasm/Emit.zig +++ b/src/arch/wasm/Emit.zig @@ -330,14 +330,14 @@ fn emitImm64(emit: *Emit, inst: Mir.Inst.Index) !void { fn emitFloat32(emit: *Emit, inst: Mir.Inst.Index) !void { const value: f32 = emit.mir.instructions.items(.data)[inst].float32; try emit.code.append(std.wasm.opcode(.f32_const)); - try emit.code.writer().writeInt(u32, @bitCast(value), .Little); + try emit.code.writer().writeInt(u32, @bitCast(value), .little); } fn emitFloat64(emit: *Emit, inst: Mir.Inst.Index) !void { const extra_index = emit.mir.instructions.items(.data)[inst].payload; const value = emit.mir.extraData(Mir.Float64, extra_index); try emit.code.append(std.wasm.opcode(.f64_const)); - try emit.code.writer().writeInt(u64, value.data.toU64(), .Little); + try emit.code.writer().writeInt(u64, value.data.toU64(), .little); } fn emitMemArg(emit: *Emit, tag: Mir.Inst.Tag, inst: Mir.Inst.Index) !void { diff --git a/src/arch/x86_64/Disassembler.zig b/src/arch/x86_64/Disassembler.zig index 426cf10feb..b15327fd21 100644 --- a/src/arch/x86_64/Disassembler.zig +++ b/src/arch/x86_64/Disassembler.zig @@ -360,13 +360,13 @@ fn parseImm(dis: *Disassembler, kind: Encoding.Op) !Immediate { var creader = std.io.countingReader(stream.reader()); const reader = creader.reader(); const imm = switch (kind) { - .imm8s, .rel8 => Immediate.s(try reader.readInt(i8, .Little)), - .imm16s, .rel16 => Immediate.s(try reader.readInt(i16, .Little)), - .imm32s, .rel32 => Immediate.s(try reader.readInt(i32, .Little)), - .imm8 => Immediate.u(try reader.readInt(u8, .Little)), - .imm16 => Immediate.u(try reader.readInt(u16, .Little)), - .imm32 => Immediate.u(try reader.readInt(u32, .Little)), - .imm64 => Immediate.u(try reader.readInt(u64, .Little)), + .imm8s, .rel8 => Immediate.s(try reader.readInt(i8, .little)), + .imm16s, .rel16 => Immediate.s(try reader.readInt(i16, .little)), + .imm32s, .rel32 => Immediate.s(try reader.readInt(i32, .little)), + .imm8 => Immediate.u(try reader.readInt(u8, .little)), + .imm16 => Immediate.u(try reader.readInt(u16, .little)), + .imm32 => Immediate.u(try reader.readInt(u32, .little)), + .imm64 => Immediate.u(try reader.readInt(u64, .little)), else => unreachable, }; dis.pos += std.math.cast(usize, creader.bytes_read) orelse return error.Overflow; @@ -376,7 +376,7 @@ fn parseImm(dis: *Disassembler, kind: Encoding.Op) !Immediate { fn parseOffset(dis: *Disassembler) !u64 { var stream = std.io.fixedBufferStream(dis.code[dis.pos..]); const reader = stream.reader(); - const offset = try reader.readInt(u64, .Little); + const offset = try reader.readInt(u64, .little); dis.pos += 8; return offset; } @@ -457,16 +457,16 @@ fn parseDisplacement(dis: *Disassembler, modrm: ModRm, sib: ?Sib) !i32 { const disp = disp: { if (sib) |info| { if (info.base == 0b101 and modrm.mod == 0) { - break :disp try reader.readInt(i32, .Little); + break :disp try reader.readInt(i32, .little); } } if (modrm.rip()) { - break :disp try reader.readInt(i32, .Little); + break :disp try reader.readInt(i32, .little); } break :disp switch (modrm.mod) { 0b00 => 0, - 0b01 => try reader.readInt(i8, .Little), - 0b10 => try reader.readInt(i32, .Little), + 0b01 => try reader.readInt(i8, .little), + 0b10 => try reader.readInt(i32, .little), 0b11 => unreachable, }; }; diff --git a/src/arch/x86_64/Emit.zig b/src/arch/x86_64/Emit.zig index e6f2db3401..36f4b05a6e 100644 --- a/src/arch/x86_64/Emit.zig +++ b/src/arch/x86_64/Emit.zig @@ -253,7 +253,7 @@ fn fixupRelocs(emit: *Emit) Error!void { const target = emit.code_offset_mapping.get(reloc.target) orelse return emit.fail("JMP/CALL relocation target not found!", .{}); const disp = @as(i32, @intCast(@as(i64, @intCast(target)) - @as(i64, @intCast(reloc.source + reloc.length)))); - mem.writeInt(i32, emit.code.items[reloc.offset..][0..4], disp, .Little); + mem.writeInt(i32, emit.code.items[reloc.offset..][0..4], disp, .little); } } diff --git a/src/arch/x86_64/encoder.zig b/src/arch/x86_64/encoder.zig index 9d629dbff7..517dd1af8d 100644 --- a/src/arch/x86_64/encoder.zig +++ b/src/arch/x86_64/encoder.zig @@ -998,7 +998,7 @@ fn Encoder(comptime T: type, comptime opts: Options) type { /// /// It is sign-extended to 64 bits by the cpu. pub fn disp32(self: Self, disp: i32) !void { - try self.writer.writeInt(i32, disp, .Little); + try self.writer.writeInt(i32, disp, .little); } /// Encode an 8 bit immediate @@ -1012,21 +1012,21 @@ fn Encoder(comptime T: type, comptime opts: Options) type { /// /// It is sign-extended to 64 bits by the cpu. pub fn imm16(self: Self, imm: u16) !void { - try self.writer.writeInt(u16, imm, .Little); + try self.writer.writeInt(u16, imm, .little); } /// Encode an 32 bit immediate /// /// It is sign-extended to 64 bits by the cpu. pub fn imm32(self: Self, imm: u32) !void { - try self.writer.writeInt(u32, imm, .Little); + try self.writer.writeInt(u32, imm, .little); } /// Encode an 64 bit immediate /// /// It is sign-extended to 64 bits by the cpu. pub fn imm64(self: Self, imm: u64) !void { - try self.writer.writeInt(u64, imm, .Little); + try self.writer.writeInt(u64, imm, .little); } }; } diff --git a/src/codegen/c.zig b/src/codegen/c.zig index 83d921ed9f..cf9467b70e 100644 --- a/src/codegen/c.zig +++ b/src/codegen/c.zig @@ -4666,8 +4666,8 @@ fn bitcast(f: *Function, dest_ty: Type, operand: CValue, operand_ty: Type) !Loca try f.writeCValue(writer, local, .Other); if (dest_cty.castTag(.array)) |pl| { try writer.print("[{d}]", .{switch (target.cpu.arch.endian()) { - .Little => pl.data.len - 1, - .Big => 0, + .little => pl.data.len - 1, + .big => 0, }}); const elem_cty = f.indexToCType(pl.data.elem_type); wrap_cty = elem_cty.toSignedness(dest_info.signedness); @@ -4697,8 +4697,8 @@ fn bitcast(f: *Function, dest_ty: Type, operand: CValue, operand_ty: Type) !Loca try f.writeCValue(writer, local, .Other); if (dest_cty.castTag(.array)) |pl| { try writer.print("[{d}]", .{switch (target.cpu.arch.endian()) { - .Little => pl.data.len - 1, - .Big => 0, + .little => pl.data.len - 1, + .big => 0, }}); } if (need_bitcasts) try writer.writeByte(')'); @@ -7652,13 +7652,13 @@ fn formatIntLiteral( else => .{ .cty = CType.initTag(.void), .count = 1, - .endian = .Little, + .endian = .little, .homogeneous = true, }, .zig_u128, .zig_i128 => .{ .cty = CType.initTag(.uint64_t), .count = 2, - .endian = .Big, + .endian = .big, .homogeneous = false, }, .array => info: { @@ -7729,8 +7729,8 @@ fn formatIntLiteral( const most_significant_limb_i = wrap.len - limbs_per_c_limb; while (limb_offset < wrap.len) : (limb_offset += limbs_per_c_limb) { const limb_i = switch (c_limb_info.endian) { - .Little => limb_offset, - .Big => most_significant_limb_i - limb_offset, + .little => limb_offset, + .big => most_significant_limb_i - limb_offset, }; var c_limb_mut = BigInt.Mutable{ .limbs = wrap.limbs[limb_i..][0..limbs_per_c_limb], diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig index 9edc456b35..356e4c318b 100644 --- a/src/codegen/llvm.zig +++ b/src/codegen/llvm.zig @@ -342,8 +342,8 @@ const DataLayoutBuilder = struct { writer: anytype, ) @TypeOf(writer).Error!void { try writer.writeByte(switch (self.target.cpu.arch.endian()) { - .Little => 'e', - .Big => 'E', + .little => 'e', + .big => 'E', }); switch (self.target.cpu.arch) { .amdgcn, @@ -10453,7 +10453,7 @@ pub const FuncGen = struct { else payload_llvm_ty; const loaded = try fg.wip.load(access_kind, load_llvm_ty, payload_ptr, payload_alignment, ""); - const shifted = if (payload_llvm_ty != load_llvm_ty and o.target.cpu.arch.endian() == .Big) + const shifted = if (payload_llvm_ty != load_llvm_ty and o.target.cpu.arch.endian() == .big) try fg.wip.bin(.lshr, loaded, try o.builder.intValue( load_llvm_ty, (payload_ty.abiSize(mod) - (std.math.divCeil(u64, payload_ty.bitSize(mod), 8) catch unreachable)) * 8, diff --git a/src/glibc.zig b/src/glibc.zig index 1a50f6b7c5..d719dab491 100644 --- a/src/glibc.zig +++ b/src/glibc.zig @@ -751,7 +751,7 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: *std.Progress.Node) !vo var inc_i: usize = 0; - const fn_inclusions_len = mem.readInt(u16, metadata.inclusions[inc_i..][0..2], .Little); + const fn_inclusions_len = mem.readInt(u16, metadata.inclusions[inc_i..][0..2], .little); inc_i += 2; var sym_i: usize = 0; @@ -768,7 +768,7 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: *std.Progress.Node) !vo versions_len = 0; break :n name; }; - const targets = mem.readInt(u32, metadata.inclusions[inc_i..][0..4], .Little); + const targets = mem.readInt(u32, metadata.inclusions[inc_i..][0..4], .little); inc_i += 4; const lib_index = metadata.inclusions[inc_i]; @@ -882,7 +882,7 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: *std.Progress.Node) !vo try stubs_asm.appendSlice(".data\n"); - const obj_inclusions_len = mem.readInt(u16, metadata.inclusions[inc_i..][0..2], .Little); + const obj_inclusions_len = mem.readInt(u16, metadata.inclusions[inc_i..][0..2], .little); inc_i += 2; sym_i = 0; @@ -899,10 +899,10 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: *std.Progress.Node) !vo versions_len = 0; break :n name; }; - const targets = mem.readInt(u32, metadata.inclusions[inc_i..][0..4], .Little); + const targets = mem.readInt(u32, metadata.inclusions[inc_i..][0..4], .little); inc_i += 4; - const size = mem.readInt(u16, metadata.inclusions[inc_i..][0..2], .Little); + const size = mem.readInt(u16, metadata.inclusions[inc_i..][0..2], .little); inc_i += 2; const lib_index = metadata.inclusions[inc_i]; diff --git a/src/link/Coff.zig b/src/link/Coff.zig index affc7406b7..fd2415bff5 100644 --- a/src/link/Coff.zig +++ b/src/link/Coff.zig @@ -856,12 +856,12 @@ fn writeOffsetTableEntry(self: *Coff, index: usize) !void { switch (self.ptr_width) { .p32 => { var buf: [4]u8 = undefined; - mem.writeInt(u32, &buf, @as(u32, @intCast(entry_value + self.getImageBase())), .Little); + mem.writeInt(u32, &buf, @as(u32, @intCast(entry_value + self.getImageBase())), .little); try self.base.file.?.pwriteAll(&buf, file_offset); }, .p64 => { var buf: [8]u8 = undefined; - mem.writeInt(u64, &buf, entry_value + self.getImageBase(), .Little); + mem.writeInt(u64, &buf, entry_value + self.getImageBase(), .little); try self.base.file.?.pwriteAll(&buf, file_offset); }, } @@ -889,14 +889,14 @@ fn writeOffsetTableEntry(self: *Coff, index: usize) !void { switch (self.ptr_width) { .p32 => { var buf: [4]u8 = undefined; - mem.writeInt(u32, &buf, @as(u32, @intCast(entry_value + slide)), .Little); + mem.writeInt(u32, &buf, @as(u32, @intCast(entry_value + slide)), .little); writeMem(handle, pvaddr, &buf) catch |err| { log.warn("writing to protected memory failed with error: {s}", .{@errorName(err)}); }; }, .p64 => { var buf: [8]u8 = undefined; - mem.writeInt(u64, &buf, entry_value + slide, .Little); + mem.writeInt(u64, &buf, entry_value + slide, .little); writeMem(handle, pvaddr, &buf) catch |err| { log.warn("writing to protected memory failed with error: {s}", .{@errorName(err)}); }; @@ -2076,7 +2076,7 @@ fn writeImportTables(self: *Coff) !void { lookup_table_offset += lookup_entry_size; // Names table entry - mem.writeInt(u16, buffer.items[names_table_offset..][0..2], 0, .Little); // Hint set to 0 until we learn how to parse DLLs + mem.writeInt(u16, buffer.items[names_table_offset..][0..2], 0, .little); // Hint set to 0 until we learn how to parse DLLs names_table_offset += 2; @memcpy(buffer.items[names_table_offset..][0..import_name.len], import_name); names_table_offset += @as(u32, @intCast(import_name.len)); @@ -2089,7 +2089,7 @@ fn writeImportTables(self: *Coff) !void { } // IAT sentinel - mem.writeInt(u64, buffer.items[iat_offset..][0..lookup_entry_size], 0, .Little); + mem.writeInt(u64, buffer.items[iat_offset..][0..lookup_entry_size], 0, .little); iat_offset += 8; // Lookup table sentinel @@ -2157,7 +2157,7 @@ fn writeStrtab(self: *Coff) !void { buffer.appendSliceAssumeCapacity(self.strtab.items()); // Here, we do a trick in that we do not commit the size of the strtab to strtab buffer, instead // we write the length of the strtab to a temporary buffer that goes to file. - mem.writeInt(u32, buffer.items[0..4], @as(u32, @intCast(self.strtab.len())), .Little); + mem.writeInt(u32, buffer.items[0..4], @as(u32, @intCast(self.strtab.len())), .little); try self.base.file.?.pwriteAll(buffer.items, self.strtab_offset.?); } @@ -2180,7 +2180,7 @@ fn writeHeader(self: *Coff) !void { try buffer.ensureTotalCapacity(self.getSizeOfHeaders()); writer.writeAll(msdos_stub) catch unreachable; - mem.writeInt(u32, buffer.items[0x3c..][0..4], msdos_stub.len, .Little); + mem.writeInt(u32, buffer.items[0x3c..][0..4], msdos_stub.len, .little); writer.writeAll("PE\x00\x00") catch unreachable; var flags = coff.CoffHeaderFlags{ @@ -2548,7 +2548,7 @@ fn setSymbolName(self: *Coff, symbol: *coff.Symbol, name: []const u8) !void { } const offset = try self.strtab.insert(self.base.allocator, name); @memset(symbol.name[0..4], 0); - mem.writeInt(u32, symbol.name[4..8], offset, .Little); + mem.writeInt(u32, symbol.name[4..8], offset, .little); } fn logSymAttributes(sym: *const coff.Symbol, buf: *[4]u8) []const u8 { diff --git a/src/link/Coff/Relocation.zig b/src/link/Coff/Relocation.zig index 050ab0d9be..84cfcdc18a 100644 --- a/src/link/Coff/Relocation.zig +++ b/src/link/Coff/Relocation.zig @@ -137,7 +137,7 @@ fn resolveAarch64(self: Relocation, ctx: Context) void { }; inst.pc_relative_address.immhi = @as(u19, @truncate(pages >> 2)); inst.pc_relative_address.immlo = @as(u2, @truncate(pages)); - mem.writeInt(u32, buffer[0..4], inst.toU32(), .Little); + mem.writeInt(u32, buffer[0..4], inst.toU32(), .little); }, .got_pageoff, .import_pageoff, .pageoff => { assert(!self.pcrel); @@ -151,7 +151,7 @@ fn resolveAarch64(self: Relocation, ctx: Context) void { ), buffer[0..4]), }; inst.add_subtract_immediate.imm12 = narrowed; - mem.writeInt(u32, buffer[0..4], inst.toU32(), .Little); + mem.writeInt(u32, buffer[0..4], inst.toU32(), .little); } else { var inst = aarch64.Instruction{ .load_store_register = mem.bytesToValue(meta.TagPayload( @@ -173,7 +173,7 @@ fn resolveAarch64(self: Relocation, ctx: Context) void { } }; inst.load_store_register.offset = offset; - mem.writeInt(u32, buffer[0..4], inst.toU32(), .Little); + mem.writeInt(u32, buffer[0..4], inst.toU32(), .little); } }, .direct => { @@ -183,9 +183,9 @@ fn resolveAarch64(self: Relocation, ctx: Context) void { u32, buffer[0..4], @as(u32, @truncate(ctx.target_vaddr + ctx.image_base)), - .Little, + .little, ), - 3 => mem.writeInt(u64, buffer[0..8], ctx.target_vaddr + ctx.image_base, .Little), + 3 => mem.writeInt(u64, buffer[0..8], ctx.target_vaddr + ctx.image_base, .little), else => unreachable, } }, @@ -208,17 +208,17 @@ fn resolveX86(self: Relocation, ctx: Context) void { .got, .import => { assert(self.pcrel); const disp = @as(i32, @intCast(ctx.target_vaddr)) - @as(i32, @intCast(ctx.source_vaddr)) - 4; - mem.writeInt(i32, buffer[0..4], disp, .Little); + mem.writeInt(i32, buffer[0..4], disp, .little); }, .direct => { if (self.pcrel) { const disp = @as(i32, @intCast(ctx.target_vaddr)) - @as(i32, @intCast(ctx.source_vaddr)) - 4; - mem.writeInt(i32, buffer[0..4], disp, .Little); + mem.writeInt(i32, buffer[0..4], disp, .little); } else switch (ctx.ptr_width) { - .p32 => mem.writeInt(u32, buffer[0..4], @as(u32, @intCast(ctx.target_vaddr + ctx.image_base)), .Little), + .p32 => mem.writeInt(u32, buffer[0..4], @as(u32, @intCast(ctx.target_vaddr + ctx.image_base)), .little), .p64 => switch (self.length) { - 2 => mem.writeInt(u32, buffer[0..4], @as(u32, @truncate(ctx.target_vaddr + ctx.image_base)), .Little), - 3 => mem.writeInt(u64, buffer[0..8], ctx.target_vaddr + ctx.image_base, .Little), + 2 => mem.writeInt(u32, buffer[0..4], @as(u32, @truncate(ctx.target_vaddr + ctx.image_base)), .little), + 3 => mem.writeInt(u64, buffer[0..8], ctx.target_vaddr + ctx.image_base, .little), else => unreachable, }, } diff --git a/src/link/Elf.zig b/src/link/Elf.zig index d368e95edc..63642d4c6a 100644 --- a/src/link/Elf.zig +++ b/src/link/Elf.zig @@ -2719,8 +2719,8 @@ fn writeHeader(self: *Elf) !void { const endian = self.base.options.target.cpu.arch.endian(); hdr_buf[index] = switch (endian) { - .Little => elf.ELFDATA2LSB, - .Big => elf.ELFDATA2MSB, + .little => elf.ELFDATA2LSB, + .big => elf.ELFDATA2MSB, }; index += 1; diff --git a/src/link/Elf/Atom.zig b/src/link/Elf/Atom.zig index f3b41f2e10..7527b61988 100644 --- a/src/link/Elf/Atom.zig +++ b/src/link/Elf/Atom.zig @@ -786,43 +786,43 @@ pub fn resolveRelocsAlloc(self: Atom, elf_file: *Elf, code: []u8) !void { elf.R_X86_64_PLT32, elf.R_X86_64_PC32, - => try cwriter.writeInt(i32, @as(i32, @intCast(S + A - P)), .Little), + => try cwriter.writeInt(i32, @as(i32, @intCast(S + A - P)), .little), - elf.R_X86_64_GOTPCREL => try cwriter.writeInt(i32, @as(i32, @intCast(G + GOT + A - P)), .Little), - elf.R_X86_64_GOTPC32 => try cwriter.writeInt(i32, @as(i32, @intCast(GOT + A - P)), .Little), - elf.R_X86_64_GOTPC64 => try cwriter.writeInt(i64, GOT + A - P, .Little), + elf.R_X86_64_GOTPCREL => try cwriter.writeInt(i32, @as(i32, @intCast(G + GOT + A - P)), .little), + elf.R_X86_64_GOTPC32 => try cwriter.writeInt(i32, @as(i32, @intCast(GOT + A - P)), .little), + elf.R_X86_64_GOTPC64 => try cwriter.writeInt(i64, GOT + A - P, .little), elf.R_X86_64_GOTPCRELX => { if (!target.flags.import and !target.isIFunc(elf_file) and !target.isAbs(elf_file)) blk: { x86_64.relaxGotpcrelx(code[r_offset - 2 ..]) catch break :blk; - try cwriter.writeInt(i32, @as(i32, @intCast(S + A - P)), .Little); + try cwriter.writeInt(i32, @as(i32, @intCast(S + A - P)), .little); continue; } - try cwriter.writeInt(i32, @as(i32, @intCast(G + GOT + A - P)), .Little); + try cwriter.writeInt(i32, @as(i32, @intCast(G + GOT + A - P)), .little); }, elf.R_X86_64_REX_GOTPCRELX => { if (!target.flags.import and !target.isIFunc(elf_file) and !target.isAbs(elf_file)) blk: { x86_64.relaxRexGotpcrelx(code[r_offset - 3 ..]) catch break :blk; - try cwriter.writeInt(i32, @as(i32, @intCast(S + A - P)), .Little); + try cwriter.writeInt(i32, @as(i32, @intCast(S + A - P)), .little); continue; } - try cwriter.writeInt(i32, @as(i32, @intCast(G + GOT + A - P)), .Little); + try cwriter.writeInt(i32, @as(i32, @intCast(G + GOT + A - P)), .little); }, - elf.R_X86_64_32 => try cwriter.writeInt(u32, @as(u32, @truncate(@as(u64, @intCast(S + A)))), .Little), - elf.R_X86_64_32S => try cwriter.writeInt(i32, @as(i32, @truncate(S + A)), .Little), + elf.R_X86_64_32 => try cwriter.writeInt(u32, @as(u32, @truncate(@as(u64, @intCast(S + A)))), .little), + elf.R_X86_64_32S => try cwriter.writeInt(i32, @as(i32, @truncate(S + A)), .little), - elf.R_X86_64_TPOFF32 => try cwriter.writeInt(i32, @as(i32, @truncate(S + A - TP)), .Little), - elf.R_X86_64_TPOFF64 => try cwriter.writeInt(i64, S + A - TP, .Little), + elf.R_X86_64_TPOFF32 => try cwriter.writeInt(i32, @as(i32, @truncate(S + A - TP)), .little), + elf.R_X86_64_TPOFF64 => try cwriter.writeInt(i64, S + A - TP, .little), - elf.R_X86_64_DTPOFF32 => try cwriter.writeInt(i32, @as(i32, @truncate(S + A - DTP)), .Little), - elf.R_X86_64_DTPOFF64 => try cwriter.writeInt(i64, S + A - DTP, .Little), + elf.R_X86_64_DTPOFF32 => try cwriter.writeInt(i32, @as(i32, @truncate(S + A - DTP)), .little), + elf.R_X86_64_DTPOFF64 => try cwriter.writeInt(i64, S + A - DTP, .little), elf.R_X86_64_TLSGD => { if (target.flags.has_tlsgd) { const S_ = @as(i64, @intCast(target.tlsGdAddress(elf_file))); - try cwriter.writeInt(i32, @as(i32, @intCast(S_ + A - P)), .Little); + try cwriter.writeInt(i32, @as(i32, @intCast(S_ + A - P)), .little); } else if (target.flags.has_gottp) { const S_ = @as(i64, @intCast(target.gotTpAddress(elf_file))); try x86_64.relaxTlsGdToIe(self, rels[i .. i + 2], @intCast(S_ - P), elf_file, &stream); @@ -843,7 +843,7 @@ pub fn resolveRelocsAlloc(self: Atom, elf_file: *Elf, code: []u8) !void { if (elf_file.got.tlsld_index) |entry_index| { const tlsld_entry = elf_file.got.entries.items[entry_index]; const S_ = @as(i64, @intCast(tlsld_entry.address(elf_file))); - try cwriter.writeInt(i32, @as(i32, @intCast(S_ + A - P)), .Little); + try cwriter.writeInt(i32, @as(i32, @intCast(S_ + A - P)), .little); } else { try x86_64.relaxTlsLdToLe( self, @@ -859,10 +859,10 @@ pub fn resolveRelocsAlloc(self: Atom, elf_file: *Elf, code: []u8) !void { elf.R_X86_64_GOTPC32_TLSDESC => { if (target.flags.has_tlsdesc) { const S_ = @as(i64, @intCast(target.tlsDescAddress(elf_file))); - try cwriter.writeInt(i32, @as(i32, @intCast(S_ + A - P)), .Little); + try cwriter.writeInt(i32, @as(i32, @intCast(S_ + A - P)), .little); } else { try x86_64.relaxGotPcTlsDesc(code[r_offset - 3 ..]); - try cwriter.writeInt(i32, @as(i32, @intCast(S - TP)), .Little); + try cwriter.writeInt(i32, @as(i32, @intCast(S - TP)), .little); } }, @@ -874,18 +874,18 @@ pub fn resolveRelocsAlloc(self: Atom, elf_file: *Elf, code: []u8) !void { elf.R_X86_64_GOTTPOFF => { if (target.flags.has_gottp) { const S_ = @as(i64, @intCast(target.gotTpAddress(elf_file))); - try cwriter.writeInt(i32, @as(i32, @intCast(S_ + A - P)), .Little); + try cwriter.writeInt(i32, @as(i32, @intCast(S_ + A - P)), .little); } else { x86_64.relaxGotTpOff(code[r_offset - 3 ..]) catch unreachable; - try cwriter.writeInt(i32, @as(i32, @intCast(S - TP)), .Little); + try cwriter.writeInt(i32, @as(i32, @intCast(S - TP)), .little); } }, - elf.R_X86_64_GOT32 => try cwriter.writeInt(i32, @as(i32, @intCast(G + GOT + A)), .Little), + elf.R_X86_64_GOT32 => try cwriter.writeInt(i32, @as(i32, @intCast(G + GOT + A)), .little), // Zig custom relocations - Elf.R_X86_64_ZIG_GOT32 => try cwriter.writeInt(u32, @as(u32, @intCast(ZIG_GOT + A)), .Little), - Elf.R_X86_64_ZIG_GOTPCREL => try cwriter.writeInt(i32, @as(i32, @intCast(ZIG_GOT + A - P)), .Little), + Elf.R_X86_64_ZIG_GOT32 => try cwriter.writeInt(u32, @as(u32, @intCast(ZIG_GOT + A)), .little), + Elf.R_X86_64_ZIG_GOTPCREL => try cwriter.writeInt(i32, @as(i32, @intCast(ZIG_GOT + A - P)), .little), else => {}, } @@ -920,7 +920,7 @@ fn resolveDynAbsReloc( .copyrel, .cplt, .none, - => try writer.writeInt(i32, @as(i32, @truncate(S + A)), .Little), + => try writer.writeInt(i32, @as(i32, @truncate(S + A)), .little), .dyn_copyrel => { if (is_writeable or elf_file.base.options.z_nocopyreloc) { @@ -932,7 +932,7 @@ fn resolveDynAbsReloc( }); try applyDynamicReloc(A, elf_file, writer); } else { - try writer.writeInt(i32, @as(i32, @truncate(S + A)), .Little); + try writer.writeInt(i32, @as(i32, @truncate(S + A)), .little); } }, @@ -946,7 +946,7 @@ fn resolveDynAbsReloc( }); try applyDynamicReloc(A, elf_file, writer); } else { - try writer.writeInt(i32, @as(i32, @truncate(S + A)), .Little); + try writer.writeInt(i32, @as(i32, @truncate(S + A)), .little); } }, @@ -984,7 +984,7 @@ fn resolveDynAbsReloc( fn applyDynamicReloc(value: i64, elf_file: *Elf, writer: anytype) !void { _ = elf_file; // if (elf_file.options.apply_dynamic_relocs) { - try writer.writeInt(i64, value, .Little); + try writer.writeInt(i64, value, .little); // } } @@ -1058,22 +1058,22 @@ pub fn resolveRelocsNonAlloc(self: Atom, elf_file: *Elf, code: []u8, undefs: any switch (r_type) { elf.R_X86_64_NONE => unreachable, - elf.R_X86_64_8 => try cwriter.writeInt(u8, @as(u8, @bitCast(@as(i8, @intCast(S + A)))), .Little), - elf.R_X86_64_16 => try cwriter.writeInt(u16, @as(u16, @bitCast(@as(i16, @intCast(S + A)))), .Little), - elf.R_X86_64_32 => try cwriter.writeInt(u32, @as(u32, @bitCast(@as(i32, @intCast(S + A)))), .Little), - elf.R_X86_64_32S => try cwriter.writeInt(i32, @as(i32, @intCast(S + A)), .Little), - elf.R_X86_64_64 => try cwriter.writeInt(i64, S + A, .Little), - elf.R_X86_64_DTPOFF32 => try cwriter.writeInt(i32, @as(i32, @intCast(S + A - DTP)), .Little), - elf.R_X86_64_DTPOFF64 => try cwriter.writeInt(i64, S + A - DTP, .Little), - elf.R_X86_64_GOTOFF64 => try cwriter.writeInt(i64, S + A - GOT, .Little), - elf.R_X86_64_GOTPC64 => try cwriter.writeInt(i64, GOT + A, .Little), + elf.R_X86_64_8 => try cwriter.writeInt(u8, @as(u8, @bitCast(@as(i8, @intCast(S + A)))), .little), + elf.R_X86_64_16 => try cwriter.writeInt(u16, @as(u16, @bitCast(@as(i16, @intCast(S + A)))), .little), + elf.R_X86_64_32 => try cwriter.writeInt(u32, @as(u32, @bitCast(@as(i32, @intCast(S + A)))), .little), + elf.R_X86_64_32S => try cwriter.writeInt(i32, @as(i32, @intCast(S + A)), .little), + elf.R_X86_64_64 => try cwriter.writeInt(i64, S + A, .little), + elf.R_X86_64_DTPOFF32 => try cwriter.writeInt(i32, @as(i32, @intCast(S + A - DTP)), .little), + elf.R_X86_64_DTPOFF64 => try cwriter.writeInt(i64, S + A - DTP, .little), + elf.R_X86_64_GOTOFF64 => try cwriter.writeInt(i64, S + A - GOT, .little), + elf.R_X86_64_GOTPC64 => try cwriter.writeInt(i64, GOT + A, .little), elf.R_X86_64_SIZE32 => { const size = @as(i64, @intCast(target.elfSym(elf_file).st_size)); - try cwriter.writeInt(u32, @as(u32, @bitCast(@as(i32, @intCast(size + A)))), .Little); + try cwriter.writeInt(u32, @as(u32, @bitCast(@as(i32, @intCast(size + A)))), .little); }, elf.R_X86_64_SIZE64 => { const size = @as(i64, @intCast(target.elfSym(elf_file).st_size)); - try cwriter.writeInt(i64, @as(i64, @intCast(size + A)), .Little); + try cwriter.writeInt(i64, @as(i64, @intCast(size + A)), .little); }, else => try self.reportUnhandledRelocError(rel, elf_file), } @@ -1254,7 +1254,7 @@ const x86_64 = struct { 0x64, 0x48, 0x8b, 0x04, 0x25, 0, 0, 0, 0, // movq %fs:0,%rax 0x48, 0x03, 0x05, 0, 0, 0, 0, // add foo@gottpoff(%rip), %rax }; - std.mem.writeInt(i32, insts[12..][0..4], value - 12, .Little); + std.mem.writeInt(i32, insts[12..][0..4], value - 12, .little); try stream.seekBy(-4); try writer.writeAll(&insts); }, @@ -1292,7 +1292,7 @@ const x86_64 = struct { 0x64, 0x48, 0x8b, 0, // mov %fs:(%rax), %rax 0x48, 0x2d, 0, 0, 0, 0, // sub $tls_size, %rax }; - std.mem.writeInt(i32, insts[8..][0..4], value, .Little); + std.mem.writeInt(i32, insts[8..][0..4], value, .little); try stream.seekBy(-3); try writer.writeAll(&insts); }, @@ -1306,7 +1306,7 @@ const x86_64 = struct { 0x48, 0x2d, 0, 0, 0, 0, // sub $tls_size, %rax 0x90, // nop }; - std.mem.writeInt(i32, insts[8..][0..4], value, .Little); + std.mem.writeInt(i32, insts[8..][0..4], value, .little); try stream.seekBy(-3); try writer.writeAll(&insts); }, @@ -1392,7 +1392,7 @@ const x86_64 = struct { 0x64, 0x48, 0x8b, 0x04, 0x25, 0, 0, 0, 0, // movq %fs:0,%rax 0x48, 0x81, 0xc0, 0, 0, 0, 0, // add $tp_offset, %rax }; - std.mem.writeInt(i32, insts[12..][0..4], value, .Little); + std.mem.writeInt(i32, insts[12..][0..4], value, .little); try stream.seekBy(-4); try writer.writeAll(&insts); relocs_log.debug(" relaxing {} and {}", .{ diff --git a/src/link/Elf/eh_frame.zig b/src/link/Elf/eh_frame.zig index 3f291f9a77..caf6f9a051 100644 --- a/src/link/Elf/eh_frame.zig +++ b/src/link/Elf/eh_frame.zig @@ -33,7 +33,7 @@ pub const Fde = struct { pub fn ciePointer(fde: Fde, elf_file: *Elf) u32 { const fde_data = fde.data(elf_file); - return std.mem.readInt(u32, fde_data[4..8], .Little); + return std.mem.readInt(u32, fde_data[4..8], .little); } pub fn calcSize(fde: Fde) usize { @@ -217,10 +217,10 @@ pub const Iterator = struct { var stream = std.io.fixedBufferStream(it.data[it.pos..]); const reader = stream.reader(); - var size = try reader.readInt(u32, .Little); + var size = try reader.readInt(u32, .little); if (size == 0xFFFFFFFF) @panic("TODO"); - const id = try reader.readInt(u32, .Little); + const id = try reader.readInt(u32, .little); const record = Record{ .tag = if (id == 0) .cie else .fde, .offset = it.pos, @@ -298,10 +298,10 @@ fn resolveReloc(rec: anytype, sym: *const Symbol, rel: elf.Elf64_Rela, elf_file: var where = contents[offset..]; switch (rel.r_type()) { - elf.R_X86_64_32 => std.mem.writeInt(i32, where[0..4], @as(i32, @truncate(S + A)), .Little), - elf.R_X86_64_64 => std.mem.writeInt(i64, where[0..8], S + A, .Little), - elf.R_X86_64_PC32 => std.mem.writeInt(i32, where[0..4], @as(i32, @intCast(S - P + A)), .Little), - elf.R_X86_64_PC64 => std.mem.writeInt(i64, where[0..8], S - P + A, .Little), + elf.R_X86_64_32 => std.mem.writeInt(i32, where[0..4], @as(i32, @truncate(S + A)), .little), + elf.R_X86_64_64 => std.mem.writeInt(i64, where[0..8], S + A, .little), + elf.R_X86_64_PC32 => std.mem.writeInt(i32, where[0..4], @as(i32, @intCast(S - P + A)), .little), + elf.R_X86_64_PC64 => std.mem.writeInt(i64, where[0..8], S - P + A, .little), else => unreachable, } } @@ -342,7 +342,7 @@ pub fn writeEhFrame(elf_file: *Elf, writer: anytype) !void { i32, contents[4..8], @truncate(@as(i64, @intCast(fde.out_offset + 4)) - @as(i64, @intCast(fde.cie(elf_file).out_offset))), - .Little, + .little, ); for (fde.relocs(elf_file)) |rel| { @@ -354,7 +354,7 @@ pub fn writeEhFrame(elf_file: *Elf, writer: anytype) !void { } } - try writer.writeInt(u32, 0, .Little); + try writer.writeInt(u32, 0, .little); } pub fn writeEhFrameHdr(elf_file: *Elf, writer: anytype) !void { @@ -372,9 +372,9 @@ pub fn writeEhFrameHdr(elf_file: *Elf, writer: anytype) !void { i32, @truncate(@as(i64, @intCast(eh_frame_shdr.sh_addr)) - @as(i64, @intCast(eh_frame_hdr_shdr.sh_addr)) - 4), ))), - .Little, + .little, ); - try writer.writeInt(u32, num_fdes, .Little); + try writer.writeInt(u32, num_fdes, .little); const Entry = struct { init_addr: u32, diff --git a/src/link/Elf/synthetic_sections.zig b/src/link/Elf/synthetic_sections.zig index 0d78aea322..cfc2064fbe 100644 --- a/src/link/Elf/synthetic_sections.zig +++ b/src/link/Elf/synthetic_sections.zig @@ -878,9 +878,9 @@ pub const PltSection = struct { 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, // jmp qword ptr [rip] -> .got.plt[2] }; var disp = @as(i64, @intCast(got_plt_addr + 8)) - @as(i64, @intCast(plt_addr + 8)) - 4; - mem.writeInt(i32, preamble[8..][0..4], @as(i32, @intCast(disp)), .Little); + mem.writeInt(i32, preamble[8..][0..4], @as(i32, @intCast(disp)), .little); disp = @as(i64, @intCast(got_plt_addr + 16)) - @as(i64, @intCast(plt_addr + 14)) - 4; - mem.writeInt(i32, preamble[14..][0..4], @as(i32, @intCast(disp)), .Little); + mem.writeInt(i32, preamble[14..][0..4], @as(i32, @intCast(disp)), .little); try writer.writeAll(&preamble); try writer.writeByteNTimes(0xcc, preamble_size - preamble.len); @@ -894,8 +894,8 @@ pub const PltSection = struct { 0x41, 0xbb, 0x00, 0x00, 0x00, 0x00, // mov r11d, N 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, // jmp qword ptr [rip] -> .got.plt[N] }; - mem.writeInt(i32, entry[6..][0..4], @as(i32, @intCast(i)), .Little); - mem.writeInt(i32, entry[12..][0..4], @as(i32, @intCast(disp)), .Little); + mem.writeInt(i32, entry[6..][0..4], @as(i32, @intCast(i)), .little); + mem.writeInt(i32, entry[12..][0..4], @as(i32, @intCast(disp)), .little); try writer.writeAll(&entry); } } @@ -971,17 +971,17 @@ pub const GotPltSection = struct { { // [0]: _DYNAMIC const symbol = elf_file.symbol(elf_file.dynamic_index.?); - try writer.writeInt(u64, symbol.value, .Little); + try writer.writeInt(u64, symbol.value, .little); } // [1]: 0x0 // [2]: 0x0 - try writer.writeInt(u64, 0x0, .Little); - try writer.writeInt(u64, 0x0, .Little); + try writer.writeInt(u64, 0x0, .little); + try writer.writeInt(u64, 0x0, .little); if (elf_file.plt_section_index) |shndx| { const plt_addr = elf_file.shdrs.items[shndx].sh_addr; for (0..elf_file.plt.symbols.items.len) |_| { // [N]: .plt - try writer.writeInt(u64, plt_addr, .Little); + try writer.writeInt(u64, plt_addr, .little); } } } @@ -1023,7 +1023,7 @@ pub const PltGotSection = struct { 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, // jmp qword ptr [rip] -> .got[N] 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, }; - mem.writeInt(i32, entry[6..][0..4], @as(i32, @intCast(disp)), .Little); + mem.writeInt(i32, entry[6..][0..4], @as(i32, @intCast(disp)), .little); try writer.writeAll(&entry); } } @@ -1258,8 +1258,8 @@ pub const HashSection = struct { } try hs.buffer.ensureTotalCapacityPrecise(gpa, (2 + nsyms * 2) * 4); - hs.buffer.writer(gpa).writeInt(u32, @as(u32, @intCast(nsyms)), .Little) catch unreachable; - hs.buffer.writer(gpa).writeInt(u32, @as(u32, @intCast(nsyms)), .Little) catch unreachable; + hs.buffer.writer(gpa).writeInt(u32, @as(u32, @intCast(nsyms)), .little) catch unreachable; + hs.buffer.writer(gpa).writeInt(u32, @as(u32, @intCast(nsyms)), .little) catch unreachable; hs.buffer.writer(gpa).writeAll(mem.sliceAsBytes(buckets)) catch unreachable; hs.buffer.writer(gpa).writeAll(mem.sliceAsBytes(chains)) catch unreachable; } @@ -1322,10 +1322,10 @@ pub const GnuHashSection = struct { var counting = std.io.countingWriter(writer); const cwriter = counting.writer(); - try cwriter.writeInt(u32, hash.num_buckets, .Little); - try cwriter.writeInt(u32, export_off, .Little); - try cwriter.writeInt(u32, hash.num_bloom, .Little); - try cwriter.writeInt(u32, bloom_shift, .Little); + try cwriter.writeInt(u32, hash.num_buckets, .little); + try cwriter.writeInt(u32, export_off, .little); + try cwriter.writeInt(u32, hash.num_bloom, .little); + try cwriter.writeInt(u32, bloom_shift, .little); const gpa = elf_file.base.allocator; const hashes = try gpa.alloc(u32, exports.len); diff --git a/src/link/MachO.zig b/src/link/MachO.zig index 55b9c617b1..5a246bcfd1 100644 --- a/src/link/MachO.zig +++ b/src/link/MachO.zig @@ -1222,7 +1222,7 @@ fn writeOffsetTableEntry(self: *MachO, index: usize) !void { log.debug("writing GOT entry {d}: @{x} => {x}", .{ index, vmaddr, entry_value }); var buf: [@sizeOf(u64)]u8 = undefined; - mem.writeInt(u64, &buf, entry_value, .Little); + mem.writeInt(u64, &buf, entry_value, .little); try self.base.file.?.pwriteAll(&buf, file_offset); if (is_hot_update_compatible) { @@ -1329,7 +1329,7 @@ fn writeStubTableEntry(self: *MachO, index: usize) !void { { var buf: [@sizeOf(u64)]u8 = undefined; - mem.writeInt(u64, &buf, stub_helper_addr, .Little); + mem.writeInt(u64, &buf, stub_helper_addr, .little); const off = laptr_header.offset + @sizeOf(u64) * index; try self.base.file.?.pwriteAll(&buf, off); } @@ -3773,7 +3773,7 @@ fn collectBindData(self: *MachO, bind: anytype, raw_bindings: anytype) !void { const base_offset = sym.n_value - segment.vmaddr; const rel_offset = @as(u32, @intCast(rel.r_address - ctx.base_offset)); const offset = @as(u64, @intCast(base_offset + rel_offset)); - const addend = mem.readInt(i64, code[rel_offset..][0..8], .Little); + const addend = mem.readInt(i64, code[rel_offset..][0..8], .little); const dylib_ordinal = @divTrunc(@as(i16, @bitCast(bind_sym.n_desc)), macho.N_SYMBOL_RESOLVER); log.debug(" | bind at {x}, import('{s}') in dylib({d})", .{ @@ -4502,7 +4502,7 @@ pub fn writeDysymtab(self: *MachO, ctx: SymtabCtx) !void { if (!self.stub_table.lookup.contains(entry)) continue; const target_sym = self.getSymbol(entry); assert(target_sym.undf()); - try writer.writeInt(u32, iundefsym + ctx.imports_table.get(entry).?, .Little); + try writer.writeInt(u32, iundefsym + ctx.imports_table.get(entry).?, .little); } } @@ -4513,9 +4513,9 @@ pub fn writeDysymtab(self: *MachO, ctx: SymtabCtx) !void { if (!self.got_table.lookup.contains(entry)) continue; const target_sym = self.getSymbol(entry); if (target_sym.undf()) { - try writer.writeInt(u32, iundefsym + ctx.imports_table.get(entry).?, .Little); + try writer.writeInt(u32, iundefsym + ctx.imports_table.get(entry).?, .little); } else { - try writer.writeInt(u32, macho.INDIRECT_SYMBOL_LOCAL, .Little); + try writer.writeInt(u32, macho.INDIRECT_SYMBOL_LOCAL, .little); } } } @@ -4527,7 +4527,7 @@ pub fn writeDysymtab(self: *MachO, ctx: SymtabCtx) !void { if (!self.stub_table.lookup.contains(entry)) continue; const target_sym = self.getSymbol(entry); assert(target_sym.undf()); - try writer.writeInt(u32, iundefsym + ctx.imports_table.get(entry).?, .Little); + try writer.writeInt(u32, iundefsym + ctx.imports_table.get(entry).?, .little); } } diff --git a/src/link/MachO/Archive.zig b/src/link/MachO/Archive.zig index fec7ce65ef..6bdc6d916d 100644 --- a/src/link/MachO/Archive.zig +++ b/src/link/MachO/Archive.zig @@ -123,7 +123,7 @@ fn parseName(allocator: Allocator, name_or_length: ar_hdr.NameOrLength, reader: } fn parseTableOfContents(self: *Archive, allocator: Allocator, reader: anytype) !void { - const symtab_size = try reader.readInt(u32, .Little); + const symtab_size = try reader.readInt(u32, .little); var symtab = try allocator.alloc(u8, symtab_size); defer allocator.free(symtab); @@ -132,7 +132,7 @@ fn parseTableOfContents(self: *Archive, allocator: Allocator, reader: anytype) ! return error.MalformedArchive; }; - const strtab_size = try reader.readInt(u32, .Little); + const strtab_size = try reader.readInt(u32, .little); var strtab = try allocator.alloc(u8, strtab_size); defer allocator.free(strtab); @@ -145,11 +145,11 @@ fn parseTableOfContents(self: *Archive, allocator: Allocator, reader: anytype) ! var symtab_reader = symtab_stream.reader(); while (true) { - const n_strx = symtab_reader.readInt(u32, .Little) catch |err| switch (err) { + const n_strx = symtab_reader.readInt(u32, .little) catch |err| switch (err) { error.EndOfStream => break, else => |e| return e, }; - const object_offset = try symtab_reader.readInt(u32, .Little); + const object_offset = try symtab_reader.readInt(u32, .little); const sym_name = mem.sliceTo(@as([*:0]const u8, @ptrCast(strtab.ptr + n_strx)), 0); const owned_name = try allocator.dupe(u8, sym_name); diff --git a/src/link/MachO/Atom.zig b/src/link/MachO/Atom.zig index 4c8fc03e3c..290c67c45e 100644 --- a/src/link/MachO/Atom.zig +++ b/src/link/MachO/Atom.zig @@ -443,9 +443,9 @@ pub fn parseRelocTarget(macho_file: *MachO, ctx: struct { const address_in_section = if (ctx.rel.r_pcrel == 0) blk: { break :blk if (ctx.rel.r_length == 3) - mem.readInt(u64, ctx.code[rel_offset..][0..8], .Little) + mem.readInt(u64, ctx.code[rel_offset..][0..8], .little) else - mem.readInt(u32, ctx.code[rel_offset..][0..4], .Little); + mem.readInt(u32, ctx.code[rel_offset..][0..4], .little); } else blk: { assert(macho_file.base.options.target.cpu.arch == .x86_64); const correction: u3 = switch (@as(macho.reloc_type_x86_64, @enumFromInt(ctx.rel.r_type))) { @@ -455,7 +455,7 @@ pub fn parseRelocTarget(macho_file: *MachO, ctx: struct { .X86_64_RELOC_SIGNED_4 => 4, else => unreachable, }; - const addend = mem.readInt(i32, ctx.code[rel_offset..][0..4], .Little); + const addend = mem.readInt(i32, ctx.code[rel_offset..][0..4], .little); const target_address = @as(i64, @intCast(ctx.base_addr)) + ctx.rel.r_address + 4 + correction + addend; break :blk @as(u64, @intCast(target_address)); }; @@ -781,7 +781,7 @@ fn resolveRelocsArm64( ), code), }; inst.unconditional_branch_immediate.imm26 = @as(u26, @truncate(@as(u28, @bitCast(displacement >> 2)))); - mem.writeInt(u32, code, inst.toU32(), .Little); + mem.writeInt(u32, code, inst.toU32(), .little); }, .ARM64_RELOC_PAGE21, @@ -802,7 +802,7 @@ fn resolveRelocsArm64( }; inst.pc_relative_address.immhi = @as(u19, @truncate(pages >> 2)); inst.pc_relative_address.immlo = @as(u2, @truncate(pages)); - mem.writeInt(u32, code, inst.toU32(), .Little); + mem.writeInt(u32, code, inst.toU32(), .little); addend = null; }, @@ -821,7 +821,7 @@ fn resolveRelocsArm64( ), code), }; inst.add_subtract_immediate.imm12 = off; - mem.writeInt(u32, code, inst.toU32(), .Little); + mem.writeInt(u32, code, inst.toU32(), .little); } else { var inst = aarch64.Instruction{ .load_store_register = mem.bytesToValue(meta.TagPayload( @@ -839,7 +839,7 @@ fn resolveRelocsArm64( 3 => .load_store_64, }); inst.load_store_register.offset = off; - mem.writeInt(u32, code, inst.toU32(), .Little); + mem.writeInt(u32, code, inst.toU32(), .little); } addend = null; }, @@ -858,7 +858,7 @@ fn resolveRelocsArm64( ), code), }; inst.load_store_register.offset = off; - mem.writeInt(u32, code, inst.toU32(), .Little); + mem.writeInt(u32, code, inst.toU32(), .little); addend = null; }, @@ -918,7 +918,7 @@ fn resolveRelocsArm64( .sf = @as(u1, @truncate(reg_info.size)), }, }; - mem.writeInt(u32, code, inst.toU32(), .Little); + mem.writeInt(u32, code, inst.toU32(), .little); addend = null; }, @@ -926,14 +926,14 @@ fn resolveRelocsArm64( relocs_log.debug(" | target_addr = 0x{x}", .{target_addr}); const result = math.cast(i32, @as(i64, @intCast(target_addr)) - @as(i64, @intCast(source_addr))) orelse return error.Overflow; - mem.writeInt(u32, atom_code[rel_offset..][0..4], @as(u32, @bitCast(result)), .Little); + mem.writeInt(u32, atom_code[rel_offset..][0..4], @as(u32, @bitCast(result)), .little); }, .ARM64_RELOC_UNSIGNED => { var ptr_addend = if (rel.r_length == 3) - mem.readInt(i64, atom_code[rel_offset..][0..8], .Little) + mem.readInt(i64, atom_code[rel_offset..][0..8], .little) else - mem.readInt(i32, atom_code[rel_offset..][0..4], .Little); + mem.readInt(i32, atom_code[rel_offset..][0..4], .little); if (rel.r_extern == 0) { const base_addr = if (target.sym_index >= object.source_address_lookup.len) @@ -954,9 +954,9 @@ fn resolveRelocsArm64( relocs_log.debug(" | target_addr = 0x{x}", .{result}); if (rel.r_length == 3) { - mem.writeInt(u64, atom_code[rel_offset..][0..8], @as(u64, @bitCast(result)), .Little); + mem.writeInt(u64, atom_code[rel_offset..][0..8], @as(u64, @bitCast(result)), .little); } else { - mem.writeInt(u32, atom_code[rel_offset..][0..4], @as(u32, @truncate(@as(u64, @bitCast(result)))), .Little); + mem.writeInt(u32, atom_code[rel_offset..][0..4], @as(u32, @truncate(@as(u64, @bitCast(result)))), .little); } subtractor = null; @@ -1045,25 +1045,25 @@ fn resolveRelocsX86( switch (rel_type) { .X86_64_RELOC_BRANCH => { - const addend = mem.readInt(i32, atom_code[rel_offset..][0..4], .Little); + const addend = mem.readInt(i32, atom_code[rel_offset..][0..4], .little); const adjusted_target_addr = @as(u64, @intCast(@as(i64, @intCast(target_addr)) + addend)); relocs_log.debug(" | target_addr = 0x{x}", .{adjusted_target_addr}); const disp = try Relocation.calcPcRelativeDisplacementX86(source_addr, adjusted_target_addr, 0); - mem.writeInt(i32, atom_code[rel_offset..][0..4], disp, .Little); + mem.writeInt(i32, atom_code[rel_offset..][0..4], disp, .little); }, .X86_64_RELOC_GOT, .X86_64_RELOC_GOT_LOAD, => { - const addend = mem.readInt(i32, atom_code[rel_offset..][0..4], .Little); + const addend = mem.readInt(i32, atom_code[rel_offset..][0..4], .little); const adjusted_target_addr = @as(u64, @intCast(@as(i64, @intCast(target_addr)) + addend)); relocs_log.debug(" | target_addr = 0x{x}", .{adjusted_target_addr}); const disp = try Relocation.calcPcRelativeDisplacementX86(source_addr, adjusted_target_addr, 0); - mem.writeInt(i32, atom_code[rel_offset..][0..4], disp, .Little); + mem.writeInt(i32, atom_code[rel_offset..][0..4], disp, .little); }, .X86_64_RELOC_TLV => { - const addend = mem.readInt(i32, atom_code[rel_offset..][0..4], .Little); + const addend = mem.readInt(i32, atom_code[rel_offset..][0..4], .little); const adjusted_target_addr = @as(u64, @intCast(@as(i64, @intCast(target_addr)) + addend)); relocs_log.debug(" | target_addr = 0x{x}", .{adjusted_target_addr}); const disp = try Relocation.calcPcRelativeDisplacementX86(source_addr, adjusted_target_addr, 0); @@ -1073,7 +1073,7 @@ fn resolveRelocsX86( atom_code[rel_offset - 2] = 0x8d; } - mem.writeInt(i32, atom_code[rel_offset..][0..4], disp, .Little); + mem.writeInt(i32, atom_code[rel_offset..][0..4], disp, .little); }, .X86_64_RELOC_SIGNED, @@ -1088,7 +1088,7 @@ fn resolveRelocsX86( .X86_64_RELOC_SIGNED_4 => 4, else => unreachable, }; - var addend = mem.readInt(i32, atom_code[rel_offset..][0..4], .Little) + correction; + var addend = mem.readInt(i32, atom_code[rel_offset..][0..4], .little) + correction; if (rel.r_extern == 0) { const base_addr = if (target.sym_index >= object.source_address_lookup.len) @@ -1104,14 +1104,14 @@ fn resolveRelocsX86( relocs_log.debug(" | target_addr = 0x{x}", .{adjusted_target_addr}); const disp = try Relocation.calcPcRelativeDisplacementX86(source_addr, adjusted_target_addr, correction); - mem.writeInt(i32, atom_code[rel_offset..][0..4], disp, .Little); + mem.writeInt(i32, atom_code[rel_offset..][0..4], disp, .little); }, .X86_64_RELOC_UNSIGNED => { var addend = if (rel.r_length == 3) - mem.readInt(i64, atom_code[rel_offset..][0..8], .Little) + mem.readInt(i64, atom_code[rel_offset..][0..8], .little) else - mem.readInt(i32, atom_code[rel_offset..][0..4], .Little); + mem.readInt(i32, atom_code[rel_offset..][0..4], .little); if (rel.r_extern == 0) { const base_addr = if (target.sym_index >= object.source_address_lookup.len) @@ -1132,9 +1132,9 @@ fn resolveRelocsX86( relocs_log.debug(" | target_addr = 0x{x}", .{result}); if (rel.r_length == 3) { - mem.writeInt(u64, atom_code[rel_offset..][0..8], @as(u64, @bitCast(result)), .Little); + mem.writeInt(u64, atom_code[rel_offset..][0..8], @as(u64, @bitCast(result)), .little); } else { - mem.writeInt(u32, atom_code[rel_offset..][0..4], @as(u32, @truncate(@as(u64, @bitCast(result)))), .Little); + mem.writeInt(u32, atom_code[rel_offset..][0..4], @as(u32, @truncate(@as(u64, @bitCast(result)))), .little); } subtractor = null; diff --git a/src/link/MachO/CodeSignature.zig b/src/link/MachO/CodeSignature.zig index 35538b4e97..0f49ee6a64 100644 --- a/src/link/MachO/CodeSignature.zig +++ b/src/link/MachO/CodeSignature.zig @@ -115,14 +115,14 @@ pub fn writeAdhocSignature( self.code_directory.inner.length = self.code_directory.size(); header.length += self.code_directory.size(); - try writer.writeInt(u32, header.magic, .Big); - try writer.writeInt(u32, header.length, .Big); - try writer.writeInt(u32, header.count, .Big); + try writer.writeInt(u32, header.magic, .big); + try writer.writeInt(u32, header.length, .big); + try writer.writeInt(u32, header.count, .big); var offset: u32 = @sizeOf(macho.SuperBlob) + @sizeOf(macho.BlobIndex) * @as(u32, @intCast(blobs.items.len)); for (blobs.items) |blob| { - try writer.writeInt(u32, blob.slotType(), .Big); - try writer.writeInt(u32, offset, .Big); + try writer.writeInt(u32, blob.slotType(), .big); + try writer.writeInt(u32, offset, .big); offset += blob.size(); } @@ -272,27 +272,27 @@ const CodeDirectory = struct { } fn write(self: CodeDirectory, writer: anytype) !void { - try writer.writeInt(u32, self.inner.magic, .Big); - try writer.writeInt(u32, self.inner.length, .Big); - try writer.writeInt(u32, self.inner.version, .Big); - try writer.writeInt(u32, self.inner.flags, .Big); - try writer.writeInt(u32, self.inner.hashOffset, .Big); - try writer.writeInt(u32, self.inner.identOffset, .Big); - try writer.writeInt(u32, self.inner.nSpecialSlots, .Big); - try writer.writeInt(u32, self.inner.nCodeSlots, .Big); - try writer.writeInt(u32, self.inner.codeLimit, .Big); + try writer.writeInt(u32, self.inner.magic, .big); + try writer.writeInt(u32, self.inner.length, .big); + try writer.writeInt(u32, self.inner.version, .big); + try writer.writeInt(u32, self.inner.flags, .big); + try writer.writeInt(u32, self.inner.hashOffset, .big); + try writer.writeInt(u32, self.inner.identOffset, .big); + try writer.writeInt(u32, self.inner.nSpecialSlots, .big); + try writer.writeInt(u32, self.inner.nCodeSlots, .big); + try writer.writeInt(u32, self.inner.codeLimit, .big); try writer.writeByte(self.inner.hashSize); try writer.writeByte(self.inner.hashType); try writer.writeByte(self.inner.platform); try writer.writeByte(self.inner.pageSize); - try writer.writeInt(u32, self.inner.spare2, .Big); - try writer.writeInt(u32, self.inner.scatterOffset, .Big); - try writer.writeInt(u32, self.inner.teamOffset, .Big); - try writer.writeInt(u32, self.inner.spare3, .Big); - try writer.writeInt(u64, self.inner.codeLimit64, .Big); - try writer.writeInt(u64, self.inner.execSegBase, .Big); - try writer.writeInt(u64, self.inner.execSegLimit, .Big); - try writer.writeInt(u64, self.inner.execSegFlags, .Big); + try writer.writeInt(u32, self.inner.spare2, .big); + try writer.writeInt(u32, self.inner.scatterOffset, .big); + try writer.writeInt(u32, self.inner.teamOffset, .big); + try writer.writeInt(u32, self.inner.spare3, .big); + try writer.writeInt(u64, self.inner.codeLimit64, .big); + try writer.writeInt(u64, self.inner.execSegBase, .big); + try writer.writeInt(u64, self.inner.execSegLimit, .big); + try writer.writeInt(u64, self.inner.execSegFlags, .big); try writer.writeAll(self.ident); try writer.writeByte(0); @@ -325,9 +325,9 @@ const Requirements = struct { } fn write(self: Requirements, writer: anytype) !void { - try writer.writeInt(u32, macho.CSMAGIC_REQUIREMENTS, .Big); - try writer.writeInt(u32, self.size(), .Big); - try writer.writeInt(u32, 0, .Big); + try writer.writeInt(u32, macho.CSMAGIC_REQUIREMENTS, .big); + try writer.writeInt(u32, self.size(), .big); + try writer.writeInt(u32, 0, .big); } }; @@ -348,8 +348,8 @@ const Entitlements = struct { } fn write(self: Entitlements, writer: anytype) !void { - try writer.writeInt(u32, macho.CSMAGIC_EMBEDDED_ENTITLEMENTS, .Big); - try writer.writeInt(u32, self.size(), .Big); + try writer.writeInt(u32, macho.CSMAGIC_EMBEDDED_ENTITLEMENTS, .big); + try writer.writeInt(u32, self.size(), .big); try writer.writeAll(self.inner); } }; @@ -371,8 +371,8 @@ const Signature = struct { } fn write(self: Signature, writer: anytype) !void { - try writer.writeInt(u32, macho.CSMAGIC_BLOBWRAPPER, .Big); - try writer.writeInt(u32, self.size(), .Big); + try writer.writeInt(u32, macho.CSMAGIC_BLOBWRAPPER, .big); + try writer.writeInt(u32, self.size(), .big); } }; diff --git a/src/link/MachO/DwarfInfo.zig b/src/link/MachO/DwarfInfo.zig index 0db0238e54..a1e0ae458a 100644 --- a/src/link/MachO/DwarfInfo.zig +++ b/src/link/MachO/DwarfInfo.zig @@ -121,19 +121,19 @@ pub const CompileUnit = struct { address_size: u8, fn read(reader: anytype) !Header { - var length: u64 = try reader.readInt(u32, .Little); + var length: u64 = try reader.readInt(u32, .little); const is_64bit = length == 0xffffffff; if (is_64bit) { - length = try reader.readInt(u64, .Little); + length = try reader.readInt(u64, .little); } - const version = try reader.readInt(u16, .Little); + const version = try reader.readInt(u16, .little); const debug_abbrev_offset = if (is_64bit) - try reader.readInt(u64, .Little) + try reader.readInt(u64, .little) else - try reader.readInt(u32, .Little); - const address_size = try reader.readInt(u8, .Little); + try reader.readInt(u32, .little); + const address_size = try reader.readInt(u8, .little); return Header{ .is_64bit = is_64bit, @@ -251,9 +251,9 @@ pub const Attribute = struct { }, dwarf.FORM.strp => { const off = if (cuh.is_64bit) - mem.readInt(u64, debug_info[0..8], .Little) + mem.readInt(u64, debug_info[0..8], .little) else - mem.readInt(u32, debug_info[0..4], .Little); + mem.readInt(u32, debug_info[0..4], .little); return ctx.getString(off); }, else => return null, @@ -267,9 +267,9 @@ pub const Attribute = struct { return switch (self.form) { dwarf.FORM.data1 => debug_info[0], - dwarf.FORM.data2 => mem.readInt(u16, debug_info[0..2], .Little), - dwarf.FORM.data4 => mem.readInt(u32, debug_info[0..4], .Little), - dwarf.FORM.data8 => mem.readInt(u64, debug_info[0..8], .Little), + dwarf.FORM.data2 => mem.readInt(u16, debug_info[0..2], .little), + dwarf.FORM.data4 => mem.readInt(u32, debug_info[0..4], .little), + dwarf.FORM.data8 => mem.readInt(u64, debug_info[0..8], .little), dwarf.FORM.udata => try leb.readULEB128(u64, reader), dwarf.FORM.sdata => try leb.readILEB128(i64, reader), else => null, @@ -281,9 +281,9 @@ pub const Attribute = struct { const debug_info = self.getDebugInfo(ctx); return switch (cuh.address_size) { 1 => debug_info[0], - 2 => mem.readInt(u16, debug_info[0..2], .Little), - 4 => mem.readInt(u32, debug_info[0..4], .Little), - 8 => mem.readInt(u64, debug_info[0..8], .Little), + 2 => mem.readInt(u16, debug_info[0..2], .little), + 4 => mem.readInt(u32, debug_info[0..4], .little), + 8 => mem.readInt(u64, debug_info[0..8], .little), else => unreachable, }; } @@ -380,9 +380,9 @@ fn findFormSize(self: DwarfInfo, form: u64, di_off: usize, cuh: CompileUnit.Head dwarf.FORM.block, => { const len: u64 = switch (form) { - dwarf.FORM.block1 => try reader.readInt(u8, .Little), - dwarf.FORM.block2 => try reader.readInt(u16, .Little), - dwarf.FORM.block4 => try reader.readInt(u32, .Little), + dwarf.FORM.block1 => try reader.readInt(u8, .little), + dwarf.FORM.block2 => try reader.readInt(u16, .little), + dwarf.FORM.block4 => try reader.readInt(u32, .little), dwarf.FORM.block => try leb.readULEB128(u64, reader), else => unreachable, }; diff --git a/src/link/MachO/Relocation.zig b/src/link/MachO/Relocation.zig index 447e19be38..74be9eb0d5 100644 --- a/src/link/MachO/Relocation.zig +++ b/src/link/MachO/Relocation.zig @@ -128,7 +128,7 @@ fn resolveAarch64(self: Relocation, source_addr: u64, target_addr: i64, code: [] ), buffer[0..4]), }; inst.unconditional_branch_immediate.imm26 = @as(u26, @truncate(@as(u28, @bitCast(displacement >> 2)))); - mem.writeInt(u32, buffer[0..4], inst.toU32(), .Little); + mem.writeInt(u32, buffer[0..4], inst.toU32(), .little); }, .page, .got_page => { const source_page = @as(i32, @intCast(source_addr >> 12)); @@ -142,7 +142,7 @@ fn resolveAarch64(self: Relocation, source_addr: u64, target_addr: i64, code: [] }; inst.pc_relative_address.immhi = @as(u19, @truncate(pages >> 2)); inst.pc_relative_address.immlo = @as(u2, @truncate(pages)); - mem.writeInt(u32, buffer[0..4], inst.toU32(), .Little); + mem.writeInt(u32, buffer[0..4], inst.toU32(), .little); }, .pageoff, .got_pageoff => { const narrowed = @as(u12, @truncate(@as(u64, @intCast(target_addr)))); @@ -154,7 +154,7 @@ fn resolveAarch64(self: Relocation, source_addr: u64, target_addr: i64, code: [] ), buffer[0..4]), }; inst.add_subtract_immediate.imm12 = narrowed; - mem.writeInt(u32, buffer[0..4], inst.toU32(), .Little); + mem.writeInt(u32, buffer[0..4], inst.toU32(), .little); } else { var inst = aarch64.Instruction{ .load_store_register = mem.bytesToValue(meta.TagPayload( @@ -176,12 +176,12 @@ fn resolveAarch64(self: Relocation, source_addr: u64, target_addr: i64, code: [] } }; inst.load_store_register.offset = offset; - mem.writeInt(u32, buffer[0..4], inst.toU32(), .Little); + mem.writeInt(u32, buffer[0..4], inst.toU32(), .little); } }, .tlv_initializer, .unsigned => switch (self.length) { - 2 => mem.writeInt(u32, buffer[0..4], @as(u32, @truncate(@as(u64, @bitCast(target_addr)))), .Little), - 3 => mem.writeInt(u64, buffer[0..8], @as(u64, @bitCast(target_addr)), .Little), + 2 => mem.writeInt(u32, buffer[0..4], @as(u32, @truncate(@as(u64, @bitCast(target_addr)))), .little), + 3 => mem.writeInt(u64, buffer[0..8], @as(u64, @bitCast(target_addr)), .little), else => unreachable, }, .got, .signed, .tlv => unreachable, // Invalid target architecture. @@ -192,15 +192,15 @@ fn resolveX8664(self: Relocation, source_addr: u64, target_addr: i64, code: []u8 switch (self.type) { .branch, .got, .tlv, .signed => { const displacement = @as(i32, @intCast(@as(i64, @intCast(target_addr)) - @as(i64, @intCast(source_addr)) - 4)); - mem.writeInt(u32, code[self.offset..][0..4], @as(u32, @bitCast(displacement)), .Little); + mem.writeInt(u32, code[self.offset..][0..4], @as(u32, @bitCast(displacement)), .little); }, .tlv_initializer, .unsigned => { switch (self.length) { 2 => { - mem.writeInt(u32, code[self.offset..][0..4], @as(u32, @truncate(@as(u64, @bitCast(target_addr)))), .Little); + mem.writeInt(u32, code[self.offset..][0..4], @as(u32, @truncate(@as(u64, @bitCast(target_addr)))), .little); }, 3 => { - mem.writeInt(u64, code[self.offset..][0..8], @as(u64, @bitCast(target_addr)), .Little); + mem.writeInt(u64, code[self.offset..][0..8], @as(u64, @bitCast(target_addr)), .little); }, else => unreachable, } diff --git a/src/link/MachO/UnwindInfo.zig b/src/link/MachO/UnwindInfo.zig index e8c4a918ef..c588b65ea3 100644 --- a/src/link/MachO/UnwindInfo.zig +++ b/src/link/MachO/UnwindInfo.zig @@ -149,7 +149,7 @@ const Page = struct { for (page.page_encodings[0..page.page_encodings_count]) |record_id| { const enc = info.records.items[record_id].compactUnwindEncoding; - try writer.writeInt(u32, enc, .Little); + try writer.writeInt(u32, enc, .little); } assert(page.count > 0); diff --git a/src/link/MachO/eh_frame.zig b/src/link/MachO/eh_frame.zig index 12516db7a1..189d9b25cd 100644 --- a/src/link/MachO/eh_frame.zig +++ b/src/link/MachO/eh_frame.zig @@ -209,7 +209,7 @@ pub fn write(macho_file: *MachO, unwind_info: *UnwindInfo) !void { const writer = buffer.writer(); for (eh_records.values()) |record| { - try writer.writeInt(u32, record.size, .Little); + try writer.writeInt(u32, record.size, .little); try buffer.appendSlice(record.data); } @@ -259,7 +259,7 @@ pub fn EhFrameRecord(comptime is_mutable: bool) type { base_offset: u64, }) u64 { assert(rec.tag == .fde); - const addend = mem.readInt(i64, rec.data[4..][0..8], .Little); + const addend = mem.readInt(i64, rec.data[4..][0..8], .little); return @as(u64, @intCast(@as(i64, @intCast(ctx.base_addr + ctx.base_offset + 8)) + addend)); } @@ -269,7 +269,7 @@ pub fn EhFrameRecord(comptime is_mutable: bool) type { }) !void { assert(rec.tag == .fde); const addend = @as(i64, @intCast(value)) - @as(i64, @intCast(ctx.base_addr + ctx.base_offset + 8)); - mem.writeInt(i64, rec.data[4..][0..8], addend, .Little); + mem.writeInt(i64, rec.data[4..][0..8], addend, .little); } pub fn getPersonalityPointerReloc( @@ -343,13 +343,13 @@ pub fn EhFrameRecord(comptime is_mutable: bool) type { const target_addr = macho_file.getGotEntryAddress(target).?; const result = math.cast(i32, @as(i64, @intCast(target_addr)) - @as(i64, @intCast(source_addr))) orelse return error.Overflow; - mem.writeInt(i32, rec.data[rel_offset..][0..4], result, .Little); + mem.writeInt(i32, rec.data[rel_offset..][0..4], result, .little); }, .ARM64_RELOC_UNSIGNED => { assert(rel.r_extern == 1); const target_addr = Atom.getRelocTargetAddress(macho_file, target, false); const result = @as(i64, @intCast(target_addr)) - @as(i64, @intCast(source_addr)); - mem.writeInt(i64, rec.data[rel_offset..][0..8], @as(i64, @intCast(result)), .Little); + mem.writeInt(i64, rec.data[rel_offset..][0..8], @as(i64, @intCast(result)), .little); }, else => unreachable, } @@ -359,10 +359,10 @@ pub fn EhFrameRecord(comptime is_mutable: bool) type { switch (rel_type) { .X86_64_RELOC_GOT => { const target_addr = macho_file.getGotEntryAddress(target).?; - const addend = mem.readInt(i32, rec.data[rel_offset..][0..4], .Little); + const addend = mem.readInt(i32, rec.data[rel_offset..][0..4], .little); const adjusted_target_addr = @as(u64, @intCast(@as(i64, @intCast(target_addr)) + addend)); const disp = try Relocation.calcPcRelativeDisplacementX86(source_addr, adjusted_target_addr, 0); - mem.writeInt(i32, rec.data[rel_offset..][0..4], disp, .Little); + mem.writeInt(i32, rec.data[rel_offset..][0..4], disp, .little); }, else => unreachable, } @@ -375,7 +375,7 @@ pub fn EhFrameRecord(comptime is_mutable: bool) type { pub fn getCiePointerSource(rec: Record, object_id: u32, macho_file: *MachO, offset: u32) u32 { assert(rec.tag == .fde); const cpu_arch = macho_file.base.options.target.cpu.arch; - const addend = mem.readInt(u32, rec.data[0..4], .Little); + const addend = mem.readInt(u32, rec.data[0..4], .little); switch (cpu_arch) { .aarch64 => { const relocs = getRelocs(macho_file, object_id, offset); @@ -397,12 +397,12 @@ pub fn EhFrameRecord(comptime is_mutable: bool) type { pub fn getCiePointer(rec: Record) u32 { assert(rec.tag == .fde); - return mem.readInt(u32, rec.data[0..4], .Little); + return mem.readInt(u32, rec.data[0..4], .little); } pub fn setCiePointer(rec: *Record, ptr: u32) void { assert(rec.tag == .fde); - mem.writeInt(u32, rec.data[0..4], ptr, .Little); + mem.writeInt(u32, rec.data[0..4], ptr, .little); } pub fn getAugmentationString(rec: Record) []const u8 { @@ -509,14 +509,14 @@ pub fn EhFrameRecord(comptime is_mutable: bool) type { if (enc == EH_PE.omit) return null; var ptr: i64 = switch (enc & 0x0F) { - EH_PE.absptr => @as(i64, @bitCast(try reader.readInt(u64, .Little))), - EH_PE.udata2 => @as(i16, @bitCast(try reader.readInt(u16, .Little))), - EH_PE.udata4 => @as(i32, @bitCast(try reader.readInt(u32, .Little))), - EH_PE.udata8 => @as(i64, @bitCast(try reader.readInt(u64, .Little))), + EH_PE.absptr => @as(i64, @bitCast(try reader.readInt(u64, .little))), + EH_PE.udata2 => @as(i16, @bitCast(try reader.readInt(u16, .little))), + EH_PE.udata4 => @as(i32, @bitCast(try reader.readInt(u32, .little))), + EH_PE.udata8 => @as(i64, @bitCast(try reader.readInt(u64, .little))), EH_PE.uleb128 => @as(i64, @bitCast(try leb.readULEB128(u64, reader))), - EH_PE.sdata2 => try reader.readInt(i16, .Little), - EH_PE.sdata4 => try reader.readInt(i32, .Little), - EH_PE.sdata8 => try reader.readInt(i64, .Little), + EH_PE.sdata2 => try reader.readInt(i16, .little), + EH_PE.sdata4 => try reader.readInt(i32, .little), + EH_PE.sdata8 => try reader.readInt(i64, .little), EH_PE.sleb128 => try leb.readILEB128(i64, reader), else => return null, }; @@ -552,14 +552,14 @@ pub fn EhFrameRecord(comptime is_mutable: bool) type { } switch (enc & 0x0F) { - EH_PE.absptr => try writer.writeInt(u64, @as(u64, @bitCast(actual)), .Little), - EH_PE.udata2 => try writer.writeInt(u16, @as(u16, @bitCast(@as(i16, @intCast(actual)))), .Little), - EH_PE.udata4 => try writer.writeInt(u32, @as(u32, @bitCast(@as(i32, @intCast(actual)))), .Little), - EH_PE.udata8 => try writer.writeInt(u64, @as(u64, @bitCast(actual)), .Little), + EH_PE.absptr => try writer.writeInt(u64, @as(u64, @bitCast(actual)), .little), + EH_PE.udata2 => try writer.writeInt(u16, @as(u16, @bitCast(@as(i16, @intCast(actual)))), .little), + EH_PE.udata4 => try writer.writeInt(u32, @as(u32, @bitCast(@as(i32, @intCast(actual)))), .little), + EH_PE.udata8 => try writer.writeInt(u64, @as(u64, @bitCast(actual)), .little), EH_PE.uleb128 => try leb.writeULEB128(writer, @as(u64, @bitCast(actual))), - EH_PE.sdata2 => try writer.writeInt(i16, @as(i16, @intCast(actual)), .Little), - EH_PE.sdata4 => try writer.writeInt(i32, @as(i32, @intCast(actual)), .Little), - EH_PE.sdata8 => try writer.writeInt(i64, actual, .Little), + EH_PE.sdata2 => try writer.writeInt(i16, @as(i16, @intCast(actual)), .little), + EH_PE.sdata4 => try writer.writeInt(i32, @as(i32, @intCast(actual)), .little), + EH_PE.sdata8 => try writer.writeInt(i64, actual, .little), EH_PE.sleb128 => try leb.writeILEB128(writer, actual), else => unreachable, } @@ -586,13 +586,13 @@ pub const Iterator = struct { var stream = std.io.fixedBufferStream(it.data[it.pos..]); const reader = stream.reader(); - var size = try reader.readInt(u32, .Little); + var size = try reader.readInt(u32, .little); if (size == 0xFFFFFFFF) { log.debug("MachO doesn't support 64bit DWARF CFI __eh_frame records", .{}); return error.BadDwarfCfi; } - const id = try reader.readInt(u32, .Little); + const id = try reader.readInt(u32, .little); const tag: EhFrameRecordTag = if (id == 0) .cie else .fde; const offset: u32 = 4; const record = EhFrameRecord(false){ diff --git a/src/link/MachO/stubs.zig b/src/link/MachO/stubs.zig index 6d947983f6..925aeaa61f 100644 --- a/src/link/MachO/stubs.zig +++ b/src/link/MachO/stubs.zig @@ -53,7 +53,7 @@ pub fn writeStubHelperPreambleCode(args: struct { args.dyld_private_addr, 0, ); - try writer.writeInt(i32, disp, .Little); + try writer.writeInt(i32, disp, .little); } try writer.writeAll(&.{ 0x41, 0x53, 0xff, 0x25 }); { @@ -62,27 +62,27 @@ pub fn writeStubHelperPreambleCode(args: struct { args.dyld_stub_binder_got_addr, 0, ); - try writer.writeInt(i32, disp, .Little); + try writer.writeInt(i32, disp, .little); } }, .aarch64 => { { const pages = Relocation.calcNumberOfPages(args.source_addr, args.dyld_private_addr); - try writer.writeInt(u32, aarch64.Instruction.adrp(.x17, pages).toU32(), .Little); + try writer.writeInt(u32, aarch64.Instruction.adrp(.x17, pages).toU32(), .little); } { const off = try Relocation.calcPageOffset(args.dyld_private_addr, .arithmetic); - try writer.writeInt(u32, aarch64.Instruction.add(.x17, .x17, off, false).toU32(), .Little); + try writer.writeInt(u32, aarch64.Instruction.add(.x17, .x17, off, false).toU32(), .little); } try writer.writeInt(u32, aarch64.Instruction.stp( .x16, .x17, aarch64.Register.sp, aarch64.Instruction.LoadStorePairOffset.pre_index(-16), - ).toU32(), .Little); + ).toU32(), .little); { const pages = Relocation.calcNumberOfPages(args.source_addr + 12, args.dyld_stub_binder_got_addr); - try writer.writeInt(u32, aarch64.Instruction.adrp(.x16, pages).toU32(), .Little); + try writer.writeInt(u32, aarch64.Instruction.adrp(.x16, pages).toU32(), .little); } { const off = try Relocation.calcPageOffset(args.dyld_stub_binder_got_addr, .load_store_64); @@ -90,9 +90,9 @@ pub fn writeStubHelperPreambleCode(args: struct { .x16, .x16, aarch64.Instruction.LoadStoreOffset.imm(off), - ).toU32(), .Little); + ).toU32(), .little); } - try writer.writeInt(u32, aarch64.Instruction.br(.x16).toU32(), .Little); + try writer.writeInt(u32, aarch64.Instruction.br(.x16).toU32(), .little); }, else => unreachable, } @@ -108,7 +108,7 @@ pub fn writeStubHelperCode(args: struct { try writer.writeAll(&.{ 0x68, 0x0, 0x0, 0x0, 0x0, 0xe9 }); { const disp = try Relocation.calcPcRelativeDisplacementX86(args.source_addr + 6, args.target_addr, 0); - try writer.writeInt(i32, disp, .Little); + try writer.writeInt(i32, disp, .little); } }, .aarch64 => { @@ -120,10 +120,10 @@ pub fn writeStubHelperCode(args: struct { try writer.writeInt(u32, aarch64.Instruction.ldrLiteral( .w16, literal, - ).toU32(), .Little); + ).toU32(), .little); { const disp = try Relocation.calcPcRelativeDisplacementArm64(args.source_addr + 4, args.target_addr); - try writer.writeInt(u32, aarch64.Instruction.b(disp).toU32(), .Little); + try writer.writeInt(u32, aarch64.Instruction.b(disp).toU32(), .little); } try writer.writeAll(&.{ 0x0, 0x0, 0x0, 0x0 }); }, @@ -141,13 +141,13 @@ pub fn writeStubCode(args: struct { try writer.writeAll(&.{ 0xff, 0x25 }); { const disp = try Relocation.calcPcRelativeDisplacementX86(args.source_addr + 2, args.target_addr, 0); - try writer.writeInt(i32, disp, .Little); + try writer.writeInt(i32, disp, .little); } }, .aarch64 => { { const pages = Relocation.calcNumberOfPages(args.source_addr, args.target_addr); - try writer.writeInt(u32, aarch64.Instruction.adrp(.x16, pages).toU32(), .Little); + try writer.writeInt(u32, aarch64.Instruction.adrp(.x16, pages).toU32(), .little); } { const off = try Relocation.calcPageOffset(args.target_addr, .load_store_64); @@ -155,9 +155,9 @@ pub fn writeStubCode(args: struct { .x16, .x16, aarch64.Instruction.LoadStoreOffset.imm(off), - ).toU32(), .Little); + ).toU32(), .little); } - try writer.writeInt(u32, aarch64.Instruction.br(.x16).toU32(), .Little); + try writer.writeInt(u32, aarch64.Instruction.br(.x16).toU32(), .little); }, else => unreachable, } diff --git a/src/link/MachO/thunks.zig b/src/link/MachO/thunks.zig index 21f5d2f410..774a8f7344 100644 --- a/src/link/MachO/thunks.zig +++ b/src/link/MachO/thunks.zig @@ -349,10 +349,10 @@ pub fn writeThunkCode(macho_file: *MachO, thunk: *const Thunk, writer: anytype) .atom => macho_file.getSymbol(target).n_value, }; const pages = Relocation.calcNumberOfPages(source_addr, target_addr); - try writer.writeInt(u32, aarch64.Instruction.adrp(.x16, pages).toU32(), .Little); + try writer.writeInt(u32, aarch64.Instruction.adrp(.x16, pages).toU32(), .little); const off = try Relocation.calcPageOffset(target_addr, .arithmetic); - try writer.writeInt(u32, aarch64.Instruction.add(.x16, .x16, off, false).toU32(), .Little); - try writer.writeInt(u32, aarch64.Instruction.br(.x16).toU32(), .Little); + try writer.writeInt(u32, aarch64.Instruction.add(.x16, .x16, off, false).toU32(), .little); + try writer.writeInt(u32, aarch64.Instruction.br(.x16).toU32(), .little); } } diff --git a/src/link/MachO/zld.zig b/src/link/MachO/zld.zig index ed1d3f0258..b94da1d284 100644 --- a/src/link/MachO/zld.zig +++ b/src/link/MachO/zld.zig @@ -796,7 +796,7 @@ fn writePointerEntries(macho_file: *MachO, sect_id: u8, table: anytype) !void { defer buffer.deinit(); for (table.entries.items) |entry| { const sym = macho_file.getSymbol(entry); - buffer.writer().writeInt(u64, sym.n_value, .Little) catch unreachable; + buffer.writer().writeInt(u64, sym.n_value, .little) catch unreachable; } log.debug("writing __DATA_CONST,__got contents at file offset 0x{x}", .{header.offset}); try macho_file.base.file.?.pwriteAll(buffer.items, header.offset); @@ -880,7 +880,7 @@ fn writeLaSymbolPtrs(macho_file: *MachO) !void { for (0..macho_file.stub_table.count()) |index| { const target_addr = stub_helper_header.addr + stubs.stubHelperPreambleSize(cpu_arch) + stubs.stubHelperSize(cpu_arch) * index; - buffer.writer().writeInt(u64, target_addr, .Little) catch unreachable; + buffer.writer().writeInt(u64, target_addr, .little) catch unreachable; } log.debug("writing __DATA,__la_symbol_ptr contents at file offset 0x{x}", .{ diff --git a/src/link/Plan9.zig b/src/link/Plan9.zig index 04c8c9abe7..d8b6f39f76 100644 --- a/src/link/Plan9.zig +++ b/src/link/Plan9.zig @@ -348,7 +348,7 @@ fn putFn(self: *Plan9, decl_index: Module.Decl.Index, out: FnDeclOutput) !void { // every 'z' starts with 0 try a.append(0); // path component value of '/' - try a.writer().writeInt(u16, 1, .Big); + try a.writer().writeInt(u16, 1, .big); // getting the full file path var buf: [std.fs.MAX_PATH_BYTES]u8 = undefined; @@ -381,11 +381,11 @@ fn addPathComponents(self: *Plan9, path: []const u8, a: *std.ArrayList(u8)) !voi var it = std.mem.tokenizeScalar(u8, path, sep); while (it.next()) |component| { if (self.file_segments.get(component)) |num| { - try a.writer().writeInt(u16, num, .Big); + try a.writer().writeInt(u16, num, .big); } else { self.file_segments_i += 1; try self.file_segments.put(self.base.allocator, component, self.file_segments_i); - try a.writer().writeInt(u16, self.file_segments_i, .Big); + try a.writer().writeInt(u16, self.file_segments_i, .big); } } } @@ -607,7 +607,7 @@ pub fn changeLine(l: *std.ArrayList(u8), delta_line: i32) !void { try l.append(toadd); } else if (delta_line != 0) { try l.append(0); - try l.writer().writeInt(i32, delta_line, .Big); + try l.writer().writeInt(i32, delta_line, .big); } } @@ -922,7 +922,7 @@ pub fn flushModule(self: *Plan9, comp: *Compilation, prog_node: *std.Progress.No @memcpy(hdr_slice, self.hdr.toU8s()[0..hdr_size]); // write the fat header for 64 bit entry points if (self.sixtyfour_bit) { - mem.writeInt(u64, hdr_buf[32..40], self.entry_val.?, .Big); + mem.writeInt(u64, hdr_buf[32..40], self.entry_val.?, .big); } // perform the relocs { @@ -1311,9 +1311,9 @@ pub fn writeSym(self: *Plan9, w: anytype, sym: aout.Sym) !void { // log.debug("write sym{{name: {s}, value: {x}}}", .{ sym.name, sym.value }); if (sym.type == .bad) return; // we don't want to write free'd symbols if (!self.sixtyfour_bit) { - try w.writeInt(u32, @as(u32, @intCast(sym.value)), .Big); + try w.writeInt(u32, @as(u32, @intCast(sym.value)), .big); } else { - try w.writeInt(u64, sym.value, .Big); + try w.writeInt(u64, sym.value, .big); } try w.writeByte(@intFromEnum(sym.type)); try w.writeAll(sym.name); diff --git a/src/link/Plan9/aout.zig b/src/link/Plan9/aout.zig index 8879a4832f..12dfc45873 100644 --- a/src/link/Plan9/aout.zig +++ b/src/link/Plan9/aout.zig @@ -21,7 +21,7 @@ pub const ExecHdr = extern struct { var buf: [40]u8 = undefined; var i: u8 = 0; inline for (std.meta.fields(@This())) |f| { - std.mem.writeInt(u32, buf[i..][0..4], @field(self, f.name), .Big); + std.mem.writeInt(u32, buf[i..][0..4], @field(self, f.name), .big); i += 4; } return buf; diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig index 2be90fa15b..fdac89f837 100644 --- a/src/link/Wasm.zig +++ b/src/link/Wasm.zig @@ -2380,7 +2380,7 @@ fn setupErrorsLen(wasm: *Wasm) !void { atom.* = Atom.empty; atom.sym_index = loc.index; atom.size = 2; - try atom.code.writer(wasm.base.allocator).writeInt(u16, @intCast(errors_len), .Little); + try atom.code.writer(wasm.base.allocator).writeInt(u16, @intCast(errors_len), .little); try wasm.parseAtom(atom_index, .{ .data = .read_only }); } @@ -3151,7 +3151,7 @@ fn populateErrorNameTable(wasm: *Wasm) !void { const offset = @as(u32, @intCast(atom.code.items.len)); // first we create the data for the slice of the name try atom.code.appendNTimes(wasm.base.allocator, 0, 4); // ptr to name, will be relocated - try atom.code.writer(wasm.base.allocator).writeInt(u32, len - 1, .Little); + try atom.code.writer(wasm.base.allocator).writeInt(u32, len - 1, .little); // create relocation to the error name try atom.relocs.append(wasm.base.allocator, .{ .index = names_atom.sym_index, @@ -4286,11 +4286,11 @@ fn emitInit(writer: anytype, init_expr: std.wasm.InitExpression) !void { }, .f32_const => |val| { try writer.writeByte(std.wasm.opcode(.f32_const)); - try writer.writeInt(u32, @bitCast(val), .Little); + try writer.writeInt(u32, @bitCast(val), .little); }, .f64_const => |val| { try writer.writeByte(std.wasm.opcode(.f64_const)); - try writer.writeInt(u64, @bitCast(val), .Little); + try writer.writeInt(u64, @bitCast(val), .little); }, .global_get => |val| { try writer.writeByte(std.wasm.opcode(.global_get)); diff --git a/src/link/Wasm/Archive.zig b/src/link/Wasm/Archive.zig index 91e92ae36d..a618aaebbf 100644 --- a/src/link/Wasm/Archive.zig +++ b/src/link/Wasm/Archive.zig @@ -141,11 +141,11 @@ fn parseTableOfContents(archive: *Archive, allocator: Allocator, reader: anytype const size_trimmed = mem.trim(u8, &archive.header.ar_size, " "); const sym_tab_size = try std.fmt.parseInt(u32, size_trimmed, 10); - const num_symbols = try reader.readInt(u32, .Big); + const num_symbols = try reader.readInt(u32, .big); const symbol_positions = try allocator.alloc(u32, num_symbols); defer allocator.free(symbol_positions); for (symbol_positions) |*index| { - index.* = try reader.readInt(u32, .Big); + index.* = try reader.readInt(u32, .big); } const sym_tab = try allocator.alloc(u8, sym_tab_size - 4 - (4 * num_symbols)); diff --git a/src/link/Wasm/Atom.zig b/src/link/Wasm/Atom.zig index 65e92ed140..60727b6af1 100644 --- a/src/link/Wasm/Atom.zig +++ b/src/link/Wasm/Atom.zig @@ -114,10 +114,10 @@ pub fn resolveRelocs(atom: *Atom, wasm_bin: *const Wasm) void { .R_WASM_GLOBAL_INDEX_I32, .R_WASM_MEMORY_ADDR_I32, .R_WASM_SECTION_OFFSET_I32, - => std.mem.writeInt(u32, atom.code.items[reloc.offset..][0..4], @as(u32, @intCast(value)), .Little), + => std.mem.writeInt(u32, atom.code.items[reloc.offset..][0..4], @as(u32, @intCast(value)), .little), .R_WASM_TABLE_INDEX_I64, .R_WASM_MEMORY_ADDR_I64, - => std.mem.writeInt(u64, atom.code.items[reloc.offset..][0..8], value, .Little), + => std.mem.writeInt(u64, atom.code.items[reloc.offset..][0..8], value, .little), .R_WASM_GLOBAL_INDEX_LEB, .R_WASM_EVENT_INDEX_LEB, .R_WASM_FUNCTION_INDEX_LEB, diff --git a/src/link/Wasm/Object.zig b/src/link/Wasm/Object.zig index 6517d7ec20..359ff20d94 100644 --- a/src/link/Wasm/Object.zig +++ b/src/link/Wasm/Object.zig @@ -344,7 +344,7 @@ fn Parser(comptime ReaderType: type) type { fn parseObject(parser: *ObjectParser, gpa: Allocator, is_object_file: *bool) Error!void { errdefer parser.object.deinit(gpa); try parser.verifyMagicBytes(); - const version = try parser.reader.reader().readInt(u32, .Little); + const version = try parser.reader.reader().readInt(u32, .little); parser.object.version = version; var relocatable_data = std.ArrayList(RelocatableData).init(gpa); diff --git a/src/resinator/ani.zig b/src/resinator/ani.zig index a4273e8488..770351351e 100644 --- a/src/resinator/ani.zig +++ b/src/resinator/ani.zig @@ -25,14 +25,14 @@ fn getAniheaderFlags(reader: anytype) !u32 { const riff_header = try reader.readBytesNoEof(4); if (!std.mem.eql(u8, &riff_header, "RIFF")) return error.InvalidFormat; - _ = try reader.readInt(u32, .Little); // size of RIFF chunk + _ = try reader.readInt(u32, .little); // size of RIFF chunk const form_type = try reader.readBytesNoEof(4); if (!std.mem.eql(u8, &form_type, "ACON")) return error.InvalidFormat; while (true) { const chunk_id = try reader.readBytesNoEof(4); - const chunk_len = try reader.readInt(u32, .Little); + const chunk_len = try reader.readInt(u32, .little); if (!std.mem.eql(u8, &chunk_id, "anih")) { // TODO: Move file cursor instead of skipBytes try reader.skipBytes(chunk_len, .{}); diff --git a/src/resinator/bmp.zig b/src/resinator/bmp.zig index fb20dacdad..1c7e0f6aad 100644 --- a/src/resinator/bmp.zig +++ b/src/resinator/bmp.zig @@ -94,16 +94,16 @@ pub fn read(reader: anytype, max_size: u64) ReadError!BitmapInfo { const id = std.mem.readInt(u16, file_header[0..2], native_endian); if (id != windows_format_id) return error.InvalidFileHeader; - bitmap_info.pixel_data_offset = std.mem.readInt(u32, file_header[10..14], .Little); + bitmap_info.pixel_data_offset = std.mem.readInt(u32, file_header[10..14], .little); if (bitmap_info.pixel_data_offset > max_size) return error.ImpossiblePixelDataOffset; - bitmap_info.dib_header_size = reader.readInt(u32, .Little) catch return error.UnexpectedEOF; + bitmap_info.dib_header_size = reader.readInt(u32, .little) catch return error.UnexpectedEOF; if (bitmap_info.pixel_data_offset < file_header_len + bitmap_info.dib_header_size) return error.ImpossiblePixelDataOffset; const dib_version = BitmapHeader.Version.get(bitmap_info.dib_header_size); switch (dib_version) { .@"nt3.1", .@"nt4.0", .@"nt5.0" => { var dib_header_buf: [@sizeOf(BITMAPINFOHEADER)]u8 align(@alignOf(BITMAPINFOHEADER)) = undefined; - std.mem.writeInt(u32, dib_header_buf[0..4], bitmap_info.dib_header_size, .Little); + std.mem.writeInt(u32, dib_header_buf[0..4], bitmap_info.dib_header_size, .little); reader.readNoEof(dib_header_buf[4..]) catch return error.UnexpectedEOF; var dib_header: *BITMAPINFOHEADER = @ptrCast(&dib_header_buf); structFieldsLittleToNative(BITMAPINFOHEADER, dib_header); @@ -118,7 +118,7 @@ pub fn read(reader: anytype, max_size: u64) ReadError!BitmapInfo { }, .@"win2.0" => { var dib_header_buf: [@sizeOf(BITMAPCOREHEADER)]u8 align(@alignOf(BITMAPCOREHEADER)) = undefined; - std.mem.writeInt(u32, dib_header_buf[0..4], bitmap_info.dib_header_size, .Little); + std.mem.writeInt(u32, dib_header_buf[0..4], bitmap_info.dib_header_size, .little); reader.readNoEof(dib_header_buf[4..]) catch return error.UnexpectedEOF; var dib_header: *BITMAPCOREHEADER = @ptrCast(&dib_header_buf); structFieldsLittleToNative(BITMAPCOREHEADER, dib_header); diff --git a/src/resinator/compile.zig b/src/resinator/compile.zig index 6f8878c411..ae0232a737 100644 --- a/src/resinator/compile.zig +++ b/src/resinator/compile.zig @@ -585,8 +585,8 @@ pub const Compiler = struct { // > resource if a RESDIR structure contains information about a cursor. // where LOCALHEADER is `struct { WORD xHotSpot; WORD yHotSpot; }` if (icon_dir.image_type == .cursor) { - try writer.writeInt(u16, entry.type_specific_data.cursor.hotspot_x, .Little); - try writer.writeInt(u16, entry.type_specific_data.cursor.hotspot_y, .Little); + try writer.writeInt(u16, entry.type_specific_data.cursor.hotspot_x, .little); + try writer.writeInt(u16, entry.type_specific_data.cursor.hotspot_y, .little); } try file.seekTo(entry.data_offset_from_start_of_file); @@ -667,7 +667,7 @@ pub const Compiler = struct { }, .dib => { var bitmap_header: *ico.BitmapHeader = @ptrCast(@alignCast(&header_bytes)); - if (native_endian == .Big) { + if (native_endian == .big) { std.mem.byteSwapAllFields(ico.BitmapHeader, bitmap_header); } const bitmap_version = ico.BitmapHeader.Version.get(bitmap_header.bcSize); @@ -985,8 +985,8 @@ pub const Compiler = struct { pub fn write(self: Data, writer: anytype) !void { switch (self) { .number => |number| switch (number.is_long) { - false => try writer.writeInt(WORD, number.asWord(), .Little), - true => try writer.writeInt(DWORD, number.value, .Little), + false => try writer.writeInt(WORD, number.asWord(), .little), + true => try writer.writeInt(DWORD, number.value, .little), }, .ascii_string => |ascii_string| { try writer.writeAll(ascii_string); @@ -1316,9 +1316,9 @@ pub const Compiler = struct { try data_writer.writeByte(modifiers.value); try data_writer.writeByte(0); // padding - try data_writer.writeInt(u16, key, .Little); - try data_writer.writeInt(u16, cmd_id.asWord(), .Little); - try data_writer.writeInt(u16, 0, .Little); // padding + try data_writer.writeInt(u16, key, .little); + try data_writer.writeInt(u16, cmd_id.asWord(), .little); + try data_writer.writeInt(u16, 0, .little); // padding } } @@ -1701,34 +1701,34 @@ pub const Compiler = struct { if (node.help_id == null) break :help_id 0; break :help_id evaluateNumberExpression(node.help_id.?, self.source, self.input_code_pages).value; }; - try data_writer.writeInt(u16, 1, .Little); // version number, always 1 - try data_writer.writeInt(u16, 0xFFFF, .Little); // signature, always 0xFFFF - try data_writer.writeInt(u32, help_id, .Little); - try data_writer.writeInt(u32, optional_statement_values.exstyle, .Little); - try data_writer.writeInt(u32, optional_statement_values.style, .Little); + try data_writer.writeInt(u16, 1, .little); // version number, always 1 + try data_writer.writeInt(u16, 0xFFFF, .little); // signature, always 0xFFFF + try data_writer.writeInt(u32, help_id, .little); + try data_writer.writeInt(u32, optional_statement_values.exstyle, .little); + try data_writer.writeInt(u32, optional_statement_values.style, .little); } else { - try data_writer.writeInt(u32, optional_statement_values.style, .Little); - try data_writer.writeInt(u32, optional_statement_values.exstyle, .Little); + try data_writer.writeInt(u32, optional_statement_values.style, .little); + try data_writer.writeInt(u32, optional_statement_values.exstyle, .little); } // This limit is enforced by the parser, so we know the number of controls // is within the range of a u16. - try data_writer.writeInt(u16, @as(u16, @intCast(node.controls.len)), .Little); - try data_writer.writeInt(u16, x.asWord(), .Little); - try data_writer.writeInt(u16, y.asWord(), .Little); - try data_writer.writeInt(u16, width.asWord(), .Little); - try data_writer.writeInt(u16, height.asWord(), .Little); + try data_writer.writeInt(u16, @as(u16, @intCast(node.controls.len)), .little); + try data_writer.writeInt(u16, x.asWord(), .little); + try data_writer.writeInt(u16, y.asWord(), .little); + try data_writer.writeInt(u16, width.asWord(), .little); + try data_writer.writeInt(u16, height.asWord(), .little); // Menu if (optional_statement_values.menu) |menu| { try menu.write(data_writer); } else { - try data_writer.writeInt(u16, 0, .Little); + try data_writer.writeInt(u16, 0, .little); } // Class if (optional_statement_values.class) |class| { try class.write(data_writer); } else { - try data_writer.writeInt(u16, 0, .Little); + try data_writer.writeInt(u16, 0, .little); } // Caption if (optional_statement_values.caption) |caption| { @@ -1736,7 +1736,7 @@ pub const Compiler = struct { defer self.allocator.free(parsed); try data_writer.writeAll(std.mem.sliceAsBytes(parsed[0 .. parsed.len + 1])); } else { - try data_writer.writeInt(u16, 0, .Little); + try data_writer.writeInt(u16, 0, .little); } // Font if (optional_statement_values.font) |font| { @@ -1787,18 +1787,18 @@ pub const Compiler = struct { switch (resource) { .dialog => { // Note: Reverse order from DIALOGEX - try data_writer.writeInt(u32, style, .Little); - try data_writer.writeInt(u32, exstyle, .Little); + try data_writer.writeInt(u32, style, .little); + try data_writer.writeInt(u32, exstyle, .little); }, .dialogex => { const help_id: u32 = if (control.help_id) |help_id_expression| evaluateNumberExpression(help_id_expression, self.source, self.input_code_pages).value else 0; - try data_writer.writeInt(u32, help_id, .Little); + try data_writer.writeInt(u32, help_id, .little); // Note: Reverse order from DIALOG - try data_writer.writeInt(u32, exstyle, .Little); - try data_writer.writeInt(u32, style, .Little); + try data_writer.writeInt(u32, exstyle, .little); + try data_writer.writeInt(u32, style, .little); }, else => unreachable, } @@ -1808,15 +1808,15 @@ pub const Compiler = struct { const control_width = evaluateNumberExpression(control.width, self.source, self.input_code_pages); const control_height = evaluateNumberExpression(control.height, self.source, self.input_code_pages); - try data_writer.writeInt(u16, control_x.asWord(), .Little); - try data_writer.writeInt(u16, control_y.asWord(), .Little); - try data_writer.writeInt(u16, control_width.asWord(), .Little); - try data_writer.writeInt(u16, control_height.asWord(), .Little); + try data_writer.writeInt(u16, control_x.asWord(), .little); + try data_writer.writeInt(u16, control_y.asWord(), .little); + try data_writer.writeInt(u16, control_width.asWord(), .little); + try data_writer.writeInt(u16, control_height.asWord(), .little); const control_id = evaluateNumberExpression(control.id, self.source, self.input_code_pages); switch (resource) { - .dialog => try data_writer.writeInt(u16, control_id.asWord(), .Little), - .dialogex => try data_writer.writeInt(u32, control_id.value, .Little), + .dialog => try data_writer.writeInt(u16, control_id.asWord(), .little), + .dialogex => try data_writer.writeInt(u32, control_id.value, .little), else => unreachable, } @@ -1949,7 +1949,7 @@ pub const Compiler = struct { } // We know the extra_data_buf size fits within a u16. const extra_data_size: u16 = @intCast(extra_data_buf.items.len); - try data_writer.writeInt(u16, extra_data_size, .Little); + try data_writer.writeInt(u16, extra_data_size, .little); try data_writer.writeAll(extra_data_buf.items); } @@ -1963,21 +1963,21 @@ pub const Compiler = struct { // I'm assuming this is some sort of version // TODO: Try to find something mentioning this - try data_writer.writeInt(u16, 1, .Little); - try data_writer.writeInt(u16, button_width.asWord(), .Little); - try data_writer.writeInt(u16, button_height.asWord(), .Little); - try data_writer.writeInt(u16, @as(u16, @intCast(node.buttons.len)), .Little); + try data_writer.writeInt(u16, 1, .little); + try data_writer.writeInt(u16, button_width.asWord(), .little); + try data_writer.writeInt(u16, button_height.asWord(), .little); + try data_writer.writeInt(u16, @as(u16, @intCast(node.buttons.len)), .little); for (node.buttons) |button_or_sep| { switch (button_or_sep.id) { .literal => { // This is always SEPARATOR std.debug.assert(button_or_sep.cast(.literal).?.token.id == .literal); - try data_writer.writeInt(u16, 0, .Little); + try data_writer.writeInt(u16, 0, .little); }, .simple_statement => { const value_node = button_or_sep.cast(.simple_statement).?.value; const value = evaluateNumberExpression(value_node, self.source, self.input_code_pages); - try data_writer.writeInt(u16, value.asWord(), .Little); + try data_writer.writeInt(u16, value.asWord(), .little); }, else => unreachable, // This is a bug in the parser } @@ -2008,21 +2008,21 @@ pub const Compiler = struct { pub fn writeDialogFont(self: *Compiler, resource: Resource, values: FontStatementValues, writer: anytype) !void { const node = values.node; const point_size = evaluateNumberExpression(node.point_size, self.source, self.input_code_pages); - try writer.writeInt(u16, point_size.asWord(), .Little); + try writer.writeInt(u16, point_size.asWord(), .little); if (resource == .dialogex) { - try writer.writeInt(u16, values.weight, .Little); + try writer.writeInt(u16, values.weight, .little); } if (resource == .dialogex) { - try writer.writeInt(u8, @intFromBool(values.italic), .Little); + try writer.writeInt(u8, @intFromBool(values.italic), .little); } if (node.char_set) |char_set| { const value = evaluateNumberExpression(char_set, self.source, self.input_code_pages); - try writer.writeInt(u8, @as(u8, @truncate(value.value)), .Little); + try writer.writeInt(u8, @as(u8, @truncate(value.value)), .little); } else if (resource == .dialogex) { - try writer.writeInt(u8, 1, .Little); // DEFAULT_CHARSET + try writer.writeInt(u8, 1, .little); // DEFAULT_CHARSET } const typeface = try self.parseQuotedStringAsWideString(node.typeface); @@ -2077,9 +2077,9 @@ pub const Compiler = struct { pub fn writeMenuData(self: *Compiler, node: *Node.Menu, data_writer: anytype, resource: Resource) !void { // menu header const version: u16 = if (resource == .menu) 0 else 1; - try data_writer.writeInt(u16, version, .Little); + try data_writer.writeInt(u16, version, .little); const header_size: u16 = if (resource == .menu) 0 else 4; - try data_writer.writeInt(u16, header_size, .Little); // cbHeaderSize + try data_writer.writeInt(u16, header_size, .little); // cbHeaderSize // Note: There can be extra bytes at the end of this header (`rgbExtra`), // but they are always zero-length for us, so we don't write anything // (the length of the rgbExtra field is inferred from the header_size). @@ -2089,9 +2089,9 @@ pub const Compiler = struct { if (resource == .menuex) { if (node.help_id) |help_id_node| { const help_id = evaluateNumberExpression(help_id_node, self.source, self.input_code_pages); - try data_writer.writeInt(u32, help_id.value, .Little); + try data_writer.writeInt(u32, help_id.value, .little); } else { - try data_writer.writeInt(u32, 0, .Little); + try data_writer.writeInt(u32, 0, .little); } } @@ -2111,9 +2111,9 @@ pub const Compiler = struct { // compiler still uses this alternate form, so that's what we use too. var flags = res.MenuItemFlags{}; if (is_last_of_parent) flags.markLast(); - try writer.writeInt(u16, flags.value, .Little); - try writer.writeInt(u16, 0, .Little); // id - try writer.writeInt(u16, 0, .Little); // null-terminated UTF-16 text + try writer.writeInt(u16, flags.value, .little); + try writer.writeInt(u16, 0, .little); // id + try writer.writeInt(u16, 0, .little); // null-terminated UTF-16 text }, .menu_item => { const menu_item = @fieldParentPtr(Node.MenuItem, "base", node); @@ -2124,10 +2124,10 @@ pub const Compiler = struct { flags.apply(option); } if (is_last_of_parent) flags.markLast(); - try writer.writeInt(u16, flags.value, .Little); + try writer.writeInt(u16, flags.value, .little); var result = evaluateNumberExpression(menu_item.result, self.source, self.input_code_pages); - try writer.writeInt(u16, result.asWord(), .Little); + try writer.writeInt(u16, result.asWord(), .little); var text = try self.parseQuotedStringAsWideString(menu_item.text); defer self.allocator.free(text); @@ -2142,7 +2142,7 @@ pub const Compiler = struct { flags.apply(option); } if (is_last_of_parent) flags.markLast(); - try writer.writeInt(u16, flags.value, .Little); + try writer.writeInt(u16, flags.value, .little); var text = try self.parseQuotedStringAsWideString(popup.text); defer self.allocator.free(text); @@ -2158,30 +2158,30 @@ pub const Compiler = struct { if (menu_item.type) |flags| { const value = evaluateNumberExpression(flags, self.source, self.input_code_pages); - try writer.writeInt(u32, value.value, .Little); + try writer.writeInt(u32, value.value, .little); } else { - try writer.writeInt(u32, 0, .Little); + try writer.writeInt(u32, 0, .little); } if (menu_item.state) |state| { const value = evaluateNumberExpression(state, self.source, self.input_code_pages); - try writer.writeInt(u32, value.value, .Little); + try writer.writeInt(u32, value.value, .little); } else { - try writer.writeInt(u32, 0, .Little); + try writer.writeInt(u32, 0, .little); } if (menu_item.id) |id| { const value = evaluateNumberExpression(id, self.source, self.input_code_pages); - try writer.writeInt(u32, value.value, .Little); + try writer.writeInt(u32, value.value, .little); } else { - try writer.writeInt(u32, 0, .Little); + try writer.writeInt(u32, 0, .little); } var flags: u16 = 0; if (is_last_of_parent) flags |= comptime @as(u16, @intCast(res.MF.END)); // This constant doesn't seem to have a named #define, it's different than MF_POPUP if (node_type == .popup_ex) flags |= 0x01; - try writer.writeInt(u16, flags, .Little); + try writer.writeInt(u16, flags, .little); var text = try self.parseQuotedStringAsWideString(menu_item.text); defer self.allocator.free(text); @@ -2196,9 +2196,9 @@ pub const Compiler = struct { if (node_type == .popup_ex) { if (menu_item.help_id) |help_id_node| { const help_id = evaluateNumberExpression(help_id_node, self.source, self.input_code_pages); - try writer.writeInt(u32, help_id.value, .Little); + try writer.writeInt(u32, help_id.value, .little); } else { - try writer.writeInt(u32, 0, .Little); + try writer.writeInt(u32, 0, .little); } for (menu_item.items, 0..) |item, i| { @@ -2219,15 +2219,15 @@ pub const Compiler = struct { var limited_writer = limitedWriter(data_buffer.writer(), std.math.maxInt(u16)); const data_writer = limited_writer.writer(); - try data_writer.writeInt(u16, 0, .Little); // placeholder size - try data_writer.writeInt(u16, res.FixedFileInfo.byte_len, .Little); - try data_writer.writeInt(u16, res.VersionNode.type_binary, .Little); + try data_writer.writeInt(u16, 0, .little); // placeholder size + try data_writer.writeInt(u16, res.FixedFileInfo.byte_len, .little); + try data_writer.writeInt(u16, res.VersionNode.type_binary, .little); const key_bytes = std.mem.sliceAsBytes(res.FixedFileInfo.key[0 .. res.FixedFileInfo.key.len + 1]); try data_writer.writeAll(key_bytes); // The number of bytes written up to this point is always the same, since the name // of the node is a constant (FixedFileInfo.key). The total number of bytes // written so far is 38, so we need 2 padding bytes to get back to DWORD alignment - try data_writer.writeInt(u16, 0, .Little); + try data_writer.writeInt(u16, 0, .little); var fixed_file_info = res.FixedFileInfo{}; for (node.fixed_info) |fixed_info| { @@ -2322,7 +2322,7 @@ pub const Compiler = struct { // limited the writer to maxInt(u16) const data_size: u16 = @intCast(data_buffer.items.len); // And now that we know the full size of this node (including its children), set its size - std.mem.writeInt(u16, data_buffer.items[0..2], data_size, .Little); + std.mem.writeInt(u16, data_buffer.items[0..2], data_size, .little); var header = try self.resourceHeader(node.id, node.versioninfo, .{ .data_size = data_size, @@ -2345,12 +2345,12 @@ pub const Compiler = struct { try writeDataPadding(writer, @as(u16, @intCast(buf.items.len))); const node_and_children_size_offset = buf.items.len; - try writer.writeInt(u16, 0, .Little); // placeholder for size + try writer.writeInt(u16, 0, .little); // placeholder for size const data_size_offset = buf.items.len; - try writer.writeInt(u16, 0, .Little); // placeholder for data size + try writer.writeInt(u16, 0, .little); // placeholder for data size const data_type_offset = buf.items.len; // Data type is string unless the node contains values that are numbers. - try writer.writeInt(u16, res.VersionNode.type_string, .Little); + try writer.writeInt(u16, res.VersionNode.type_string, .little); switch (node.id) { inline .block, .block_value => |node_type| { @@ -2412,17 +2412,17 @@ pub const Compiler = struct { const is_empty = parsed_to_first_null.len == 0; const is_only = block_or_value.values.len == 1; if ((!is_empty or !is_only) and (is_last or value_value_node.trailing_comma)) { - try writer.writeInt(u16, 0, .Little); + try writer.writeInt(u16, 0, .little); values_size += if (has_number_value) 2 else 1; } } } var data_size_slice = buf.items[data_size_offset..]; - std.mem.writeInt(u16, data_size_slice[0..@sizeOf(u16)], @as(u16, @intCast(values_size)), .Little); + std.mem.writeInt(u16, data_size_slice[0..@sizeOf(u16)], @as(u16, @intCast(values_size)), .little); if (has_number_value) { const data_type_slice = buf.items[data_type_offset..]; - std.mem.writeInt(u16, data_type_slice[0..@sizeOf(u16)], res.VersionNode.type_binary, .Little); + std.mem.writeInt(u16, data_type_slice[0..@sizeOf(u16)], res.VersionNode.type_binary, .little); } if (node_type == .block) { @@ -2437,7 +2437,7 @@ pub const Compiler = struct { const node_and_children_size = buf.items.len - node_and_children_size_offset; const node_and_children_size_slice = buf.items[node_and_children_size_offset..]; - std.mem.writeInt(u16, node_and_children_size_slice[0..@sizeOf(u16)], @as(u16, @intCast(node_and_children_size)), .Little); + std.mem.writeInt(u16, node_and_children_size_slice[0..@sizeOf(u16)], @as(u16, @intCast(node_and_children_size)), .little); } pub fn writeStringTable(self: *Compiler, node: *Node.StringTable) !void { @@ -2645,17 +2645,17 @@ pub const Compiler = struct { } fn writeSizeInfo(self: ResourceHeader, writer: anytype, size_info: SizeInfo) !void { - try writer.writeInt(DWORD, self.data_size, .Little); // DataSize - try writer.writeInt(DWORD, size_info.bytes, .Little); // HeaderSize + try writer.writeInt(DWORD, self.data_size, .little); // DataSize + try writer.writeInt(DWORD, size_info.bytes, .little); // HeaderSize try self.type_value.write(writer); // TYPE try self.name_value.write(writer); // NAME try writer.writeByteNTimes(0, size_info.padding_after_name); - try writer.writeInt(DWORD, self.data_version, .Little); // DataVersion - try writer.writeInt(WORD, self.memory_flags.value, .Little); // MemoryFlags - try writer.writeInt(WORD, self.language.asInt(), .Little); // LanguageId - try writer.writeInt(DWORD, self.version, .Little); // Version - try writer.writeInt(DWORD, self.characteristics, .Little); // Characteristics + try writer.writeInt(DWORD, self.data_version, .little); // DataVersion + try writer.writeInt(WORD, self.memory_flags.value, .little); // MemoryFlags + try writer.writeInt(WORD, self.language.asInt(), .little); // LanguageId + try writer.writeInt(DWORD, self.version, .little); // Version + try writer.writeInt(DWORD, self.characteristics, .little); // Characteristics } pub fn predefinedResourceType(self: ResourceHeader) ?res.RT { @@ -2998,7 +2998,7 @@ pub const FontDir = struct { defer header.deinit(compiler.allocator); try header.writeAssertNoOverflow(writer); - try writer.writeInt(u16, num_fonts, .Little); + try writer.writeInt(u16, num_fonts, .little); for (self.fonts.items) |font| { // The format of the FONTDIR is a strange beast. // Technically, each FONT is seemingly meant to be written as a @@ -3050,7 +3050,7 @@ pub const FontDir = struct { // device name/face name in the FONTDIR is reliable. // First, the ID is written, though - try writer.writeInt(u16, font.id, .Little); + try writer.writeInt(u16, font.id, .little); try writer.writeAll(&font.header_bytes); try writer.writeByteNTimes(0, 2); } @@ -3187,7 +3187,7 @@ pub const StringTable = struct { var string_i: u8 = 0; while (true) : (i += 1) { if (!self.set_indexes.isSet(i)) { - try data_writer.writeInt(u16, 0, .Little); + try data_writer.writeInt(u16, 0, .little); if (i == 15) break else continue; } @@ -3218,10 +3218,10 @@ pub const StringTable = struct { // If the option is set, then a NUL terminator is added unconditionally. // We already trimmed any trailing NULs, so we know it will be a new addition to the string. if (compiler.null_terminate_string_table_strings) string_len_in_utf16_code_units += 1; - try data_writer.writeInt(u16, string_len_in_utf16_code_units, .Little); + try data_writer.writeInt(u16, string_len_in_utf16_code_units, .little); try data_writer.writeAll(std.mem.sliceAsBytes(trimmed_string)); if (compiler.null_terminate_string_table_strings) { - try data_writer.writeInt(u16, 0, .Little); + try data_writer.writeInt(u16, 0, .little); } if (i == 15) break; diff --git a/src/resinator/ico.zig b/src/resinator/ico.zig index 9075de4ccc..310db6ece2 100644 --- a/src/resinator/ico.zig +++ b/src/resinator/ico.zig @@ -39,17 +39,17 @@ pub fn read(allocator: std.mem.Allocator, reader: anytype, max_size: u64) ReadEr // to do this. Maybe it makes more sense to handle the translation // at the call site instead of having a helper function here. pub fn readAnyError(allocator: std.mem.Allocator, reader: anytype, max_size: u64) !IconDir { - const reserved = try reader.readInt(u16, .Little); + const reserved = try reader.readInt(u16, .little); if (reserved != 0) { return error.InvalidHeader; } - const image_type = reader.readEnum(ImageType, .Little) catch |err| switch (err) { + const image_type = reader.readEnum(ImageType, .little) catch |err| switch (err) { error.InvalidValue => return error.InvalidImageType, else => |e| return e, }; - const num_images = try reader.readInt(u16, .Little); + const num_images = try reader.readInt(u16, .little); // To avoid over-allocation in the case of a file that says it has way more // entries than it actually does, we use an ArrayList with a conservatively @@ -68,19 +68,19 @@ pub fn readAnyError(allocator: std.mem.Allocator, reader: anytype, max_size: u64 switch (image_type) { .icon => { entry.type_specific_data = .{ .icon = .{ - .color_planes = try reader.readInt(u16, .Little), - .bits_per_pixel = try reader.readInt(u16, .Little), + .color_planes = try reader.readInt(u16, .little), + .bits_per_pixel = try reader.readInt(u16, .little), } }; }, .cursor => { entry.type_specific_data = .{ .cursor = .{ - .hotspot_x = try reader.readInt(u16, .Little), - .hotspot_y = try reader.readInt(u16, .Little), + .hotspot_x = try reader.readInt(u16, .little), + .hotspot_y = try reader.readInt(u16, .little), } }; }, } - entry.data_size_in_bytes = try reader.readInt(u32, .Little); - entry.data_offset_from_start_of_file = try reader.readInt(u32, .Little); + entry.data_size_in_bytes = try reader.readInt(u32, .little); + entry.data_offset_from_start_of_file = try reader.readInt(u32, .little); // Validate that the offset/data size is feasible if (@as(u64, entry.data_offset_from_start_of_file) + entry.data_size_in_bytes > max_size) { return error.ImpossibleDataSize; @@ -135,10 +135,10 @@ pub const IconDir = struct { } pub fn writeResData(self: IconDir, writer: anytype, first_image_id: u16) !void { - try writer.writeInt(u16, 0, .Little); - try writer.writeInt(u16, @intFromEnum(self.image_type), .Little); + try writer.writeInt(u16, 0, .little); + try writer.writeInt(u16, @intFromEnum(self.image_type), .little); // We know that entries.len must fit into a u16 - try writer.writeInt(u16, @as(u16, @intCast(self.entries.len)), .Little); + try writer.writeInt(u16, @as(u16, @intCast(self.entries.len)), .little); var image_id = first_image_id; for (self.entries) |entry| { @@ -175,23 +175,23 @@ pub const Entry = struct { pub fn writeResData(self: Entry, writer: anytype, id: u16) !void { switch (self.type_specific_data) { .icon => |icon_data| { - try writer.writeInt(u8, @as(u8, @truncate(self.width)), .Little); - try writer.writeInt(u8, @as(u8, @truncate(self.height)), .Little); - try writer.writeInt(u8, self.num_colors, .Little); - try writer.writeInt(u8, self.reserved, .Little); - try writer.writeInt(u16, icon_data.color_planes, .Little); - try writer.writeInt(u16, icon_data.bits_per_pixel, .Little); - try writer.writeInt(u32, self.data_size_in_bytes, .Little); + try writer.writeInt(u8, @as(u8, @truncate(self.width)), .little); + try writer.writeInt(u8, @as(u8, @truncate(self.height)), .little); + try writer.writeInt(u8, self.num_colors, .little); + try writer.writeInt(u8, self.reserved, .little); + try writer.writeInt(u16, icon_data.color_planes, .little); + try writer.writeInt(u16, icon_data.bits_per_pixel, .little); + try writer.writeInt(u32, self.data_size_in_bytes, .little); }, .cursor => |cursor_data| { - try writer.writeInt(u16, self.width, .Little); - try writer.writeInt(u16, self.height, .Little); - try writer.writeInt(u16, cursor_data.hotspot_x, .Little); - try writer.writeInt(u16, cursor_data.hotspot_y, .Little); - try writer.writeInt(u32, self.data_size_in_bytes + 4, .Little); + try writer.writeInt(u16, self.width, .little); + try writer.writeInt(u16, self.height, .little); + try writer.writeInt(u16, cursor_data.hotspot_x, .little); + try writer.writeInt(u16, cursor_data.hotspot_y, .little); + try writer.writeInt(u32, self.data_size_in_bytes + 4, .little); }, } - try writer.writeInt(u16, id, .Little); + try writer.writeInt(u16, id, .little); } }; diff --git a/src/resinator/res.zig b/src/resinator/res.zig index c21f877245..7db3f0d749 100644 --- a/src/resinator/res.zig +++ b/src/resinator/res.zig @@ -249,14 +249,14 @@ pub const NameOrOrdinal = union(enum) { try writer.writeAll(std.mem.sliceAsBytes(name[0 .. name.len + 1])); }, .ordinal => |ordinal| { - try writer.writeInt(u16, 0xffff, .Little); - try writer.writeInt(u16, ordinal, .Little); + try writer.writeInt(u16, 0xffff, .little); + try writer.writeInt(u16, ordinal, .little); }, } } pub fn writeEmpty(writer: anytype) !void { - try writer.writeInt(u16, 0, .Little); + try writer.writeInt(u16, 0, .little); } pub fn fromString(allocator: Allocator, bytes: SourceBytes) !NameOrOrdinal { @@ -963,19 +963,19 @@ pub const FixedFileInfo = struct { }; pub fn write(self: FixedFileInfo, writer: anytype) !void { - try writer.writeInt(u32, signature, .Little); - try writer.writeInt(u32, version, .Little); - try writer.writeInt(u32, self.file_version.mostSignificantCombinedParts(), .Little); - try writer.writeInt(u32, self.file_version.leastSignificantCombinedParts(), .Little); - try writer.writeInt(u32, self.product_version.mostSignificantCombinedParts(), .Little); - try writer.writeInt(u32, self.product_version.leastSignificantCombinedParts(), .Little); - try writer.writeInt(u32, self.file_flags_mask, .Little); - try writer.writeInt(u32, self.file_flags, .Little); - try writer.writeInt(u32, self.file_os, .Little); - try writer.writeInt(u32, self.file_type, .Little); - try writer.writeInt(u32, self.file_subtype, .Little); - try writer.writeInt(u32, self.file_date.mostSignificantCombinedParts(), .Little); - try writer.writeInt(u32, self.file_date.leastSignificantCombinedParts(), .Little); + try writer.writeInt(u32, signature, .little); + try writer.writeInt(u32, version, .little); + try writer.writeInt(u32, self.file_version.mostSignificantCombinedParts(), .little); + try writer.writeInt(u32, self.file_version.leastSignificantCombinedParts(), .little); + try writer.writeInt(u32, self.product_version.mostSignificantCombinedParts(), .little); + try writer.writeInt(u32, self.product_version.leastSignificantCombinedParts(), .little); + try writer.writeInt(u32, self.file_flags_mask, .little); + try writer.writeInt(u32, self.file_flags, .little); + try writer.writeInt(u32, self.file_os, .little); + try writer.writeInt(u32, self.file_type, .little); + try writer.writeInt(u32, self.file_subtype, .little); + try writer.writeInt(u32, self.file_date.mostSignificantCombinedParts(), .little); + try writer.writeInt(u32, self.file_date.leastSignificantCombinedParts(), .little); } }; diff --git a/src/value.zig b/src/value.zig index d9dfd3a257..6af43063d1 100644 --- a/src/value.zig +++ b/src/value.zig @@ -778,8 +778,8 @@ pub const Value = struct { .Void => {}, .Bool => { const byte_index = switch (endian) { - .Little => bit_offset / 8, - .Big => buffer.len - bit_offset / 8 - 1, + .little => bit_offset / 8, + .big => buffer.len - bit_offset / 8 - 1, }; if (val.toBool()) { buffer[byte_index] |= (@as(u8, 1) << @as(u3, @intCast(bit_offset % 8))); @@ -815,7 +815,7 @@ pub const Value = struct { var elem_i: usize = 0; while (elem_i < len) : (elem_i += 1) { // On big-endian systems, LLVM reverses the element order of vectors by default - const tgt_elem_i = if (endian == .Big) len - elem_i - 1 else elem_i; + const tgt_elem_i = if (endian == .big) len - elem_i - 1 else elem_i; const elem_val = try val.elemValue(mod, tgt_elem_i); try elem_val.writeToPackedMemory(elem_ty, mod, buffer, bit_offset + bits); bits += elem_bit_size; @@ -1064,8 +1064,8 @@ pub const Value = struct { .Void => return Value.void, .Bool => { const byte = switch (endian) { - .Big => buffer[buffer.len - bit_offset / 8 - 1], - .Little => buffer[bit_offset / 8], + .big => buffer[buffer.len - bit_offset / 8 - 1], + .little => buffer[bit_offset / 8], }; if (((byte >> @as(u3, @intCast(bit_offset % 8))) & 1) == 0) { return Value.false; @@ -1127,7 +1127,7 @@ pub const Value = struct { const elem_bit_size = @as(u16, @intCast(elem_ty.bitSize(mod))); for (elems, 0..) |_, i| { // On big-endian systems, LLVM reverses the element order of vectors by default - const tgt_elem_i = if (endian == .Big) elems.len - i - 1 else i; + const tgt_elem_i = if (endian == .big) elems.len - i - 1 else i; elems[tgt_elem_i] = try (try readFromPackedMemory(elem_ty, mod, buffer, bit_offset + bits, arena)).intern(elem_ty, mod); bits += elem_bit_size; } |