motiejus/zig
1
Fork 0
Code Releases Activity

mem: fix ub in writeInt

Browse Source 
Use inline to vastly simplify the exposed API.  This allows a
comptime-known endian parameter to be propogated, making extra functions
for a specific endianness completely unnecessary.
This commit is contained in:
Jacob Young
2023-10-31 04:26:57 -04:00
parent 50cdb65784
commit d890e81761
107 changed files with 1129 additions and 1337 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
lib/std/Build/Step/CheckObject.zig
View File

@@ -1624,8 +1624,8 @@ const WasmDumper = struct {
switch (opcode) {
.i32_const => try writer.print("i32.const {x}\n", .{try std.leb.readILEB128(i32, reader)}),
.i64_const => try writer.print("i64.const {x}\n", .{try std.leb.readILEB128(i64, reader)}),
.f32_const => try writer.print("f32.const {x}\n", .{@as(f32, @bitCast(try reader.readIntLittle(u32)))}),
.f64_const => try writer.print("f64.const {x}\n", .{@as(f64, @bitCast(try reader.readIntLittle(u64)))}),
.f32_const => try writer.print("f32.const {x}\n", .{@as(f32, @bitCast(try reader.readInt(u32, .Little)))}),
.f64_const => try writer.print("f64.const {x}\n", .{@as(f64, @bitCast(try reader.readInt(u64, .Little)))}),
.global_get => try writer.print("global.get {x}\n", .{try std.leb.readULEB128(u32, reader)}),
else => unreachable,
}

8
lib/std/base64.zig
View File

@@ -104,14 +104,14 @@ pub const Base64Encoder = struct {
var idx: usize = 0;
var out_idx: usize = 0;
while (idx + 15 < source.len) : (idx += 12) {
const bits = std.mem.readIntBig(u128, source[idx..][0..16]);
const bits = std.mem.readInt(u128, source[idx..][0..16], .Big);
inline for (0..16) |i| {
dest[out_idx + i] = encoder.alphabet_chars[@truncate((bits >> (122 - i * 6)) & 0x3f)];
}
out_idx += 16;
}
while (idx + 3 < source.len) : (idx += 3) {
const bits = std.mem.readIntBig(u32, source[idx..][0..4]);
const bits = std.mem.readInt(u32, source[idx..][0..4], .Big);
dest[out_idx] = encoder.alphabet_chars[(bits >> 26) & 0x3f];
dest[out_idx + 1] = encoder.alphabet_chars[(bits >> 20) & 0x3f];
dest[out_idx + 2] = encoder.alphabet_chars[(bits >> 14) & 0x3f];
@@ -226,7 +226,7 @@ pub const Base64Decoder = struct {
if ((new_bits & invalid_char_tst) != 0) return error.InvalidCharacter;
bits |= (new_bits << (24 * i));
}
std.mem.writeIntLittle(u128, dest[dest_idx..][0..16], bits);
std.mem.writeInt(u128, dest[dest_idx..][0..16], bits, .Little);
}
while (fast_src_idx + 4 < source.len and dest_idx + 3 < dest.len) : ({
fast_src_idx += 4;
@@ -237,7 +237,7 @@ pub const Base64Decoder = struct {
bits |= decoder.fast_char_to_index[2][source[fast_src_idx + 2]];
bits |= decoder.fast_char_to_index[3][source[fast_src_idx + 3]];
if ((bits & invalid_char_tst) != 0) return error.InvalidCharacter;
std.mem.writeIntLittle(u32, dest[dest_idx..][0..4], bits);
std.mem.writeInt(u32, dest[dest_idx..][0..4], bits, .Little);
}
var remaining = source[fast_src_idx..];
for (remaining, fast_src_idx..) |c, src_idx| {

4
lib/std/child_process.zig
View File

@@ -1376,7 +1376,7 @@ fn writeIntFd(fd: i32, value: ErrInt) !void {
.capable_io_mode = .blocking,
.intended_io_mode = .blocking,
};
file.writer().writeIntNative(u64, @as(u64, @intCast(value))) catch return error.SystemResources;
file.writer().writeInt(u64, @intCast(value), .Little) catch return error.SystemResources;
}
fn readIntFd(fd: i32) !ErrInt {
@@ -1385,7 +1385,7 @@ fn readIntFd(fd: i32) !ErrInt {
.capable_io_mode = .blocking,
.intended_io_mode = .blocking,
};
return @as(ErrInt, @intCast(file.reader().readIntNative(u64) catch return error.SystemResources));
return @as(ErrInt, @intCast(file.reader().readInt(u64, .Little) catch return error.SystemResources));
}
/// Caller must free result.

40
lib/std/coff.zig
View File

@@ -663,7 +663,7 @@ pub const Symbol = struct {
pub fn getNameOffset(self: Symbol) ?u32 {
if (!std.mem.eql(u8, self.name[0..4], "\x00\x00\x00\x00")) return null;
const offset = std.mem.readIntLittle(u32, self.name[4..8]);
const offset = std.mem.readInt(u32, self.name[4..8], .Little);
return offset;
}
};
@@ -1075,7 +1075,7 @@ pub const Coff = struct {
var stream = std.io.fixedBufferStream(data);
const reader = stream.reader();
try stream.seekTo(pe_pointer_offset);
var coff_header_offset = try reader.readIntLittle(u32);
var coff_header_offset = try reader.readInt(u32, .Little);
try stream.seekTo(coff_header_offset);
var buf: [4]u8 = undefined;
try reader.readNoEof(&buf);
@@ -1142,7 +1142,7 @@ pub const Coff = struct {
if (!mem.eql(u8, &cv_signature, "RSDS"))
return error.InvalidPEMagic;
try reader.readNoEof(self.guid[0..]);
self.age = try reader.readIntLittle(u32);
self.age = try reader.readInt(u32, .Little);
// Finally read the null-terminated string.
var byte = try reader.readByte();
@@ -1223,7 +1223,7 @@ pub const Coff = struct {
if (coff_header.pointer_to_symbol_table == 0) return null;
const offset = coff_header.pointer_to_symbol_table + Symbol.sizeOf() * coff_header.number_of_symbols;
const size = mem.readIntLittle(u32, self.data[offset..][0..4]);
const size = mem.readInt(u32, self.data[offset..][0..4], .Little);
if ((offset + size) > self.data.len) return error.InvalidStrtabSize;
return Strtab{ .buffer = self.data[offset..][0..size] };
@@ -1324,9 +1324,9 @@ pub const Symtab = struct {
fn asSymbol(raw: []const u8) Symbol {
return .{
.name = raw[0..8].*,
.value = mem.readIntLittle(u32, raw[8..12]),
.section_number = @as(SectionNumber, @enumFromInt(mem.readIntLittle(u16, raw[12..14]))),
.type = @as(SymType, @bitCast(mem.readIntLittle(u16, raw[14..16]))),
.value = mem.readInt(u32, raw[8..12], .Little),
.section_number = @as(SectionNumber, @enumFromInt(mem.readInt(u16, raw[12..14], .Little))),
.type = @as(SymType, @bitCast(mem.readInt(u16, raw[14..16], .Little))),
.storage_class = @as(StorageClass, @enumFromInt(raw[16])),
.number_of_aux_symbols = raw[17],
};
@@ -1335,27 +1335,27 @@ pub const Symtab = struct {
fn asDebugInfo(raw: []const u8) DebugInfoDefinition {
return .{
.unused_1 = raw[0..4].*,
.linenumber = mem.readIntLittle(u16, raw[4..6]),
.linenumber = mem.readInt(u16, raw[4..6], .Little),
.unused_2 = raw[6..12].*,
.pointer_to_next_function = mem.readIntLittle(u32, raw[12..16]),
.pointer_to_next_function = mem.readInt(u32, raw[12..16], .Little),
.unused_3 = raw[16..18].*,
};
}
fn asFuncDef(raw: []const u8) FunctionDefinition {
return .{
.tag_index = mem.readIntLittle(u32, raw[0..4]),
.total_size = mem.readIntLittle(u32, raw[4..8]),
.pointer_to_linenumber = mem.readIntLittle(u32, raw[8..12]),
.pointer_to_next_function = mem.readIntLittle(u32, raw[12..16]),
.tag_index = mem.readInt(u32, raw[0..4], .Little),
.total_size = mem.readInt(u32, raw[4..8], .Little),
.pointer_to_linenumber = mem.readInt(u32, raw[8..12], .Little),
.pointer_to_next_function = mem.readInt(u32, raw[12..16], .Little),
.unused = raw[16..18].*,
};
}
fn asWeakExtDef(raw: []const u8) WeakExternalDefinition {
return .{
.tag_index = mem.readIntLittle(u32, raw[0..4]),
.flag = @as(WeakExternalFlag, @enumFromInt(mem.readIntLittle(u32, raw[4..8]))),
.tag_index = mem.readInt(u32, raw[0..4], .Little),
.flag = @as(WeakExternalFlag, @enumFromInt(mem.readInt(u32, raw[4..8], .Little))),
.unused = raw[8..18].*,
};
}
@@ -1368,11 +1368,11 @@ pub const Symtab = struct {
fn asSectDef(raw: []const u8) SectionDefinition {
return .{
.length = mem.readIntLittle(u32, raw[0..4]),
.number_of_relocations = mem.readIntLittle(u16, raw[4..6]),
.number_of_linenumbers = mem.readIntLittle(u16, raw[6..8]),
.checksum = mem.readIntLittle(u32, raw[8..12]),
.number = mem.readIntLittle(u16, raw[12..14]),
.length = mem.readInt(u32, raw[0..4], .Little),
.number_of_relocations = mem.readInt(u16, raw[4..6], .Little),
.number_of_linenumbers = mem.readInt(u16, raw[6..8], .Little),
.checksum = mem.readInt(u32, raw[8..12], .Little),
.number = mem.readInt(u16, raw[12..14], .Little),
.selection = @as(ComdatSelection, @enumFromInt(raw[14])),
.unused = raw[15..18].*,
};

10
lib/std/compress/gzip.zig
View File

@@ -58,7 +58,7 @@ pub fn Decompress(comptime ReaderType: type) type {
const FLG = header[3];
// Modification time, as a Unix timestamp.
// If zero there's no timestamp available.
const MTIME = mem.readIntLittle(u32, header[4..8]);
const MTIME = mem.readInt(u32, header[4..8], .Little);
// Extra flags
const XFL = header[8];
// Operating system where the compression took place
@@ -66,7 +66,7 @@ pub fn Decompress(comptime ReaderType: type) type {
_ = XFL;
const extra = if (FLG & FEXTRA != 0) blk: {
const len = try hashed_reader.readIntLittle(u16);
const len = try hashed_reader.readInt(u16, .Little);
const tmp_buf = try allocator.alloc(u8, len);
errdefer allocator.free(tmp_buf);
@@ -88,7 +88,7 @@ pub fn Decompress(comptime ReaderType: type) type {
errdefer if (comment) |p| allocator.free(p);
if (FLG & FHCRC != 0) {
const hash = try source.readIntLittle(u16);
const hash = try source.readInt(u16, .Little);
if (hash != @as(u16, @truncate(hasher.hasher.final())))
return error.WrongChecksum;
}
@@ -133,12 +133,12 @@ pub fn Decompress(comptime ReaderType: type) type {
}
// We've reached the end of stream, check if the checksum matches
const hash = try self.in_reader.readIntLittle(u32);
const hash = try self.in_reader.readInt(u32, .Little);
if (hash != self.hasher.final())
return error.WrongChecksum;
// The ISIZE field is the size of the uncompressed input modulo 2^32
const input_size = try self.in_reader.readIntLittle(u32);
const input_size = try self.in_reader.readInt(u32, .Little);
if (self.read_amt & 0xffffffff != input_size)
return error.CorruptedData;

6
lib/std/compress/lzma/decode.zig
View File

@@ -58,12 +58,12 @@ pub const Params = struct {
props /= 5;
const pb = @as(u3, @intCast(props));
const dict_size_provided = try reader.readIntLittle(u32);
const dict_size_provided = try reader.readInt(u32, .Little);
const dict_size = @max(0x1000, dict_size_provided);
const unpacked_size = switch (options.unpacked_size) {
.read_from_header => blk: {
const unpacked_size_provided = try reader.readIntLittle(u64);
const unpacked_size_provided = try reader.readInt(u64, .Little);
const marker_mandatory = unpacked_size_provided == 0xFFFF_FFFF_FFFF_FFFF;
break :blk if (marker_mandatory)
null
@@ -71,7 +71,7 @@ pub const Params = struct {
unpacked_size_provided;
},
.read_header_but_use_provided => |x| blk: {
_ = try reader.readIntLittle(u64);
_ = try reader.readInt(u64, .Little);
break :blk x;
},
.use_provided => |x| x,

2
lib/std/compress/lzma/decode/rangecoder.zig
View File

@@ -12,7 +12,7 @@ pub const RangeDecoder = struct {
}
return RangeDecoder{
.range = 0xFFFF_FFFF,
.code = try reader.readIntBig(u32),
.code = try reader.readInt(u32, .Big),
};
}

6
lib/std/compress/lzma2/decode.zig
View File

@@ -97,12 +97,12 @@ pub const Decoder = struct {
const unpacked_size = blk: {
var tmp: u64 = status & 0x1F;
tmp <<= 16;
tmp |= try reader.readIntBig(u16);
tmp |= try reader.readInt(u16, .Big);
break :blk tmp + 1;
};
const packed_size = blk: {
const tmp: u17 = try reader.readIntBig(u16);
const tmp: u17 = try reader.readInt(u16, .Big);
break :blk tmp + 1;
};
@@ -155,7 +155,7 @@ pub const Decoder = struct {
accum: *LzAccumBuffer,
reset_dict: bool,
) !void {
const unpacked_size = @as(u17, try reader.readIntBig(u16)) + 1;
const unpacked_size = @as(u17, try reader.readInt(u16, .Big)) + 1;
if (reset_dict) {
try accum.reset(writer);

8
lib/std/compress/xz.zig
View File

@@ -52,7 +52,7 @@ pub fn Decompress(comptime ReaderType: type) type {
break :blk hasher.hasher.final();
};
const hash_b = try source.readIntLittle(u32);
const hash_b = try source.readInt(u32, .Little);
if (hash_a != hash_b)
return error.WrongChecksum;
@@ -105,20 +105,20 @@ pub fn Decompress(comptime ReaderType: type) type {
}
const hash_a = hasher.hasher.final();
const hash_b = try counting_reader.readIntLittle(u32);
const hash_b = try counting_reader.readInt(u32, .Little);
if (hash_a != hash_b)
return error.WrongChecksum;
break :blk counter.bytes_read;
};
const hash_a = try self.in_reader.readIntLittle(u32);
const hash_a = try self.in_reader.readInt(u32, .Little);
const hash_b = blk: {
var hasher = std.compress.hashedReader(self.in_reader, Crc32.init());
const hashed_reader = hasher.reader();
const backward_size = (@as(u64, try hashed_reader.readIntLittle(u32)) + 1) * 4;
const backward_size = (@as(u64, try hashed_reader.readInt(u32, .Little)) + 1) * 4;
if (backward_size != index_size)
return error.CorruptInput;

6
lib/std/compress/xz/block.zig
View File

@@ -148,7 +148,7 @@ pub fn Decoder(comptime ReaderType: type) type {
}
const hash_a = header_hasher.hasher.final();
const hash_b = try header_reader.readIntLittle(u32);
const hash_b = try header_reader.readInt(u32, .Little);
if (hash_a != hash_b)
return error.WrongChecksum;
}
@@ -182,13 +182,13 @@ pub fn Decoder(comptime ReaderType: type) type {
.none => {},
.crc32 => {
const hash_a = Crc32.hash(unpacked_bytes);
const hash_b = try self.inner_reader.readIntLittle(u32);
const hash_b = try self.inner_reader.readInt(u32, .Little);
if (hash_a != hash_b)
return error.WrongChecksum;
},
.crc64 => {
const hash_a = Crc64.hash(unpacked_bytes);
const hash_b = try self.inner_reader.readIntLittle(u64);
const hash_b = try self.inner_reader.readInt(u64, .Little);
if (hash_a != hash_b)
return error.WrongChecksum;
},

8
lib/std/compress/zlib.zig
View File

@@ -36,7 +36,7 @@ pub fn DecompressStream(comptime ReaderType: type) type {
fn init(allocator: mem.Allocator, source: ReaderType) !Self {
// Zlib header format is specified in RFC1950
const header_u16 = try source.readIntBig(u16);
const header_u16 = try source.readInt(u16, .Big);
// verify the header checksum
if (header_u16 % 31 != 0)
@@ -81,7 +81,7 @@ pub fn DecompressStream(comptime ReaderType: type) type {
}
// We've reached the end of stream, check if the checksum matches
const hash = try self.in_reader.readIntBig(u32);
const hash = try self.in_reader.readInt(u32, .Big);
if (hash != self.hasher.final())
return error.WrongChecksum;
@@ -132,7 +132,7 @@ pub fn CompressStream(comptime WriterType: type) type {
};
header.checksum = @as(u5, @truncate(31 - @as(u16, @bitCast(header)) % 31));
try dest.writeIntBig(u16, @as(u16, @bitCast(header)));
try dest.writeInt(u16, @as(u16, @bitCast(header)), .Big);
const compression_level: deflate.Compression = switch (options.level) {
.no_compression => .no_compression,
@@ -171,7 +171,7 @@ pub fn CompressStream(comptime WriterType: type) type {
pub fn finish(self: *Self) !void {
const hash = self.hasher.final();
try self.deflator.close();
try self.in_writer.writeIntBig(u32, hash);
try self.in_writer.writeInt(u32, hash, .Big);
}
};
}

2
lib/std/compress/zstandard.zig
View File

@@ -201,7 +201,7 @@ pub fn DecompressStream(
if (block_header.last_block) {
self.state = .LastBlock;
if (self.frame_context.has_checksum) {
const checksum = source_reader.readIntLittle(u32) catch
const checksum = source_reader.readInt(u32, .Little) catch
return error.MalformedFrame;
if (comptime options.verify_checksum) {
if (self.frame_context.hasher_opt) |*hasher| {

8
lib/std/compress/zstandard/decode/block.zig
View File

@@ -13,8 +13,6 @@ const readers = @import("../readers.zig");
const decodeFseTable = @import("fse.zig").decodeFseTable;
const readInt = std.mem.readIntLittle;
pub const Error = error{
BlockSizeOverMaximum,
MalformedBlockSize,
@@ -1031,9 +1029,9 @@ fn decodeStreams(size_format: u2, stream_data: []const u8) !LiteralsSection.Stre
if (stream_data.len < 6) return error.MalformedLiteralsSection;
const stream_1_length = @as(usize, readInt(u16, stream_data[0..2]));
const stream_2_length = @as(usize, readInt(u16, stream_data[2..4]));
const stream_3_length = @as(usize, readInt(u16, stream_data[4..6]));
const stream_1_length: usize = std.mem.readInt(u16, stream_data[0..2], .Little);
const stream_2_length: usize = std.mem.readInt(u16, stream_data[2..4], .Little);
const stream_3_length: usize = std.mem.readInt(u16, stream_data[4..6], .Little);
const stream_1_start = 6;
const stream_2_start = stream_1_start + stream_1_length;

27
lib/std/compress/zstandard/decompress.zig
View File

@@ -15,9 +15,6 @@ pub const block = @import("decode/block.zig");
const readers = @import("readers.zig");
const readInt = std.mem.readIntLittle;
const readIntSlice = std.mem.readIntSliceLittle;
/// Returns `true` is `magic` is a valid magic number for a skippable frame
pub fn isSkippableMagic(magic: u32) bool {
return frame.Skippable.magic_number_min <= magic and magic <= frame.Skippable.magic_number_max;
@@ -31,7 +28,7 @@ pub fn isSkippableMagic(magic: u32) bool {
/// skippable frames.
/// - `error.EndOfStream` if `source` contains fewer than 4 bytes
pub fn decodeFrameType(source: anytype) error{ BadMagic, EndOfStream }!frame.Kind {
const magic = try source.readIntLittle(u32);
const magic = try source.readInt(u32, .Little);
return frameType(magic);
}
@@ -65,14 +62,14 @@ pub const HeaderError = error{ BadMagic, EndOfStream, ReservedBitSet };
/// - `error.ReservedBitSet` if the frame is a Zstandard frame and any of the
/// reserved bits are set
pub fn decodeFrameHeader(source: anytype) (@TypeOf(source).Error || HeaderError)!FrameHeader {
const magic = try source.readIntLittle(u32);
const magic = try source.readInt(u32, .Little);
const frame_type = try frameType(magic);
switch (frame_type) {
.zstandard => return FrameHeader{ .zstandard = try decodeZstandardHeader(source) },
.skippable => return FrameHeader{
.skippable = .{
.magic_number = magic,
.frame_size = try source.readIntLittle(u32),
.frame_size = try source.readInt(u32, .Little),
},
},
}
@@ -193,7 +190,7 @@ pub fn decodeFrame(
switch (try decodeFrameType(fbs.reader())) {
.zstandard => return decodeZstandardFrame(dest, src, verify_checksum),
.skippable => {
const content_size = try fbs.reader().readIntLittle(u32);
const content_size = try fbs.reader().readInt(u32, .Little);
if (content_size > std.math.maxInt(usize) - 8) return error.SkippableSizeTooLarge;
const read_count = @as(usize, content_size) + 8;
if (read_count > src.len) return error.SkippableSizeTooLarge;
@@ -238,7 +235,7 @@ pub fn decodeFrameArrayList(
) (error{ BadMagic, OutOfMemory, SkippableSizeTooLarge } || FrameContext.Error || FrameError)!usize {
var fbs = std.io.fixedBufferStream(src);
const reader = fbs.reader();
const magic = try reader.readIntLittle(u32);
const magic = try reader.readInt(u32, .Little);
switch (try frameType(magic)) {
.zstandard => return decodeZstandardFrameArrayList(
allocator,
@@ -248,7 +245,7 @@ pub fn decodeFrameArrayList(
window_size_max,
),
.skippable => {
const content_size = try fbs.reader().readIntLittle(u32);
const content_size = try fbs.reader().readInt(u32, .Little);
if (content_size > std.math.maxInt(usize) - 8) return error.SkippableSizeTooLarge;
const read_count = @as(usize, content_size) + 8;
if (read_count > src.len) return error.SkippableSizeTooLarge;
@@ -302,7 +299,7 @@ pub fn decodeZstandardFrame(
WindowSizeUnknown,
DictionaryIdFlagUnsupported,
} || FrameError)!ReadWriteCount {
assert(readInt(u32, src[0..4]) == frame.Zstandard.magic_number);
assert(std.mem.readInt(u32, src[0..4], .Little) == frame.Zstandard.magic_number);
var consumed_count: usize = 4;
var frame_context = context: {
@@ -354,7 +351,7 @@ pub fn decodeZStandardFrameBlocks(
if (written_count != content_size) return error.BadContentSize;
if (frame_context.has_checksum) {
if (src.len < consumed_count + 4) return error.EndOfStream;
const checksum = readIntSlice(u32, src[consumed_count .. consumed_count + 4]);
const checksum = std.mem.readInt(u32, src[consumed_count..][0..4], .Little);
consumed_count += 4;
if (frame_context.hasher_opt) |*hasher| {
if (checksum != computeChecksum(hasher)) return error.ChecksumFailure;
@@ -445,7 +442,7 @@ pub fn decodeZstandardFrameArrayList(
verify_checksum: bool,
window_size_max: usize,
) (error{OutOfMemory} || FrameContext.Error || FrameError)!usize {
assert(readInt(u32, src[0..4]) == frame.Zstandard.magic_number);
assert(std.mem.readInt(u32, src[0..4], .Little) == frame.Zstandard.magic_number);
var consumed_count: usize = 4;
var frame_context = context: {
@@ -520,7 +517,7 @@ pub fn decodeZstandardFrameBlocksArrayList(
if (frame_context.has_checksum) {
if (src.len < consumed_count + 4) return error.EndOfStream;
const checksum = readIntSlice(u32, src[consumed_count .. consumed_count + 4]);
const checksum = std.mem.readInt(u32, src[consumed_count..][0..4], .Little);
consumed_count += 4;
if (frame_context.hasher_opt) |*hasher| {
if (checksum != computeChecksum(hasher)) return error.ChecksumFailure;
@@ -569,9 +566,9 @@ fn decodeFrameBlocksInner(
/// Decode the header of a skippable frame. The first four bytes of `src` must
/// be a valid magic number for a skippable frame.
pub fn decodeSkippableHeader(src: *const [8]u8) SkippableHeader {
const magic = readInt(u32, src[0..4]);
const magic = std.mem.readInt(u32, src[0..4], .Little);
assert(isSkippableMagic(magic));
const frame_size = readInt(u32, src[4..8]);
const frame_size = std.mem.readInt(u32, src[4..8], .Little);
return .{
.magic_number = magic,
.frame_size = frame_size,

20
lib/std/crypto/25519/field.zig
View File

@@ -1,8 +1,6 @@
const std = @import("std");
const builtin = @import("builtin");
const crypto = std.crypto;
const readIntLittle = std.mem.readIntLittle;
const writeIntLittle = std.mem.writeIntLittle;
const NonCanonicalError = crypto.errors.NonCanonicalError;
const NotSquareError = crypto.errors.NotSquareError;
@@ -73,11 +71,11 @@ pub const Fe = struct {
/// Unpack a field element
pub fn fromBytes(s: [32]u8) Fe {
var fe: Fe = undefined;
fe.limbs[0] = readIntLittle(u64, s[0..8]) & MASK51;
fe.limbs[1] = (readIntLittle(u64, s[6..14]) >> 3) & MASK51;
fe.limbs[2] = (readIntLittle(u64, s[12..20]) >> 6) & MASK51;
fe.limbs[3] = (readIntLittle(u64, s[19..27]) >> 1) & MASK51;
fe.limbs[4] = (readIntLittle(u64, s[24..32]) >> 12) & MASK51;
fe.limbs[0] = std.mem.readInt(u64, s[0..8], .Little) & MASK51;
fe.limbs[1] = (std.mem.readInt(u64, s[6..14], .Little) >> 3) & MASK51;
fe.limbs[2] = (std.mem.readInt(u64, s[12..20], .Little) >> 6) & MASK51;
fe.limbs[3] = (std.mem.readInt(u64, s[19..27], .Little) >> 1) & MASK51;
fe.limbs[4] = (std.mem.readInt(u64, s[24..32], .Little) >> 12) & MASK51;
return fe;
}
@@ -87,10 +85,10 @@ pub const Fe = struct {
var reduced = fe;
reduced.reduce();
var s: [32]u8 = undefined;
writeIntLittle(u64, s[0..8], reduced.limbs[0] | (reduced.limbs[1] << 51));
writeIntLittle(u64, s[8..16], (reduced.limbs[1] >> 13) | (reduced.limbs[2] << 38));
writeIntLittle(u64, s[16..24], (reduced.limbs[2] >> 26) | (reduced.limbs[3] << 25));
writeIntLittle(u64, s[24..32], (reduced.limbs[3] >> 39) | (reduced.limbs[4] << 12));
std.mem.writeInt(u64, s[0..8], reduced.limbs[0] | (reduced.limbs[1] << 51), .Little);
std.mem.writeInt(u64, s[8..16], (reduced.limbs[1] >> 13) | (reduced.limbs[2] << 38), .Little);
std.mem.writeInt(u64, s[16..24], (reduced.limbs[2] >> 26) | (reduced.limbs[3] << 25), .Little);
std.mem.writeInt(u64, s[24..32], (reduced.limbs[3] >> 39) | (reduced.limbs[4] << 12), .Little);
return s;
}

12
lib/std/crypto/25519/scalar.zig
View File

@@ -15,7 +15,7 @@ pub const zero = [_]u8{0} ** 32;
const field_order_s = s: {
var s: [32]u8 = undefined;
mem.writeIntLittle(u256, &s, field_order);
mem.writeInt(u256, &s, field_order, .Little);
break :s s;
};
@@ -127,9 +127,9 @@ pub const Scalar = struct {
var bytes: CompressedScalar = undefined;
var i: usize = 0;
while (i < 4) : (i += 1) {
mem.writeIntLittle(u64, bytes[i * 7 ..][0..8], expanded.limbs[i]);
mem.writeInt(u64, bytes[i * 7 ..][0..8], expanded.limbs[i], .Little);
}
mem.writeIntLittle(u32, bytes[i * 7 ..][0..4], @as(u32, @intCast(expanded.limbs[i])));
mem.writeInt(u32, bytes[i * 7 ..][0..4], @intCast(expanded.limbs[i]), .Little);
return bytes;
}
@@ -580,7 +580,7 @@ const ScalarDouble = struct {
var limbs: Limbs = undefined;
var i: usize = 0;
while (i < 9) : (i += 1) {
limbs[i] = mem.readIntLittle(u64, bytes[i * 7 ..][0..8]) & 0xffffffffffffff;
limbs[i] = mem.readInt(u64, bytes[i * 7 ..][0..8], .Little) & 0xffffffffffffff;
}
limbs[i] = @as(u64, bytes[i * 7]);
return ScalarDouble{ .limbs = limbs };
@@ -590,9 +590,9 @@ const ScalarDouble = struct {
var limbs: Limbs = undefined;
var i: usize = 0;
while (i < 4) : (i += 1) {
limbs[i] = mem.readIntLittle(u64, bytes[i * 7 ..][0..8]) & 0xffffffffffffff;
limbs[i] = mem.readInt(u64, bytes[i * 7 ..][0..8], .Little) & 0xffffffffffffff;
}
limbs[i] = @as(u64, mem.readIntLittle(u32, bytes[i * 7 ..][0..4]));
limbs[i] = @as(u64, mem.readInt(u32, bytes[i * 7 ..][0..4], .Little));
@memset(limbs[5..], 0);
return ScalarDouble{ .limbs = limbs };
}

4
lib/std/crypto/Certificate/Bundle/macos.zig
View File

@@ -32,7 +32,7 @@ pub fn rescanMac(cb: *Bundle, gpa: Allocator) RescanMacError!void {
var table_idx: u32 = 0;
while (table_idx < table_list.len) : (table_idx += 1) {
table_list[table_idx] = try reader.readIntBig(u32);
table_list[table_idx] = try reader.readInt(u32, .Big);
}
const now_sec = std.time.timestamp();
@@ -51,7 +51,7 @@ pub fn rescanMac(cb: *Bundle, gpa: Allocator) RescanMacError!void {
var record_idx: u32 = 0;
while (record_idx < record_list.len) : (record_idx += 1) {
record_list[record_idx] = try reader.readIntBig(u32);
record_list[record_idx] = try reader.readInt(u32, .Big);
}
for (record_list) |record_offset| {

8
lib/std/crypto/aegis.zig
View File

@@ -106,8 +106,8 @@ const State128L = struct {
fn mac(state: *State128L, comptime tag_bits: u9, adlen: usize, mlen: usize) [tag_bits / 8]u8 {
const blocks = &state.blocks;
var sizes: [16]u8 = undefined;
mem.writeIntLittle(u64, sizes[0..8], adlen * 8);
mem.writeIntLittle(u64, sizes[8..16], mlen * 8);
mem.writeInt(u64, sizes[0..8], adlen * 8, .Little);
mem.writeInt(u64, sizes[8..16], mlen * 8, .Little);
const tmp = AesBlock.fromBytes(&sizes).xorBlocks(blocks[2]);
var i: usize = 0;
while (i < 7) : (i += 1) {
@@ -284,8 +284,8 @@ const State256 = struct {
fn mac(state: *State256, comptime tag_bits: u9, adlen: usize, mlen: usize) [tag_bits / 8]u8 {
const blocks = &state.blocks;
var sizes: [16]u8 = undefined;
mem.writeIntLittle(u64, sizes[0..8], adlen * 8);
mem.writeIntLittle(u64, sizes[8..16], mlen * 8);
mem.writeInt(u64, sizes[0..8], adlen * 8, .Little);
mem.writeInt(u64, sizes[8..16], mlen * 8, .Little);
const tmp = AesBlock.fromBytes(&sizes).xorBlocks(blocks[3]);
var i: usize = 0;
while (i < 7) : (i += 1) {

36
lib/std/crypto/aes/soft.zig
View File

@@ -15,20 +15,20 @@ pub const Block = struct {
/// Convert a byte sequence into an internal representation.
pub inline fn fromBytes(bytes: *const [16]u8) Block {
const s0 = mem.readIntLittle(u32, bytes[0..4]);
const s1 = mem.readIntLittle(u32, bytes[4..8]);
const s2 = mem.readIntLittle(u32, bytes[8..12]);
const s3 = mem.readIntLittle(u32, bytes[12..16]);
const s0 = mem.readInt(u32, bytes[0..4], .Little);
const s1 = mem.readInt(u32, bytes[4..8], .Little);
const s2 = mem.readInt(u32, bytes[8..12], .Little);
const s3 = mem.readInt(u32, bytes[12..16], .Little);
return Block{ .repr = BlockVec{ s0, s1, s2, s3 } };
}
/// Convert the internal representation of a block into a byte sequence.
pub inline fn toBytes(block: Block) [16]u8 {
var bytes: [16]u8 = undefined;
mem.writeIntLittle(u32, bytes[0..4], block.repr[0]);
mem.writeIntLittle(u32, bytes[4..8], block.repr[1]);
mem.writeIntLittle(u32, bytes[8..12], block.repr[2]);
mem.writeIntLittle(u32, bytes[12..16], block.repr[3]);
mem.writeInt(u32, bytes[0..4], block.repr[0], .Little);
mem.writeInt(u32, bytes[4..8], block.repr[1], .Little);
mem.writeInt(u32, bytes[8..12], block.repr[2], .Little);
mem.writeInt(u32, bytes[12..16], block.repr[3], .Little);
return bytes;
}
@@ -123,13 +123,13 @@ pub const Block = struct {
// Last round uses s-box directly and XORs to produce output.
var x: [4]u8 = undefined;
x = sbox_lookup(&sbox_encrypt, @as(u8, @truncate(s0)), @as(u8, @truncate(s1 >> 8)), @as(u8, @truncate(s2 >> 16)), @as(u8, @truncate(s3 >> 24)));
var t0 = mem.readIntLittle(u32, &x);
var t0 = mem.readInt(u32, &x, .Little);
x = sbox_lookup(&sbox_encrypt, @as(u8, @truncate(s1)), @as(u8, @truncate(s2 >> 8)), @as(u8, @truncate(s3 >> 16)), @as(u8, @truncate(s0 >> 24)));
var t1 = mem.readIntLittle(u32, &x);
var t1 = mem.readInt(u32, &x, .Little);
x = sbox_lookup(&sbox_encrypt, @as(u8, @truncate(s2)), @as(u8, @truncate(s3 >> 8)), @as(u8, @truncate(s0 >> 16)), @as(u8, @truncate(s1 >> 24)));
var t2 = mem.readIntLittle(u32, &x);
var t2 = mem.readInt(u32, &x, .Little);
x = sbox_lookup(&sbox_encrypt, @as(u8, @truncate(s3)), @as(u8, @truncate(s0 >> 8)), @as(u8, @truncate(s1 >> 16)), @as(u8, @truncate(s2 >> 24)));
var t3 = mem.readIntLittle(u32, &x);
var t3 = mem.readInt(u32, &x, .Little);
t0 ^= round_key.repr[0];
t1 ^= round_key.repr[1];
@@ -219,13 +219,13 @@ pub const Block = struct {
// Last round uses s-box directly and XORs to produce output.
var x: [4]u8 = undefined;
x = sbox_lookup(&sbox_decrypt, @as(u8, @truncate(s0)), @as(u8, @truncate(s3 >> 8)), @as(u8, @truncate(s2 >> 16)), @as(u8, @truncate(s1 >> 24)));
var t0 = mem.readIntLittle(u32, &x);
var t0 = mem.readInt(u32, &x, .Little);
x = sbox_lookup(&sbox_decrypt, @as(u8, @truncate(s1)), @as(u8, @truncate(s0 >> 8)), @as(u8, @truncate(s3 >> 16)), @as(u8, @truncate(s2 >> 24)));
var t1 = mem.readIntLittle(u32, &x);
var t1 = mem.readInt(u32, &x, .Little);
x = sbox_lookup(&sbox_decrypt, @as(u8, @truncate(s2)), @as(u8, @truncate(s1 >> 8)), @as(u8, @truncate(s0 >> 16)), @as(u8, @truncate(s3 >> 24)));
var t2 = mem.readIntLittle(u32, &x);
var t2 = mem.readInt(u32, &x, .Little);
x = sbox_lookup(&sbox_decrypt, @as(u8, @truncate(s3)), @as(u8, @truncate(s2 >> 8)), @as(u8, @truncate(s1 >> 16)), @as(u8, @truncate(s0 >> 24)));
var t3 = mem.readIntLittle(u32, &x);
var t3 = mem.readInt(u32, &x, .Little);
t0 ^= round_key.repr[0];
t1 ^= round_key.repr[1];
@@ -349,14 +349,14 @@ fn KeySchedule(comptime Aes: type) type {
// Apply sbox_encrypt to each byte in w.
fn func(w: u32) u32 {
const x = sbox_lookup(&sbox_key_schedule, @as(u8, @truncate(w)), @as(u8, @truncate(w >> 8)), @as(u8, @truncate(w >> 16)), @as(u8, @truncate(w >> 24)));
return mem.readIntLittle(u32, &x);
return mem.readInt(u32, &x, .Little);
}
}.func;
var round_keys: [rounds + 1]Block = undefined;
comptime var i: usize = 0;
inline while (i < words_in_key) : (i += 1) {
round_keys[i / 4].repr[i % 4] = mem.readIntBig(u32, key[4 * i ..][0..4]);
round_keys[i / 4].repr[i % 4] = mem.readInt(u32, key[4 * i ..][0..4], .Big);
}
inline while (i < round_keys.len * 4) : (i += 1) {
var t = round_keys[(i - 1) / 4].repr[(i - 1) % 4];

16
lib/std/crypto/aes_gcm.zig
View File

@@ -33,7 +33,7 @@ fn AesGcm(comptime Aes: anytype) type {
var t: [16]u8 = undefined;
var j: [16]u8 = undefined;
j[0..nonce_length].* = npub;
mem.writeIntBig(u32, j[nonce_length..][0..4], 1);
mem.writeInt(u32, j[nonce_length..][0..4], 1, .Big);
aes.encrypt(&t, &j);
const block_count = (math.divCeil(usize, ad.len, Ghash.block_length) catch unreachable) + (math.divCeil(usize, c.len, Ghash.block_length) catch unreachable) + 1;
@@ -41,14 +41,14 @@ fn AesGcm(comptime Aes: anytype) type {
mac.update(ad);
mac.pad();
mem.writeIntBig(u32, j[nonce_length..][0..4], 2);
mem.writeInt(u32, j[nonce_length..][0..4], 2, .Big);
modes.ctr(@TypeOf(aes), aes, c, m, j, std.builtin.Endian.Big);
mac.update(c[0..m.len][0..]);
mac.pad();
var final_block = h;
mem.writeIntBig(u64, final_block[0..8], ad.len * 8);
mem.writeIntBig(u64, final_block[8..16], m.len * 8);
mem.writeInt(u64, final_block[0..8], ad.len * 8, .Big);
mem.writeInt(u64, final_block[8..16], m.len * 8, .Big);
mac.update(&final_block);
mac.final(tag);
for (t, 0..) |x, i| {
@@ -75,7 +75,7 @@ fn AesGcm(comptime Aes: anytype) type {
var t: [16]u8 = undefined;
var j: [16]u8 = undefined;
j[0..nonce_length].* = npub;
mem.writeIntBig(u32, j[nonce_length..][0..4], 1);
mem.writeInt(u32, j[nonce_length..][0..4], 1, .Big);
aes.encrypt(&t, &j);
const block_count = (math.divCeil(usize, ad.len, Ghash.block_length) catch unreachable) + (math.divCeil(usize, c.len, Ghash.block_length) catch unreachable) + 1;
@@ -87,8 +87,8 @@ fn AesGcm(comptime Aes: anytype) type {
mac.pad();
var final_block = h;
mem.writeIntBig(u64, final_block[0..8], ad.len * 8);
mem.writeIntBig(u64, final_block[8..16], m.len * 8);
mem.writeInt(u64, final_block[0..8], ad.len * 8, .Big);
mem.writeInt(u64, final_block[8..16], m.len * 8, .Big);
mac.update(&final_block);
var computed_tag: [Ghash.mac_length]u8 = undefined;
mac.final(&computed_tag);
@@ -103,7 +103,7 @@ fn AesGcm(comptime Aes: anytype) type {
return error.AuthenticationFailed;
}
mem.writeIntBig(u32, j[nonce_length..][0..4], 2);
mem.writeInt(u32, j[nonce_length..][0..4], 2, .Big);
modes.ctr(@TypeOf(aes), aes, m, c, j, std.builtin.Endian.Big);
}
};

8
lib/std/crypto/aes_ocb.zig
View File

@@ -29,10 +29,10 @@ fn AesOcb(comptime Aes: anytype) type {
upto: usize,
inline fn double(l: Block) Block {
const l_ = mem.readIntBig(u128, &l);
const l_ = mem.readInt(u128, &l, .Big);
const l_2 = (l_ << 1) ^ (0x87 & -%(l_ >> 127));
var l2: Block = undefined;
mem.writeIntBig(u128, &l2, l_2);
mem.writeInt(u128, &l2, l_2, .Big);
return l2;
}
@@ -94,10 +94,10 @@ fn AesOcb(comptime Aes: anytype) type {
nx[15] &= 0xc0;
var ktop_: Block = undefined;
aes_enc_ctx.encrypt(&ktop_, &nx);
const ktop = mem.readIntBig(u128, &ktop_);
const ktop = mem.readInt(u128, &ktop_, .Big);
var stretch = (@as(u192, ktop) << 64) | @as(u192, @as(u64, @truncate(ktop >> 64)) ^ @as(u64, @truncate(ktop >> 56)));
var offset: Block = undefined;
mem.writeIntBig(u128, &offset, @as(u128, @truncate(stretch >> (64 - @as(u7, bottom)))));
mem.writeInt(u128, &offset, @as(u128, @truncate(stretch >> (64 - @as(u7, bottom)))), .Big);
return offset;
}

34
lib/std/crypto/argon2.zig
View File

@@ -110,27 +110,27 @@ fn initHash(
var parameters: [24]u8 = undefined;
var tmp: [4]u8 = undefined;
var b2 = Blake2b512.init(.{});
mem.writeIntLittle(u32, parameters[0..4], params.p);
mem.writeIntLittle(u32, parameters[4..8], @as(u32, @intCast(dk_len)));
mem.writeIntLittle(u32, parameters[8..12], params.m);
mem.writeIntLittle(u32, parameters[12..16], params.t);
mem.writeIntLittle(u32, parameters[16..20], version);
mem.writeIntLittle(u32, parameters[20..24], @intFromEnum(mode));
mem.writeInt(u32, parameters[0..4], params.p, .Little);
mem.writeInt(u32, parameters[4..8], @as(u32, @intCast(dk_len)), .Little);
mem.writeInt(u32, parameters[8..12], params.m, .Little);
mem.writeInt(u32, parameters[12..16], params.t, .Little);
mem.writeInt(u32, parameters[16..20], version, .Little);
mem.writeInt(u32, parameters[20..24], @intFromEnum(mode), .Little);
b2.update(&parameters);
mem.writeIntLittle(u32, &tmp, @as(u32, @intCast(password.len)));
mem.writeInt(u32, &tmp, @as(u32, @intCast(password.len)), .Little);
b2.update(&tmp);
b2.update(password);
mem.writeIntLittle(u32, &tmp, @as(u32, @intCast(salt.len)));
mem.writeInt(u32, &tmp, @as(u32, @intCast(salt.len)), .Little);
b2.update(&tmp);
b2.update(salt);
const secret = params.secret orelse "";
std.debug.assert(secret.len <= max_int);
mem.writeIntLittle(u32, &tmp, @as(u32, @intCast(secret.len)));
mem.writeInt(u32, &tmp, @as(u32, @intCast(secret.len)), .Little);
b2.update(&tmp);
b2.update(secret);
const ad = params.ad orelse "";
std.debug.assert(ad.len <= max_int);
mem.writeIntLittle(u32, &tmp, @as(u32, @intCast(ad.len)));
mem.writeInt(u32, &tmp, @as(u32, @intCast(ad.len)), .Little);
b2.update(&tmp);
b2.update(ad);
b2.final(h0[0..Blake2b512.digest_length]);
@@ -140,7 +140,7 @@ fn initHash(
fn blake2bLong(out: []u8, in: []const u8) void {
const H = Blake2b512;
var outlen_bytes: [4]u8 = undefined;
mem.writeIntLittle(u32, &outlen_bytes, @as(u32, @intCast(out.len)));
mem.writeInt(u32, &outlen_bytes, @as(u32, @intCast(out.len)), .Little);
var out_buf: [H.digest_length]u8 = undefined;
@@ -183,18 +183,18 @@ fn initBlocks(
var lane: u24 = 0;
while (lane < threads) : (lane += 1) {
const j = lane * (memory / threads);
mem.writeIntLittle(u32, h0[Blake2b512.digest_length + 4 ..][0..4], lane);
mem.writeInt(u32, h0[Blake2b512.digest_length + 4 ..][0..4], lane, .Little);
mem.writeIntLittle(u32, h0[Blake2b512.digest_length..][0..4], 0);
mem.writeInt(u32, h0[Blake2b512.digest_length..][0..4], 0, .Little);
blake2bLong(&block0, h0);
for (&blocks.items[j + 0], 0..) |*v, i| {
v.* = mem.readIntLittle(u64, block0[i * 8 ..][0..8]);
v.* = mem.readInt(u64, block0[i * 8 ..][0..8], .Little);
}
mem.writeIntLittle(u32, h0[Blake2b512.digest_length..][0..4], 1);
mem.writeInt(u32, h0[Blake2b512.digest_length..][0..4], 1, .Little);
blake2bLong(&block0, h0);
for (&blocks.items[j + 1], 0..) |*v, i| {
v.* = mem.readIntLittle(u64, block0[i * 8 ..][0..8]);
v.* = mem.readInt(u64, block0[i * 8 ..][0..8], .Little);
}
}
}
@@ -433,7 +433,7 @@ fn finalize(
}
var block: [1024]u8 = undefined;
for (blocks.items[memory - 1], 0..) |v, i| {
mem.writeIntLittle(u64, block[i * 8 ..][0..8], v);
mem.writeInt(u64, block[i * 8 ..][0..8], v, .Little);
}
blake2bLong(out, &block);
}

13
lib/std/crypto/ascon.zig
View File

@@ -8,11 +8,12 @@
//! It is not meant to be used directly, but as a building block for symmetric cryptography.
const std = @import("std");
const builtin = std.builtin;
const builtin = @import("builtin");
const debug = std.debug;
const mem = std.mem;
const testing = std.testing;
const rotr = std.math.rotr;
const native_endian = builtin.cpu.arch.endian();
/// An Ascon state.
///
@@ -20,7 +21,7 @@ const rotr = std.math.rotr;
///
/// The NIST submission (v1.2) serializes these words as big-endian,
/// but software implementations are free to use native endianness.
pub fn State(comptime endian: builtin.Endian) type {
pub fn State(comptime endian: std.builtin.Endian) type {
return struct {
const Self = @This();
@@ -133,14 +134,14 @@ pub fn State(comptime endian: builtin.Endian) type {
var i: usize = 0;
while (i + 8 <= in.len) : (i += 8) {
const x = mem.readIntNative(u64, in[i..][0..8]) ^ mem.nativeTo(u64, self.st[i / 8], endian);
mem.writeIntNative(u64, out[i..][0..8], x);
const x = mem.readInt(u64, in[i..][0..8], native_endian) ^ mem.nativeTo(u64, self.st[i / 8], endian);
mem.writeInt(u64, out[i..][0..8], x, native_endian);
}
if (i < in.len) {
var padded = [_]u8{0} ** 8;
@memcpy(padded[0 .. in.len - i], in[i..]);
const x = mem.readIntNative(u64, &padded) ^ mem.nativeTo(u64, self.st[i / 8], endian);
mem.writeIntNative(u64, &padded, x);
const x = mem.readInt(u64, &padded, native_endian) ^ mem.nativeTo(u64, self.st[i / 8], endian);
mem.writeInt(u64, &padded, x, native_endian);
@memcpy(out[i..], padded[0 .. in.len - i]);
}
}

4
lib/std/crypto/bcrypt.zig
View File

@@ -451,7 +451,7 @@ pub fn bcrypt(
var ct: [ct_length]u8 = undefined;
for (cdata, 0..) |c, i| {
mem.writeIntBig(u32, ct[i * 4 ..][0..4], c);
mem.writeInt(u32, ct[i * 4 ..][0..4], c, .Big);
}
return ct[0..dk_length].*;
}
@@ -547,7 +547,7 @@ const pbkdf_prf = struct {
// copy out
var out: [32]u8 = undefined;
for (cdata, 0..) |v, i| {
std.mem.writeIntLittle(u32, out[4 * i ..][0..4], v);
std.mem.writeInt(u32, out[4 * i ..][0..4], v, .Little);
}
// zap

20
lib/std/crypto/blake2.zig
View File

@@ -85,12 +85,12 @@ pub fn Blake2s(comptime out_bits: usize) type {
d.buf_len = 0;
if (options.salt) |salt| {
d.h[4] ^= mem.readIntLittle(u32, salt[0..4]);
d.h[5] ^= mem.readIntLittle(u32, salt[4..8]);
d.h[4] ^= mem.readInt(u32, salt[0..4], .Little);
d.h[5] ^= mem.readInt(u32, salt[4..8], .Little);
}
if (options.context) |context| {
d.h[6] ^= mem.readIntLittle(u32, context[0..4]);
d.h[7] ^= mem.readIntLittle(u32, context[4..8]);
d.h[6] ^= mem.readInt(u32, context[0..4], .Little);
d.h[7] ^= mem.readInt(u32, context[4..8], .Little);
}
if (key_len > 0) {
@memset(d.buf[key_len..], 0);
@@ -143,7 +143,7 @@ pub fn Blake2s(comptime out_bits: usize) type {
var v: [16]u32 = undefined;
for (&m, 0..) |*r, i| {
r.* = mem.readIntLittle(u32, b[4 * i ..][0..4]);
r.* = mem.readInt(u32, b[4 * i ..][0..4], .Little);
}
var k: usize = 0;
@@ -521,12 +521,12 @@ pub fn Blake2b(comptime out_bits: usize) type {
d.buf_len = 0;
if (options.salt) |salt| {
d.h[4] ^= mem.readIntLittle(u64, salt[0..8]);
d.h[5] ^= mem.readIntLittle(u64, salt[8..16]);
d.h[4] ^= mem.readInt(u64, salt[0..8], .Little);
d.h[5] ^= mem.readInt(u64, salt[8..16], .Little);
}
if (options.context) |context| {
d.h[6] ^= mem.readIntLittle(u64, context[0..8]);
d.h[7] ^= mem.readIntLittle(u64, context[8..16]);
d.h[6] ^= mem.readInt(u64, context[0..8], .Little);
d.h[7] ^= mem.readInt(u64, context[8..16], .Little);
}
if (key_len > 0) {
@memset(d.buf[key_len..], 0);
@@ -579,7 +579,7 @@ pub fn Blake2b(comptime out_bits: usize) type {
var v: [16]u64 = undefined;
for (&m, 0..) |*r, i| {
r.* = mem.readIntLittle(u64, b[8 * i ..][0..8]);
r.* = mem.readInt(u64, b[8 * i ..][0..8], .Little);
}
var k: usize = 0;

4
lib/std/crypto/blake3.zig
View File

@@ -212,7 +212,7 @@ fn first8Words(words: [16]u32) [8]u32 {
fn wordsFromLittleEndianBytes(comptime count: usize, bytes: [count * 4]u8) [count]u32 {
var words: [count]u32 = undefined;
for (&words, 0..) |*word, i| {
word.* = mem.readIntSliceLittle(u32, bytes[4 * i ..]);
word.* = mem.readInt(u32, bytes[4 * i ..][0..4], .Little);
}
return words;
}
@@ -252,7 +252,7 @@ const Output = struct {
var word_counter: usize = 0;
while (out_word_it.next()) |out_word| {
var word_bytes: [4]u8 = undefined;
mem.writeIntLittle(u32, &word_bytes, words[word_counter]);
mem.writeInt(u32, &word_bytes, words[word_counter], .Little);
@memcpy(out_word, word_bytes[0..out_word.len]);
word_counter += 1;
}

146
lib/std/crypto/chacha20.zig
View File

@@ -87,10 +87,10 @@ fn ChaChaVecImpl(comptime rounds_nb: usize, comptime degree: comptime_int) type
switch (degree) {
1 => {
const constant_le = Lane{
mem.readIntLittle(u32, c[0..4]),
mem.readIntLittle(u32, c[4..8]),
mem.readIntLittle(u32, c[8..12]),
mem.readIntLittle(u32, c[12..16]),
mem.readInt(u32, c[0..4], .Little),
mem.readInt(u32, c[4..8], .Little),
mem.readInt(u32, c[8..12], .Little),
mem.readInt(u32, c[12..16], .Little),
};
return BlockVec{
constant_le,
@@ -101,14 +101,14 @@ fn ChaChaVecImpl(comptime rounds_nb: usize, comptime degree: comptime_int) type
},
2 => {
const constant_le = Lane{
mem.readIntLittle(u32, c[0..4]),
mem.readIntLittle(u32, c[4..8]),
mem.readIntLittle(u32, c[8..12]),
mem.readIntLittle(u32, c[12..16]),
mem.readIntLittle(u32, c[0..4]),
mem.readIntLittle(u32, c[4..8]),
mem.readIntLittle(u32, c[8..12]),
mem.readIntLittle(u32, c[12..16]),
mem.readInt(u32, c[0..4], .Little),
mem.readInt(u32, c[4..8], .Little),
mem.readInt(u32, c[8..12], .Little),
mem.readInt(u32, c[12..16], .Little),
mem.readInt(u32, c[0..4], .Little),
mem.readInt(u32, c[4..8], .Little),
mem.readInt(u32, c[8..12], .Little),
mem.readInt(u32, c[12..16], .Little),
};
const n1 = @addWithOverflow(d[0], 1);
return BlockVec{
@@ -123,22 +123,22 @@ fn ChaChaVecImpl(comptime rounds_nb: usize, comptime degree: comptime_int) type
const n2 = @addWithOverflow(d[0], 2);
const n3 = @addWithOverflow(d[0], 3);
const constant_le = Lane{
mem.readIntLittle(u32, c[0..4]),
mem.readIntLittle(u32, c[4..8]),
mem.readIntLittle(u32, c[8..12]),
mem.readIntLittle(u32, c[12..16]),
mem.readIntLittle(u32, c[0..4]),
mem.readIntLittle(u32, c[4..8]),
mem.readIntLittle(u32, c[8..12]),
mem.readIntLittle(u32, c[12..16]),
mem.readIntLittle(u32, c[0..4]),
mem.readIntLittle(u32, c[4..8]),
mem.readIntLittle(u32, c[8..12]),
mem.readIntLittle(u32, c[12..16]),
mem.readIntLittle(u32, c[0..4]),
mem.readIntLittle(u32, c[4..8]),
mem.readIntLittle(u32, c[8..12]),
mem.readIntLittle(u32, c[12..16]),
mem.readInt(u32, c[0..4], .Little),
mem.readInt(u32, c[4..8], .Little),
mem.readInt(u32, c[8..12], .Little),
mem.readInt(u32, c[12..16], .Little),
mem.readInt(u32, c[0..4], .Little),
mem.readInt(u32, c[4..8], .Little),
mem.readInt(u32, c[8..12], .Little),
mem.readInt(u32, c[12..16], .Little),
mem.readInt(u32, c[0..4], .Little),
mem.readInt(u32, c[4..8], .Little),
mem.readInt(u32, c[8..12], .Little),
mem.readInt(u32, c[12..16], .Little),
mem.readInt(u32, c[0..4], .Little),
mem.readInt(u32, c[4..8], .Little),
mem.readInt(u32, c[8..12], .Little),
mem.readInt(u32, c[12..16], .Little),
};
return BlockVec{
constant_le,
@@ -218,10 +218,10 @@ fn ChaChaVecImpl(comptime rounds_nb: usize, comptime degree: comptime_int) type
inline fn hashToBytes(comptime dm: usize, out: *[64 * dm]u8, x: BlockVec) void {
for (0..dm) |d| {
for (0..4) |i| {
mem.writeIntLittle(u32, out[64 * d + 16 * i + 0 ..][0..4], x[i][0 + 4 * d]);
mem.writeIntLittle(u32, out[64 * d + 16 * i + 4 ..][0..4], x[i][1 + 4 * d]);
mem.writeIntLittle(u32, out[64 * d + 16 * i + 8 ..][0..4], x[i][2 + 4 * d]);
mem.writeIntLittle(u32, out[64 * d + 16 * i + 12 ..][0..4], x[i][3 + 4 * d]);
mem.writeInt(u32, out[64 * d + 16 * i + 0 ..][0..4], x[i][0 + 4 * d], .Little);
mem.writeInt(u32, out[64 * d + 16 * i + 4 ..][0..4], x[i][1 + 4 * d], .Little);
mem.writeInt(u32, out[64 * d + 16 * i + 8 ..][0..4], x[i][2 + 4 * d], .Little);
mem.writeInt(u32, out[64 * d + 16 * i + 12 ..][0..4], x[i][3 + 4 * d], .Little);
}
}
}
@@ -309,20 +309,20 @@ fn ChaChaVecImpl(comptime rounds_nb: usize, comptime degree: comptime_int) type
fn hchacha20(input: [16]u8, key: [32]u8) [32]u8 {
var c: [4]u32 = undefined;
for (c, 0..) |_, i| {
c[i] = mem.readIntLittle(u32, input[4 * i ..][0..4]);
c[i] = mem.readInt(u32, input[4 * i ..][0..4], .Little);
}
const ctx = initContext(keyToWords(key), c);
var x: BlockVec = undefined;
chacha20Core(x[0..], ctx);
var out: [32]u8 = undefined;
mem.writeIntLittle(u32, out[0..4], x[0][0]);
mem.writeIntLittle(u32, out[4..8], x[0][1]);
mem.writeIntLittle(u32, out[8..12], x[0][2]);
mem.writeIntLittle(u32, out[12..16], x[0][3]);
mem.writeIntLittle(u32, out[16..20], x[3][0]);
mem.writeIntLittle(u32, out[20..24], x[3][1]);
mem.writeIntLittle(u32, out[24..28], x[3][2]);
mem.writeIntLittle(u32, out[28..32], x[3][3]);
mem.writeInt(u32, out[0..4], x[0][0], .Little);
mem.writeInt(u32, out[4..8], x[0][1], .Little);
mem.writeInt(u32, out[8..12], x[0][2], .Little);
mem.writeInt(u32, out[12..16], x[0][3], .Little);
mem.writeInt(u32, out[16..20], x[3][0], .Little);
mem.writeInt(u32, out[20..24], x[3][1], .Little);
mem.writeInt(u32, out[24..28], x[3][2], .Little);
mem.writeInt(u32, out[28..32], x[3][3], .Little);
return out;
}
};
@@ -336,10 +336,10 @@ fn ChaChaNonVecImpl(comptime rounds_nb: usize) type {
fn initContext(key: [8]u32, d: [4]u32) BlockVec {
const c = "expand 32-byte k";
const constant_le = comptime [4]u32{
mem.readIntLittle(u32, c[0..4]),
mem.readIntLittle(u32, c[4..8]),
mem.readIntLittle(u32, c[8..12]),
mem.readIntLittle(u32, c[12..16]),
mem.readInt(u32, c[0..4], .Little),
mem.readInt(u32, c[4..8], .Little),
mem.readInt(u32, c[8..12], .Little),
mem.readInt(u32, c[12..16], .Little),
};
return BlockVec{
constant_le[0], constant_le[1], constant_le[2], constant_le[3],
@@ -396,10 +396,10 @@ fn ChaChaNonVecImpl(comptime rounds_nb: usize) type {
inline fn hashToBytes(out: *[64]u8, x: BlockVec) void {
for (0..4) |i| {
mem.writeIntLittle(u32, out[16 * i + 0 ..][0..4], x[i * 4 + 0]);
mem.writeIntLittle(u32, out[16 * i + 4 ..][0..4], x[i * 4 + 1]);
mem.writeIntLittle(u32, out[16 * i + 8 ..][0..4], x[i * 4 + 2]);
mem.writeIntLittle(u32, out[16 * i + 12 ..][0..4], x[i * 4 + 3]);
mem.writeInt(u32, out[16 * i + 0 ..][0..4], x[i * 4 + 0], .Little);
mem.writeInt(u32, out[16 * i + 4 ..][0..4], x[i * 4 + 1], .Little);
mem.writeInt(u32, out[16 * i + 8 ..][0..4], x[i * 4 + 2], .Little);
mem.writeInt(u32, out[16 * i + 12 ..][0..4], x[i * 4 + 3], .Little);
}
}
@@ -477,20 +477,20 @@ fn ChaChaNonVecImpl(comptime rounds_nb: usize) type {
fn hchacha20(input: [16]u8, key: [32]u8) [32]u8 {
var c: [4]u32 = undefined;
for (c, 0..) |_, i| {
c[i] = mem.readIntLittle(u32, input[4 * i ..][0..4]);
c[i] = mem.readInt(u32, input[4 * i ..][0..4], .Little);
}
const ctx = initContext(keyToWords(key), c);
var x: BlockVec = undefined;
chacha20Core(x[0..], ctx);
var out: [32]u8 = undefined;
mem.writeIntLittle(u32, out[0..4], x[0]);
mem.writeIntLittle(u32, out[4..8], x[1]);
mem.writeIntLittle(u32, out[8..12], x[2]);
mem.writeIntLittle(u32, out[12..16], x[3]);
mem.writeIntLittle(u32, out[16..20], x[12]);
mem.writeIntLittle(u32, out[20..24], x[13]);
mem.writeIntLittle(u32, out[24..28], x[14]);
mem.writeIntLittle(u32, out[28..32], x[15]);
mem.writeInt(u32, out[0..4], x[0], .Little);
mem.writeInt(u32, out[4..8], x[1], .Little);
mem.writeInt(u32, out[8..12], x[2], .Little);
mem.writeInt(u32, out[12..16], x[3], .Little);
mem.writeInt(u32, out[16..20], x[12], .Little);
mem.writeInt(u32, out[20..24], x[13], .Little);
mem.writeInt(u32, out[24..28], x[14], .Little);
mem.writeInt(u32, out[28..32], x[15], .Little);
return out;
}
};
@@ -519,7 +519,7 @@ fn ChaChaImpl(comptime rounds_nb: usize) type {
fn keyToWords(key: [32]u8) [8]u32 {
var k: [8]u32 = undefined;
for (0..8) |i| {
k[i] = mem.readIntLittle(u32, key[i * 4 ..][0..4]);
k[i] = mem.readInt(u32, key[i * 4 ..][0..4], .Little);
}
return k;
}
@@ -552,9 +552,9 @@ fn ChaChaIETF(comptime rounds_nb: usize) type {
var d: [4]u32 = undefined;
d[0] = counter;
d[1] = mem.readIntLittle(u32, nonce[0..4]);
d[2] = mem.readIntLittle(u32, nonce[4..8]);
d[3] = mem.readIntLittle(u32, nonce[8..12]);
d[1] = mem.readInt(u32, nonce[0..4], .Little);
d[2] = mem.readInt(u32, nonce[4..8], .Little);
d[3] = mem.readInt(u32, nonce[8..12], .Little);
ChaChaImpl(rounds_nb).chacha20Xor(out, in, keyToWords(key), d, false);
}
@@ -564,9 +564,9 @@ fn ChaChaIETF(comptime rounds_nb: usize) type {
var d: [4]u32 = undefined;
d[0] = counter;
d[1] = mem.readIntLittle(u32, nonce[0..4]);
d[2] = mem.readIntLittle(u32, nonce[4..8]);
d[3] = mem.readIntLittle(u32, nonce[8..12]);
d[1] = mem.readInt(u32, nonce[0..4], .Little);
d[2] = mem.readInt(u32, nonce[4..8], .Little);
d[3] = mem.readInt(u32, nonce[8..12], .Little);
ChaChaImpl(rounds_nb).chacha20Stream(out, keyToWords(key), d, false);
}
};
@@ -592,8 +592,8 @@ fn ChaChaWith64BitNonce(comptime rounds_nb: usize) type {
var c: [4]u32 = undefined;
c[0] = @as(u32, @truncate(counter));
c[1] = @as(u32, @truncate(counter >> 32));
c[2] = mem.readIntLittle(u32, nonce[0..4]);
c[3] = mem.readIntLittle(u32, nonce[4..8]);
c[2] = mem.readInt(u32, nonce[0..4], .Little);
c[3] = mem.readInt(u32, nonce[4..8], .Little);
ChaChaImpl(rounds_nb).chacha20Xor(out, in, k, c, true);
}
@@ -605,8 +605,8 @@ fn ChaChaWith64BitNonce(comptime rounds_nb: usize) type {
var c: [4]u32 = undefined;
c[0] = @as(u32, @truncate(counter));
c[1] = @as(u32, @truncate(counter >> 32));
c[2] = mem.readIntLittle(u32, nonce[0..4]);
c[3] = mem.readIntLittle(u32, nonce[4..8]);
c[2] = mem.readInt(u32, nonce[0..4], .Little);
c[3] = mem.readInt(u32, nonce[4..8], .Little);
ChaChaImpl(rounds_nb).chacha20Stream(out, k, c, true);
}
};
@@ -672,8 +672,8 @@ fn ChaChaPoly1305(comptime rounds_nb: usize) type {
mac.update(zeros[0..padding]);
}
var lens: [16]u8 = undefined;
mem.writeIntLittle(u64, lens[0..8], ad.len);
mem.writeIntLittle(u64, lens[8..16], m.len);
mem.writeInt(u64, lens[0..8], ad.len, .Little);
mem.writeInt(u64, lens[8..16], m.len, .Little);
mac.update(lens[0..]);
mac.final(tag);
}
@@ -708,8 +708,8 @@ fn ChaChaPoly1305(comptime rounds_nb: usize) type {
mac.update(zeros[0..padding]);
}
var lens: [16]u8 = undefined;
mem.writeIntLittle(u64, lens[0..8], ad.len);
mem.writeIntLittle(u64, lens[8..16], c.len);
mem.writeInt(u64, lens[0..8], ad.len, .Little);
mem.writeInt(u64, lens[8..16], c.len, .Little);
mac.update(lens[0..]);
var computed_tag: [16]u8 = undefined;
mac.final(computed_tag[0..]);

4
lib/std/crypto/cmac.zig
View File

@@ -76,7 +76,7 @@ pub fn Cmac(comptime BlockCipher: type) type {
fn double(l: Block) Block {
const Int = std.meta.Int(.unsigned, block_length * 8);
const l_ = mem.readIntBig(Int, &l);
const l_ = mem.readInt(Int, &l, .Big);
const l_2 = switch (block_length) {
8 => (l_ << 1) ^ (0x1b & -%(l_ >> 63)), // mod x^64 + x^4 + x^3 + x + 1
16 => (l_ << 1) ^ (0x87 & -%(l_ >> 127)), // mod x^128 + x^7 + x^2 + x + 1
@@ -85,7 +85,7 @@ pub fn Cmac(comptime BlockCipher: type) type {
else => @compileError("unsupported block length"),
};
var l2: Block = undefined;
mem.writeIntBig(Int, &l2, l_2);
mem.writeInt(Int, &l2, l_2, .Big);
return l2;
}
};

22
lib/std/crypto/isap.zig
View File

@@ -55,9 +55,9 @@ pub const IsapA128A = struct {
fn trickle(k: [16]u8, iv: [8]u8, y: []const u8, comptime out_len: usize) [out_len]u8 {
var isap = IsapA128A{
.st = Ascon.initFromWords(.{
mem.readIntBig(u64, k[0..8]),
mem.readIntBig(u64, k[8..16]),
mem.readIntBig(u64, iv[0..8]),
mem.readInt(u64, k[0..8], .Big),
mem.readInt(u64, k[8..16], .Big),
mem.readInt(u64, iv[0..8], .Big),
0,
0,
}),
@@ -85,9 +85,9 @@ pub const IsapA128A = struct {
fn mac(c: []const u8, ad: []const u8, npub: [16]u8, key: [16]u8) [16]u8 {
var isap = IsapA128A{
.st = Ascon.initFromWords(.{
mem.readIntBig(u64, npub[0..8]),
mem.readIntBig(u64, npub[8..16]),
mem.readIntBig(u64, iv1[0..]),
mem.readInt(u64, npub[0..8], .Big),
mem.readInt(u64, npub[8..16], .Big),
mem.readInt(u64, iv1[0..], .Big),
0,
0,
}),
@@ -116,11 +116,11 @@ pub const IsapA128A = struct {
const nb = trickle(key, iv3, npub[0..], 24);
var isap = IsapA128A{
.st = Ascon.initFromWords(.{
mem.readIntBig(u64, nb[0..8]),
mem.readIntBig(u64, nb[8..16]),
mem.readIntBig(u64, nb[16..24]),
mem.readIntBig(u64, npub[0..8]),
mem.readIntBig(u64, npub[8..16]),
mem.readInt(u64, nb[0..8], .Big),
mem.readInt(u64, nb[8..16], .Big),
mem.readInt(u64, nb[16..24], .Big),
mem.readInt(u64, npub[0..8], .Big),
mem.readInt(u64, npub[8..16], .Big),
}),
};
isap.st.permuteR(6);

24
lib/std/crypto/keccak_p.zig
View File

@@ -1,7 +1,9 @@
const std = @import("std");
const builtin = @import("builtin");
const assert = std.debug.assert;
const math = std.math;
const mem = std.mem;
const native_endian = builtin.cpu.arch.endian();
/// The Keccak-f permutation.
pub fn KeccakF(comptime f: u11) type {
@@ -43,7 +45,7 @@ pub fn KeccakF(comptime f: u11) type {
pub fn init(bytes: [block_bytes]u8) Self {
var self: Self = undefined;
inline for (&self.st, 0..) |*r, i| {
r.* = mem.readIntLittle(T, bytes[@sizeOf(T) * i ..][0..@sizeOf(T)]);
r.* = mem.readInt(T, bytes[@sizeOf(T) * i ..][0..@sizeOf(T)], .Little);
}
return self;
}
@@ -64,12 +66,12 @@ pub fn KeccakF(comptime f: u11) type {
pub fn setBytes(self: *Self, bytes: []const u8) void {
var i: usize = 0;
while (i + @sizeOf(T) <= bytes.len) : (i += @sizeOf(T)) {
self.st[i / @sizeOf(T)] = mem.readIntLittle(T, bytes[i..][0..@sizeOf(T)]);
self.st[i / @sizeOf(T)] = mem.readInt(T, bytes[i..][0..@sizeOf(T)], .Little);
}
if (i < bytes.len) {
var padded = [_]u8{0} ** @sizeOf(T);
@memcpy(padded[0 .. bytes.len - i], bytes[i..]);
self.st[i / @sizeOf(T)] = mem.readIntLittle(T, padded[0..]);
self.st[i / @sizeOf(T)] = mem.readInt(T, padded[0..], .Little);
}
}
@@ -83,12 +85,12 @@ pub fn KeccakF(comptime f: u11) type {
pub fn addBytes(self: *Self, bytes: []const u8) void {
var i: usize = 0;
while (i + @sizeOf(T) <= bytes.len) : (i += @sizeOf(T)) {
self.st[i / @sizeOf(T)] ^= mem.readIntLittle(T, bytes[i..][0..@sizeOf(T)]);
self.st[i / @sizeOf(T)] ^= mem.readInt(T, bytes[i..][0..@sizeOf(T)], .Little);
}
if (i < bytes.len) {
var padded = [_]u8{0} ** @sizeOf(T);
@memcpy(padded[0 .. bytes.len - i], bytes[i..]);
self.st[i / @sizeOf(T)] ^= mem.readIntLittle(T, padded[0..]);
self.st[i / @sizeOf(T)] ^= mem.readInt(T, padded[0..], .Little);
}
}
@@ -96,11 +98,11 @@ pub fn KeccakF(comptime f: u11) type {
pub fn extractBytes(self: *Self, out: []u8) void {
var i: usize = 0;
while (i + @sizeOf(T) <= out.len) : (i += @sizeOf(T)) {
mem.writeIntLittle(T, out[i..][0..@sizeOf(T)], self.st[i / @sizeOf(T)]);
mem.writeInt(T, out[i..][0..@sizeOf(T)], self.st[i / @sizeOf(T)], .Little);
}
if (i < out.len) {
var padded = [_]u8{0} ** @sizeOf(T);
mem.writeIntLittle(T, padded[0..], self.st[i / @sizeOf(T)]);
mem.writeInt(T, padded[0..], self.st[i / @sizeOf(T)], .Little);
@memcpy(out[i..], padded[0 .. out.len - i]);
}
}
@@ -111,14 +113,14 @@ pub fn KeccakF(comptime f: u11) type {
var i: usize = 0;
while (i + @sizeOf(T) <= in.len) : (i += @sizeOf(T)) {
const x = mem.readIntNative(T, in[i..][0..@sizeOf(T)]) ^ mem.nativeToLittle(T, self.st[i / @sizeOf(T)]);
mem.writeIntNative(T, out[i..][0..@sizeOf(T)], x);
const x = mem.readInt(T, in[i..][0..@sizeOf(T)], native_endian) ^ mem.nativeToLittle(T, self.st[i / @sizeOf(T)]);
mem.writeInt(T, out[i..][0..@sizeOf(T)], x, native_endian);
}
if (i < in.len) {
var padded = [_]u8{0} ** @sizeOf(T);
@memcpy(padded[0 .. in.len - i], in[i..]);
const x = mem.readIntNative(T, &padded) ^ mem.nativeToLittle(T, self.st[i / @sizeOf(T)]);
mem.writeIntNative(T, &padded, x);
const x = mem.readInt(T, &padded, native_endian) ^ mem.nativeToLittle(T, self.st[i / @sizeOf(T)]);
mem.writeInt(T, &padded, x, native_endian);
@memcpy(out[i..], padded[0 .. in.len - i]);
}
}

4
lib/std/crypto/md5.zig
View File

@@ -112,7 +112,7 @@ pub const Md5 = struct {
d.round(d.buf[0..]);
for (d.s, 0..) |s, j| {
mem.writeIntLittle(u32, out[4 * j ..][0..4], s);
mem.writeInt(u32, out[4 * j ..][0..4], s, .Little);
}
}
@@ -121,7 +121,7 @@ pub const Md5 = struct {
var i: usize = 0;
while (i < 16) : (i += 1) {
s[i] = mem.readIntLittle(u32, b[i * 4 ..][0..4]);
s[i] = mem.readInt(u32, b[i * 4 ..][0..4], .Little);
}
var v: [4]u32 = [_]u32{

6
lib/std/crypto/pcurves/common.zig
View File

@@ -54,7 +54,7 @@ pub fn Field(comptime params: FieldParams) type {
var s = if (endian == .Little) s_ else orderSwap(s_);
const field_order_s = comptime fos: {
var fos: [encoded_length]u8 = undefined;
mem.writeIntLittle(std.meta.Int(.unsigned, encoded_length * 8), &fos, field_order);
mem.writeInt(std.meta.Int(.unsigned, encoded_length * 8), &fos, field_order, .Little);
break :fos fos;
};
if (crypto.utils.timingSafeCompare(u8, &s, &field_order_s, .Little) != .lt) {
@@ -95,14 +95,14 @@ pub fn Field(comptime params: FieldParams) type {
/// Create a field element from an integer.
pub fn fromInt(comptime x: IntRepr) NonCanonicalError!Fe {
var s: [encoded_length]u8 = undefined;
mem.writeIntLittle(IntRepr, &s, x);
mem.writeInt(IntRepr, &s, x, .Little);
return fromBytes(s, .Little);
}
/// Return the field element as an integer.
pub fn toInt(fe: Fe) IntRepr {
const s = fe.toBytes(.Little);
return mem.readIntLittle(IntRepr, &s);
return mem.readInt(IntRepr, &s, .Little);
}
/// Return true if the field element is zero.

10
lib/std/crypto/pcurves/secp256k1.zig
View File

@@ -41,7 +41,7 @@ pub const Secp256k1 = struct {
const lambda_s = s: {
var buf: [32]u8 = undefined;
mem.writeIntLittle(u256, &buf, Endormorphism.lambda);
mem.writeInt(u256, &buf, Endormorphism.lambda, .Little);
break :s buf;
};
@@ -54,12 +54,12 @@ pub const Secp256k1 = struct {
pub fn splitScalar(s: [32]u8, endian: std.builtin.Endian) NonCanonicalError!SplitScalar {
const b1_neg_s = comptime s: {
var buf: [32]u8 = undefined;
mem.writeIntLittle(u256, &buf, 303414439467246543595250775667605759171);
mem.writeInt(u256, &buf, 303414439467246543595250775667605759171, .Little);
break :s buf;
};
const b2_neg_s = comptime s: {
var buf: [32]u8 = undefined;
mem.writeIntLittle(u256, &buf, scalar.field_order - 64502973549206556628585045361533709077);
mem.writeInt(u256, &buf, scalar.field_order - 64502973549206556628585045361533709077, .Little);
break :s buf;
};
const k = mem.readInt(u256, &s, endian);
@@ -72,10 +72,10 @@ pub const Secp256k1 = struct {
var buf: [32]u8 = undefined;
mem.writeIntLittle(u256, &buf, c1);
mem.writeInt(u256, &buf, c1, .Little);
const c1x = try scalar.mul(buf, b1_neg_s, .Little);
mem.writeIntLittle(u256, &buf, c2);
mem.writeInt(u256, &buf, c2, .Little);
const c2x = try scalar.mul(buf, b2_neg_s, .Little);
const r2 = try scalar.add(c1x, c2x, .Little);

16
lib/std/crypto/poly1305.zig
View File

@@ -22,12 +22,12 @@ pub const Poly1305 = struct {
pub fn init(key: *const [key_length]u8) Poly1305 {
return Poly1305{
.r = [_]u64{
mem.readIntLittle(u64, key[0..8]) & 0x0ffffffc0fffffff,
mem.readIntLittle(u64, key[8..16]) & 0x0ffffffc0ffffffc,
mem.readInt(u64, key[0..8], .Little) & 0x0ffffffc0fffffff,
mem.readInt(u64, key[8..16], .Little) & 0x0ffffffc0ffffffc,
},
.pad = [_]u64{
mem.readIntLittle(u64, key[16..24]),
mem.readIntLittle(u64, key[24..32]),
mem.readInt(u64, key[16..24], .Little),
mem.readInt(u64, key[24..32], .Little),
},
};
}
@@ -56,8 +56,8 @@ pub const Poly1305 = struct {
var i: usize = 0;
while (i + block_length <= m.len) : (i += block_length) {
const in0 = mem.readIntLittle(u64, m[i..][0..8]);
const in1 = mem.readIntLittle(u64, m[i + 8 ..][0..8]);
const in0 = mem.readInt(u64, m[i..][0..8], .Little);
const in1 = mem.readInt(u64, m[i + 8 ..][0..8], .Little);
// Add the input message to H
var v = @addWithOverflow(h0, in0);
@@ -182,8 +182,8 @@ pub const Poly1305 = struct {
const c = ((h0 & st.pad[0]) | ((h0 | st.pad[0]) & ~st.h[0])) >> 63;
st.h[1] = h1 +% st.pad[1] +% c;
mem.writeIntLittle(u64, out[0..8], st.h[0]);
mem.writeIntLittle(u64, out[8..16], st.h[1]);
mem.writeInt(u64, out[0..8], st.h[0], .Little);
mem.writeInt(u64, out[8..16], st.h[1], .Little);
utils.secureZero(u8, @as([*]u8, @ptrCast(st))[0..@sizeOf(Poly1305)]);
}

68
lib/std/crypto/salsa20.zig
View File

@@ -29,10 +29,10 @@ fn SalsaVecImpl(comptime rounds: comptime_int) type {
fn initContext(key: [8]u32, d: [4]u32) BlockVec {
const c = "expand 32-byte k";
const constant_le = comptime [4]u32{
mem.readIntLittle(u32, c[0..4]),
mem.readIntLittle(u32, c[4..8]),
mem.readIntLittle(u32, c[8..12]),
mem.readIntLittle(u32, c[12..16]),
mem.readInt(u32, c[0..4], .Little),
mem.readInt(u32, c[4..8], .Little),
mem.readInt(u32, c[8..12], .Little),
mem.readInt(u32, c[12..16], .Little),
};
return BlockVec{
Lane{ key[0], key[1], key[2], key[3] },
@@ -112,10 +112,10 @@ fn SalsaVecImpl(comptime rounds: comptime_int) type {
fn hashToBytes(out: *[64]u8, x: BlockVec) void {
var i: usize = 0;
while (i < 4) : (i += 1) {
mem.writeIntLittle(u32, out[16 * i + 0 ..][0..4], x[i][0]);
mem.writeIntLittle(u32, out[16 * i + 4 ..][0..4], x[i][1]);
mem.writeIntLittle(u32, out[16 * i + 8 ..][0..4], x[i][2]);
mem.writeIntLittle(u32, out[16 * i + 12 ..][0..4], x[i][3]);
mem.writeInt(u32, out[16 * i + 0 ..][0..4], x[i][0], .Little);
mem.writeInt(u32, out[16 * i + 4 ..][0..4], x[i][1], .Little);
mem.writeInt(u32, out[16 * i + 8 ..][0..4], x[i][2], .Little);
mem.writeInt(u32, out[16 * i + 12 ..][0..4], x[i][3], .Little);
}
}
@@ -158,20 +158,20 @@ fn SalsaVecImpl(comptime rounds: comptime_int) type {
fn hsalsa(input: [16]u8, key: [32]u8) [32]u8 {
var c: [4]u32 = undefined;
for (c, 0..) |_, i| {
c[i] = mem.readIntLittle(u32, input[4 * i ..][0..4]);
c[i] = mem.readInt(u32, input[4 * i ..][0..4], .Little);
}
const ctx = initContext(keyToWords(key), c);
var x: BlockVec = undefined;
salsaCore(x[0..], ctx, false);
var out: [32]u8 = undefined;
mem.writeIntLittle(u32, out[0..4], x[0][0]);
mem.writeIntLittle(u32, out[4..8], x[1][1]);
mem.writeIntLittle(u32, out[8..12], x[2][2]);
mem.writeIntLittle(u32, out[12..16], x[3][3]);
mem.writeIntLittle(u32, out[16..20], x[1][2]);
mem.writeIntLittle(u32, out[20..24], x[1][3]);
mem.writeIntLittle(u32, out[24..28], x[2][0]);
mem.writeIntLittle(u32, out[28..32], x[2][1]);
mem.writeInt(u32, out[0..4], x[0][0], .Little);
mem.writeInt(u32, out[4..8], x[1][1], .Little);
mem.writeInt(u32, out[8..12], x[2][2], .Little);
mem.writeInt(u32, out[12..16], x[3][3], .Little);
mem.writeInt(u32, out[16..20], x[1][2], .Little);
mem.writeInt(u32, out[20..24], x[1][3], .Little);
mem.writeInt(u32, out[24..28], x[2][0], .Little);
mem.writeInt(u32, out[28..32], x[2][1], .Little);
return out;
}
};
@@ -184,10 +184,10 @@ fn SalsaNonVecImpl(comptime rounds: comptime_int) type {
fn initContext(key: [8]u32, d: [4]u32) BlockVec {
const c = "expand 32-byte k";
const constant_le = comptime [4]u32{
mem.readIntLittle(u32, c[0..4]),
mem.readIntLittle(u32, c[4..8]),
mem.readIntLittle(u32, c[8..12]),
mem.readIntLittle(u32, c[12..16]),
mem.readInt(u32, c[0..4], .Little),
mem.readInt(u32, c[4..8], .Little),
mem.readInt(u32, c[8..12], .Little),
mem.readInt(u32, c[12..16], .Little),
};
return BlockVec{
constant_le[0], key[0], key[1], key[2],
@@ -241,7 +241,7 @@ fn SalsaNonVecImpl(comptime rounds: comptime_int) type {
fn hashToBytes(out: *[64]u8, x: BlockVec) void {
for (x, 0..) |w, i| {
mem.writeIntLittle(u32, out[i * 4 ..][0..4], w);
mem.writeInt(u32, out[i * 4 ..][0..4], w, .Little);
}
}
@@ -283,20 +283,20 @@ fn SalsaNonVecImpl(comptime rounds: comptime_int) type {
fn hsalsa(input: [16]u8, key: [32]u8) [32]u8 {
var c: [4]u32 = undefined;
for (c, 0..) |_, i| {
c[i] = mem.readIntLittle(u32, input[4 * i ..][0..4]);
c[i] = mem.readInt(u32, input[4 * i ..][0..4], .Little);
}
const ctx = initContext(keyToWords(key), c);
var x: BlockVec = undefined;
salsaCore(x[0..], ctx, false);
var out: [32]u8 = undefined;
mem.writeIntLittle(u32, out[0..4], x[0]);
mem.writeIntLittle(u32, out[4..8], x[5]);
mem.writeIntLittle(u32, out[8..12], x[10]);
mem.writeIntLittle(u32, out[12..16], x[15]);
mem.writeIntLittle(u32, out[16..20], x[6]);
mem.writeIntLittle(u32, out[20..24], x[7]);
mem.writeIntLittle(u32, out[24..28], x[8]);
mem.writeIntLittle(u32, out[28..32], x[9]);
mem.writeInt(u32, out[0..4], x[0], .Little);
mem.writeInt(u32, out[4..8], x[5], .Little);
mem.writeInt(u32, out[8..12], x[10], .Little);
mem.writeInt(u32, out[12..16], x[15], .Little);
mem.writeInt(u32, out[16..20], x[6], .Little);
mem.writeInt(u32, out[20..24], x[7], .Little);
mem.writeInt(u32, out[24..28], x[8], .Little);
mem.writeInt(u32, out[28..32], x[9], .Little);
return out;
}
};
@@ -308,7 +308,7 @@ fn keyToWords(key: [32]u8) [8]u32 {
var k: [8]u32 = undefined;
var i: usize = 0;
while (i < 8) : (i += 1) {
k[i] = mem.readIntLittle(u32, key[i * 4 ..][0..4]);
k[i] = mem.readInt(u32, key[i * 4 ..][0..4], .Little);
}
return k;
}
@@ -335,8 +335,8 @@ pub fn Salsa(comptime rounds: comptime_int) type {
debug.assert(in.len == out.len);
var d: [4]u32 = undefined;
d[0] = mem.readIntLittle(u32, nonce[0..4]);
d[1] = mem.readIntLittle(u32, nonce[4..8]);
d[0] = mem.readInt(u32, nonce[0..4], .Little);
d[1] = mem.readInt(u32, nonce[4..8], .Little);
d[2] = @as(u32, @truncate(counter));
d[3] = @as(u32, @truncate(counter >> 32));
SalsaImpl(rounds).salsaXor(out, in, keyToWords(key), d);

8
lib/std/crypto/scrypt.zig
View File

@@ -91,7 +91,7 @@ fn smix(b: []align(16) u8, r: u30, n: usize, v: []align(16) u32, xy: []align(16)
var y: []align(16) u32 = @alignCast(xy[32 * r ..]);
for (x, 0..) |*v1, j| {
v1.* = mem.readIntSliceLittle(u32, b[4 * j ..]);
v1.* = mem.readInt(u32, b[4 * j ..][0..4], .Little);
}
var tmp: [16]u32 align(16) = undefined;
@@ -116,7 +116,7 @@ fn smix(b: []align(16) u8, r: u30, n: usize, v: []align(16) u32, xy: []align(16)
}
for (x, 0..) |v1, j| {
mem.writeIntLittle(u32, b[4 * j ..][0..4], v1);
mem.writeInt(u32, b[4 * j ..][0..4], v1, .Little);
}
}
@@ -361,7 +361,7 @@ const crypt_format = struct {
std.debug.assert(dst.len == decodedLen(src.len));
var i: usize = 0;
while (i < src.len / 4) : (i += 1) {
mem.writeIntSliceLittle(u24, dst[i * 3 ..], try intDecode(u24, src[i * 4 ..][0..4]));
mem.writeInt(u24, dst[i * 3 ..][0..3], try intDecode(u24, src[i * 4 ..][0..4]), .Little);
}
const leftover = src[i * 4 ..];
var v: u24 = 0;
@@ -377,7 +377,7 @@ const crypt_format = struct {
std.debug.assert(dst.len == encodedLen(src.len));
var i: usize = 0;
while (i < src.len / 3) : (i += 1) {
intEncode(dst[i * 4 ..][0..4], mem.readIntSliceLittle(u24, src[i * 3 ..]));
intEncode(dst[i * 4 ..][0..4], mem.readInt(u24, src[i * 3 ..][0..3], .Little));
}
const leftover = src[i * 3 ..];
var v: u24 = 0;

4
lib/std/crypto/sha1.zig
View File

@@ -111,7 +111,7 @@ pub const Sha1 = struct {
d.round(d.buf[0..]);
for (d.s, 0..) |s, j| {
mem.writeIntBig(u32, out[4 * j ..][0..4], s);
mem.writeInt(u32, out[4 * j ..][0..4], s, .Big);
}
}
@@ -151,7 +151,7 @@ pub const Sha1 = struct {
roundParam(0, 1, 2, 3, 4, 15),
};
inline for (round0a) |r| {
s[r.i] = mem.readIntBig(u32, b[r.i * 4 ..][0..4]);
s[r.i] = mem.readInt(u32, b[r.i * 4 ..][0..4], .Big);
v[r.e] = v[r.e] +% math.rotl(u32, v[r.a], @as(u32, 5)) +% 0x5A827999 +% s[r.i & 0xf] +% ((v[r.b] & v[r.c]) | (~v[r.b] & v[r.d]));
v[r.b] = math.rotl(u32, v[r.b], @as(u32, 30));

8
lib/std/crypto/sha2.zig
View File

@@ -171,7 +171,7 @@ fn Sha2x32(comptime params: Sha2Params32) type {
const rr = d.s[0 .. params.digest_bits / 32];
for (rr, 0..) |s, j| {
mem.writeIntBig(u32, out[4 * j ..][0..4], s);
mem.writeInt(u32, out[4 * j ..][0..4], s, .Big);
}
}
@@ -195,7 +195,7 @@ fn Sha2x32(comptime params: Sha2Params32) type {
fn round(d: *Self, b: *const [64]u8) void {
var s: [64]u32 align(16) = undefined;
for (@as(*align(1) const [16]u32, @ptrCast(b)), 0..) |*elem, i| {
s[i] = mem.readIntBig(u32, mem.asBytes(elem));
s[i] = mem.readInt(u32, mem.asBytes(elem), .Big);
}
if (!@inComptime()) {
@@ -663,7 +663,7 @@ fn Sha2x64(comptime params: Sha2Params64) type {
const rr = d.s[0 .. params.digest_bits / 64];
for (rr, 0..) |s, j| {
mem.writeIntBig(u64, out[8 * j ..][0..8], s);
mem.writeInt(u64, out[8 * j ..][0..8], s, .Big);
}
}
@@ -678,7 +678,7 @@ fn Sha2x64(comptime params: Sha2Params64) type {
var i: usize = 0;
while (i < 16) : (i += 1) {
s[i] = mem.readIntBig(u64, b[i * 8 ..][0..8]);
s[i] = mem.readInt(u64, b[i * 8 ..][0..8], .Big);
}
while (i < 80) : (i += 1) {
s[i] = s[i - 16] +% s[i - 7] +%

8
lib/std/crypto/siphash.zig
View File

@@ -56,8 +56,8 @@ fn SipHashStateless(comptime T: type, comptime c_rounds: usize, comptime d_round
msg_len: u8,
fn init(key: *const [key_length]u8) Self {
const k0 = mem.readIntLittle(u64, key[0..8]);
const k1 = mem.readIntLittle(u64, key[8..16]);
const k0 = mem.readInt(u64, key[0..8], .Little);
const k1 = mem.readInt(u64, key[8..16], .Little);
var d = Self{
.v0 = k0 ^ 0x736f6d6570736575,
@@ -124,7 +124,7 @@ fn SipHashStateless(comptime T: type, comptime c_rounds: usize, comptime d_round
}
fn round(self: *Self, b: [8]u8) void {
const m = mem.readIntLittle(u64, &b);
const m = mem.readInt(u64, &b, .Little);
self.v3 ^= m;
comptime var i: usize = 0;
@@ -213,7 +213,7 @@ fn SipHash(comptime T: type, comptime c_rounds: usize, comptime d_rounds: usize)
/// Return an authentication tag for the current state
/// Assumes `out` is less than or equal to `mac_length`.
pub fn final(self: *Self, out: *[mac_length]u8) void {
mem.writeIntLittle(T, out, self.state.final(self.buf[0..self.buf_len]));
mem.writeInt(T, out, self.state.final(self.buf[0..self.buf_len]), .Little);
}
pub fn finalResult(self: *Self) [mac_length]u8 {

2
lib/std/crypto/tls.zig
View File

@@ -370,7 +370,7 @@ pub fn hkdfExpandLabel(
const max_context_len = 255;
const tls13 = "tls13 ";
var buf: [2 + 1 + tls13.len + max_label_len + 1 + max_context_len]u8 = undefined;
mem.writeIntBig(u16, buf[0..2], len);
mem.writeInt(u16, buf[0..2], len, .Big);
buf[2] = @as(u8, @intCast(tls13.len + label.len));
buf[3..][0..tls13.len].* = tls13.*;
var i: usize = 3 + tls13.len;

6
lib/std/crypto/tls/Client.zig
View File

@@ -1049,10 +1049,10 @@ pub fn readvAdvanced(c: *Client, stream: anytype, iovecs: []const std.os.iovec)
}
const ct: tls.ContentType = @enumFromInt(frag[in]);
in += 1;
const legacy_version = mem.readIntBig(u16, frag[in..][0..2]);
const legacy_version = mem.readInt(u16, frag[in..][0..2], .Big);
in += 2;
_ = legacy_version;
const record_len = mem.readIntBig(u16, frag[in..][0..2]);
const record_len = mem.readInt(u16, frag[in..][0..2], .Big);
if (record_len > max_ciphertext_len) return error.TlsRecordOverflow;
in += 2;
const end = in + record_len;
@@ -1136,7 +1136,7 @@ pub fn readvAdvanced(c: *Client, stream: anytype, iovecs: []const std.os.iovec)
while (true) {
const handshake_type: tls.HandshakeType = @enumFromInt(cleartext[ct_i]);
ct_i += 1;
const handshake_len = mem.readIntBig(u24, cleartext[ct_i..][0..3]);
const handshake_len = mem.readInt(u24, cleartext[ct_i..][0..3], .Big);
ct_i += 3;
const next_handshake_i = ct_i + handshake_len;
if (next_handshake_i > cleartext.len - 1)

10
lib/std/debug.zig
View File

@@ -1135,8 +1135,8 @@ pub fn readElfDebugInfo(
const gnu_debuglink = try chopSlice(mapped_mem, shdr.sh_offset, shdr.sh_size);
const debug_filename = mem.sliceTo(@as([*:0]const u8, @ptrCast(gnu_debuglink.ptr)), 0);
const crc_offset = mem.alignForward(usize, @intFromPtr(&debug_filename[debug_filename.len]) + 1, 4) - @intFromPtr(gnu_debuglink.ptr);
const crc_bytes = gnu_debuglink[crc_offset .. crc_offset + 4];
separate_debug_crc = mem.readIntSliceNative(u32, crc_bytes);
const crc_bytes = gnu_debuglink[crc_offset..][0..4];
separate_debug_crc = mem.readInt(u32, crc_bytes, native_endian);
separate_debug_filename = debug_filename;
continue;
}
@@ -1868,10 +1868,10 @@ pub const DebugInfo = struct {
elf.PT_NOTE => {
// Look for .note.gnu.build-id
const note_bytes = @as([*]const u8, @ptrFromInt(info.dlpi_addr + phdr.p_vaddr))[0..phdr.p_memsz];
const name_size = mem.readIntSliceNative(u32, note_bytes[0..4]);
const name_size = mem.readInt(u32, note_bytes[0..4], native_endian);
if (name_size != 4) continue;
const desc_size = mem.readIntSliceNative(u32, note_bytes[4..8]);
const note_type = mem.readIntSliceNative(u32, note_bytes[8..12]);
const desc_size = mem.readInt(u32, note_bytes[4..8], native_endian);
const note_type = mem.readInt(u32, note_bytes[8..12], native_endian);
if (note_type != elf.NT_GNU_BUILD_ID) continue;
if (!mem.eql(u8, "GNU\x00", note_bytes[12..16])) continue;
context.build_id = note_bytes[16..][0..desc_size];

7
lib/std/dwarf.zig
View File

@@ -7,6 +7,7 @@ const mem = std.mem;
const math = std.math;
const leb = @import("leb128.zig");
const assert = std.debug.assert;
const native_endian = builtin.cpu.arch.endian();
pub const TAG = @import("dwarf/TAG.zig");
pub const AT = @import("dwarf/AT.zig");
@@ -1741,7 +1742,7 @@ pub const DwarfInfo = struct {
context.cfa = switch (row.cfa.rule) {
.val_offset => |offset| blk: {
const register = row.cfa.register orelse return error.InvalidCFARule;
const value = mem.readIntSliceNative(usize, try abi.regBytes(context.thread_context, register, context.reg_context));
const value = mem.readInt(usize, (try abi.regBytes(context.thread_context, register, context.reg_context))[0..@sizeOf(usize)], native_endian);
break :blk try call_frame.applyOffset(value, offset);
},
.expression => |expression| blk: {
@@ -1814,11 +1815,11 @@ pub const DwarfInfo = struct {
}
if (has_return_address) {
context.pc = abi.stripInstructionPtrAuthCode(mem.readIntSliceNative(usize, try abi.regBytes(
context.pc = abi.stripInstructionPtrAuthCode(mem.readInt(usize, (try abi.regBytes(
context.thread_context,
cie.return_address_register,
context.reg_context,
)));
))[0..@sizeOf(usize)], native_endian));
} else {
context.pc = 0;
}

9
lib/std/dwarf/call_frame.zig
View File

@@ -7,6 +7,7 @@ const dwarf = std.dwarf;
const abi = dwarf.abi;
const expressions = dwarf.expressions;
const assert = std.debug.assert;
const native_endian = builtin.cpu.arch.endian();
const Opcode = enum(u8) {
advance_loc = 0x1 << 6,
@@ -386,12 +387,12 @@ pub const VirtualMachine = struct {
const addr = try applyOffset(cfa, offset);
if (expression_context.isValidMemory) |isValidMemory| if (!isValidMemory(addr)) return error.InvalidAddress;
const ptr: *const usize = @ptrFromInt(addr);
mem.writeIntSliceNative(usize, out, ptr.*);
mem.writeInt(usize, out[0..@sizeOf(usize)], ptr.*, native_endian);
} else return error.InvalidCFA;
},
.val_offset => |offset| {
if (context.cfa) |cfa| {
mem.writeIntSliceNative(usize, out, try applyOffset(cfa, offset));
mem.writeInt(usize, out[0..@sizeOf(usize)], try applyOffset(cfa, offset), native_endian);
} else return error.InvalidCFA;
},
.register => |register| {
@@ -409,14 +410,14 @@ pub const VirtualMachine = struct {
if (!context.isValidMemory(addr)) return error.InvalidExpressionAddress;
const ptr: *usize = @ptrFromInt(addr);
mem.writeIntSliceNative(usize, out, ptr.*);
mem.writeInt(usize, out[0..@sizeOf(usize)], ptr.*, native_endian);
},
.val_expression => |expression| {
context.stack_machine.reset();
const value = try context.stack_machine.run(expression, context.allocator, expression_context, context.cfa.?);
if (value) |v| {
if (v != .generic) return error.InvalidExpressionValue;
mem.writeIntSliceNative(usize, out, v.generic);
mem.writeInt(usize, out[0..@sizeOf(usize)], v.generic, native_endian);
} else return error.NoExpressionValue;
},
.architectural => return error.UnimplementedRegisterRule,

33
lib/std/dwarf/expressions.zig
View File

@@ -6,6 +6,7 @@ const dwarf = std.dwarf;
const abi = dwarf.abi;
const mem = std.mem;
const assert = std.debug.assert;
const native_endian = builtin.cpu.arch.endian();
/// Expressions can be evaluated in different contexts, each requiring its own set of inputs.
/// Callers should specify all the fields relevant to their context. If a field is required
@@ -147,10 +148,10 @@ pub fn StackMachine(comptime options: ExpressionOptions) type {
.regval_type => |regval_type| regval_type.value,
.const_type => |const_type| {
const value: u64 = switch (const_type.value_bytes.len) {
1 => mem.readIntSliceNative(u8, const_type.value_bytes),
2 => mem.readIntSliceNative(u16, const_type.value_bytes),
4 => mem.readIntSliceNative(u32, const_type.value_bytes),
8 => mem.readIntSliceNative(u64, const_type.value_bytes),
1 => mem.readInt(u8, const_type.value_bytes[0..1], native_endian),
2 => mem.readInt(u16, const_type.value_bytes[0..2], native_endian),
4 => mem.readInt(u32, const_type.value_bytes[0..4], native_endian),
8 => mem.readInt(u64, const_type.value_bytes[0..8], native_endian),
else => return error.InvalidIntegralTypeSize,
};
@@ -352,7 +353,7 @@ pub fn StackMachine(comptime options: ExpressionOptions) type {
const debug_addr_index = operand.?.generic;
const offset = context.compile_unit.?.addr_base + debug_addr_index;
if (offset >= context.debug_addr.?.len) return error.InvalidExpression;
const value = mem.readIntSliceNative(usize, context.debug_addr.?[offset..][0..@sizeOf(usize)]);
const value = mem.readInt(usize, context.debug_addr.?[offset..][0..@sizeOf(usize)], native_endian);
try self.stack.append(allocator, .{ .generic = value });
},
@@ -386,21 +387,21 @@ pub fn StackMachine(comptime options: ExpressionOptions) type {
if (context.thread_context == null) return error.IncompleteExpressionContext;
const base_register = operand.?.base_register;
var value: i64 = @intCast(mem.readIntSliceNative(usize, try abi.regBytes(
var value: i64 = @intCast(mem.readInt(usize, (try abi.regBytes(
context.thread_context.?,
base_register.base_register,
context.reg_context,
)));
))[0..@sizeOf(usize)], native_endian));
value += base_register.offset;
try self.stack.append(allocator, .{ .generic = @intCast(value) });
},
OP.regval_type => {
const register_type = operand.?.register_type;
const value = mem.readIntSliceNative(usize, try abi.regBytes(
const value = mem.readInt(usize, (try abi.regBytes(
context.thread_context.?,
register_type.register,
context.reg_context,
));
))[0..@sizeOf(usize)], native_endian);
try self.stack.append(allocator, .{
.regval_type = .{
.type_offset = register_type.type_offset,
@@ -756,7 +757,7 @@ pub fn StackMachine(comptime options: ExpressionOptions) type {
var block_stream = std.io.fixedBufferStream(block);
const register = (try readOperand(&block_stream, block[0], context)).?.register;
const value = mem.readIntSliceNative(usize, try abi.regBytes(context.thread_context.?, register, context.reg_context));
const value = mem.readInt(usize, (try abi.regBytes(context.thread_context.?, register, context.reg_context))[0..@sizeOf(usize)], native_endian);
try self.stack.append(allocator, .{ .generic = value });
} else {
var stack_machine: Self = .{};
@@ -1121,9 +1122,9 @@ test "DWARF expressions" {
var mock_debug_addr = std.ArrayList(u8).init(allocator);
defer mock_debug_addr.deinit();
try mock_debug_addr.writer().writeIntNative(u16, 0);
try mock_debug_addr.writer().writeIntNative(usize, input[11]);
try mock_debug_addr.writer().writeIntNative(usize, input[12]);
try mock_debug_addr.writer().writeInt(u16, 0, native_endian);
try mock_debug_addr.writer().writeInt(usize, input[11], native_endian);
try mock_debug_addr.writer().writeInt(usize, input[12], native_endian);
const context = ExpressionContext{
.compile_unit = &mock_compile_unit,
@@ -1185,7 +1186,7 @@ test "DWARF expressions" {
// TODO: Test fbreg (once implemented): mock a DIE and point compile_unit.frame_base at it
mem.writeIntSliceNative(usize, reg_bytes, 0xee);
mem.writeInt(usize, reg_bytes[0..@sizeOf(usize)], 0xee, native_endian);
(try abi.regValueNative(usize, &thread_context, abi.fpRegNum(reg_context), reg_context)).* = 1;
(try abi.regValueNative(usize, &thread_context, abi.spRegNum(reg_context), reg_context)).* = 2;
(try abi.regValueNative(usize, &thread_context, abi.ipRegNum(), reg_context)).* = 3;
@@ -1538,7 +1539,7 @@ test "DWARF expressions" {
const value: usize = @truncate(0xffeeffee_ffeeffee);
var value_bytes: [options.addr_size]u8 = undefined;
mem.writeIntSliceNative(usize, &value_bytes, value);
mem.writeInt(usize, &value_bytes, value, native_endian);
// Convert to generic type
stack_machine.reset();
@@ -1613,7 +1614,7 @@ test "DWARF expressions" {
};
if (abi.regBytes(&thread_context, 0, reg_context)) |reg_bytes| {
mem.writeIntSliceNative(usize, reg_bytes, 0xee);
mem.writeInt(usize, reg_bytes[0..@sizeOf(usize)], 0xee, native_endian);
var sub_program = std.ArrayList(u8).init(allocator);
defer sub_program.deinit();

2
lib/std/fmt/parse_float/FloatStream.zig
View File

@@ -98,7 +98,7 @@ pub fn skipChars2(self: *FloatStream, c1: u8, c2: u8) void {
}
pub fn readU64Unchecked(self: FloatStream) u64 {
return std.mem.readIntSliceLittle(u64, self.slice[self.offset..]);
return std.mem.readInt(u64, self.slice[self.offset..][0..8], .Little);
}
pub fn readU64(self: FloatStream) ?u64 {

2
lib/std/fmt/parse_float/decimal.zig
View File

@@ -260,7 +260,7 @@ pub fn Decimal(comptime T: type) type {
if (!isEightDigits(v)) {
break;
}
std.mem.writeIntSliceLittle(u64, d.digits[d.num_digits..], v - 0x3030_3030_3030_3030);
std.mem.writeInt(u64, d.digits[d.num_digits..][0..8], v - 0x3030_3030_3030_3030, .Little);
d.num_digits += 8;
stream.advance(8);
}

4
lib/std/hash/cityhash.zig
View File

@@ -6,11 +6,11 @@ inline fn offsetPtr(ptr: [*]const u8, offset: usize) [*]const u8 {
}
fn fetch32(ptr: [*]const u8, offset: usize) u32 {
return std.mem.readIntLittle(u32, offsetPtr(ptr, offset)[0..4]);
return std.mem.readInt(u32, offsetPtr(ptr, offset)[0..4], .Little);
}
fn fetch64(ptr: [*]const u8, offset: usize) u64 {
return std.mem.readIntLittle(u64, offsetPtr(ptr, offset)[0..8]);
return std.mem.readInt(u64, offsetPtr(ptr, offset)[0..8], .Little);
}
pub const CityHash32 = struct {

2
lib/std/hash/crc.zig
View File

@@ -163,7 +163,7 @@ pub fn Crc32WithPoly(comptime poly: Polynomial) type {
const p = input[i..][0..8];
// Unrolling this way gives ~50Mb/s increase
self.crc ^= std.mem.readIntLittle(u32, p[0..4]);
self.crc ^= std.mem.readInt(u32, p[0..4], .Little);
self.crc =
lookup_tables[0][p[7]] ^

2
lib/std/hash/verify.zig
View File

@@ -37,7 +37,7 @@ pub fn smhasher(comptime hash_fn: anytype) u32 {
for (0..256) |i| {
buf[i] = @intCast(i);
const h = hashMaybeSeed(hash_fn, 256 - i, buf[0..i]);
std.mem.writeIntLittle(HashResult, buf_all[i * hash_size ..][0..hash_size], h);
std.mem.writeInt(HashResult, buf_all[i * hash_size ..][0..hash_size], h, .Little);
}
return @truncate(hashMaybeSeed(hash_fn, 0, buf_all[0..]));

2
lib/std/hash/wyhash.zig
View File

@@ -131,7 +131,7 @@ pub const Wyhash = struct {
inline fn read(comptime bytes: usize, data: []const u8) u64 {
std.debug.assert(bytes <= 8);
const T = std.meta.Int(.unsigned, 8 * bytes);
return @as(u64, std.mem.readIntLittle(T, data[0..bytes]));
return @as(u64, std.mem.readInt(T, data[0..bytes], .Little));
}
inline fn mum(a: *u64, b: *u64) void {

22
lib/std/hash/xxhash.zig
View File

@@ -53,10 +53,10 @@ pub const XxHash64 = struct {
}
fn processStripe(self: *Accumulator, buf: *const [32]u8) void {
self.acc1 = round(self.acc1, mem.readIntLittle(u64, buf[0..8]));
self.acc2 = round(self.acc2, mem.readIntLittle(u64, buf[8..16]));
self.acc3 = round(self.acc3, mem.readIntLittle(u64, buf[16..24]));
self.acc4 = round(self.acc4, mem.readIntLittle(u64, buf[24..32]));
self.acc1 = round(self.acc1, mem.readInt(u64, buf[0..8], .Little));
self.acc2 = round(self.acc2, mem.readInt(u64, buf[8..16], .Little));
self.acc3 = round(self.acc3, mem.readInt(u64, buf[16..24], .Little));
self.acc4 = round(self.acc4, mem.readInt(u64, buf[24..32], .Little));
}
fn merge(self: Accumulator) u64 {
@@ -139,7 +139,7 @@ pub const XxHash64 = struct {
fn finalize8(v: u64, bytes: *const [8]u8) u64 {
var acc = v;
const lane = mem.readIntLittle(u64, bytes);
const lane = mem.readInt(u64, bytes, .Little);
acc ^= round(0, lane);
acc = rotl(u64, acc, 27) *% prime_1;
acc +%= prime_4;
@@ -148,7 +148,7 @@ pub const XxHash64 = struct {
fn finalize4(v: u64, bytes: *const [4]u8) u64 {
var acc = v;
const lane = @as(u64, mem.readIntLittle(u32, bytes));
const lane = @as(u64, mem.readInt(u32, bytes, .Little));
acc ^= lane *% prime_1;
acc = rotl(u64, acc, 23) *% prime_2;
acc +%= prime_3;
@@ -291,10 +291,10 @@ pub const XxHash32 = struct {
}
fn processStripe(self: *Accumulator, buf: *const [16]u8) void {
self.acc1 = round(self.acc1, mem.readIntLittle(u32, buf[0..4]));
self.acc2 = round(self.acc2, mem.readIntLittle(u32, buf[4..8]));
self.acc3 = round(self.acc3, mem.readIntLittle(u32, buf[8..12]));
self.acc4 = round(self.acc4, mem.readIntLittle(u32, buf[12..16]));
self.acc1 = round(self.acc1, mem.readInt(u32, buf[0..4], .Little));
self.acc2 = round(self.acc2, mem.readInt(u32, buf[4..8], .Little));
self.acc3 = round(self.acc3, mem.readInt(u32, buf[8..12], .Little));
self.acc4 = round(self.acc4, mem.readInt(u32, buf[12..16], .Little));
}
fn merge(self: Accumulator) u32 {
@@ -390,7 +390,7 @@ pub const XxHash32 = struct {
fn finalize4(v: u32, bytes: *const [4]u8) u32 {
var acc = v;
const lane = mem.readIntLittle(u32, bytes);
const lane = mem.readInt(u32, bytes, .Little);
acc +%= lane *% prime_3;
acc = rotl(u32, acc, 17) *% prime_4;
return acc;

16
lib/std/io.zig
View File

@@ -269,22 +269,6 @@ pub fn GenericReader(
return @errorCast(self.any().readBoundedBytes(num_bytes));
}
pub inline fn readIntNative(self: Self, comptime T: type) NoEofError!T {
return @errorCast(self.any().readIntNative(T));
}
pub inline fn readIntForeign(self: Self, comptime T: type) NoEofError!T {
return @errorCast(self.any().readIntForeign(T));
}
pub inline fn readIntLittle(self: Self, comptime T: type) NoEofError!T {
return @errorCast(self.any().readIntLittle(T));
}
pub inline fn readIntBig(self: Self, comptime T: type) NoEofError!T {
return @errorCast(self.any().readIntBig(T));
}
pub inline fn readInt(self: Self, comptime T: type, endian: std.builtin.Endian) NoEofError!T {
return @errorCast(self.any().readInt(T, endian));
}

26
lib/std/io/Reader.zig
View File

@@ -276,30 +276,8 @@ pub fn readBoundedBytes(self: Self, comptime num_bytes: usize) anyerror!std.Boun
return result;
}
/// Reads a native-endian integer
pub fn readIntNative(self: Self, comptime T: type) anyerror!T {
const bytes = try self.readBytesNoEof(@as(u16, @intCast((@as(u17, @typeInfo(T).Int.bits) + 7) / 8)));
return mem.readIntNative(T, &bytes);
}
/// Reads a foreign-endian integer
pub fn readIntForeign(self: Self, comptime T: type) anyerror!T {
const bytes = try self.readBytesNoEof(@as(u16, @intCast((@as(u17, @typeInfo(T).Int.bits) + 7) / 8)));
return mem.readIntForeign(T, &bytes);
}
pub fn readIntLittle(self: Self, comptime T: type) anyerror!T {
const bytes = try self.readBytesNoEof(@as(u16, @intCast((@as(u17, @typeInfo(T).Int.bits) + 7) / 8)));
return mem.readIntLittle(T, &bytes);
}
pub fn readIntBig(self: Self, comptime T: type) anyerror!T {
const bytes = try self.readBytesNoEof(@as(u16, @intCast((@as(u17, @typeInfo(T).Int.bits) + 7) / 8)));
return mem.readIntBig(T, &bytes);
}
pub fn readInt(self: Self, comptime T: type, endian: std.builtin.Endian) anyerror!T {
const bytes = try self.readBytesNoEof(@as(u16, @intCast((@as(u17, @typeInfo(T).Int.bits) + 7) / 8)));
pub inline fn readInt(self: Self, comptime T: type, endian: std.builtin.Endian) anyerror!T {
const bytes = try self.readBytesNoEof(@divExact(@typeInfo(T).Int.bits, 8));
return mem.readInt(T, &bytes, endian);
}

30
lib/std/io/writer.zig
View File

@@ -45,34 +45,8 @@ pub fn Writer(
}
}
/// Write a native-endian integer.
pub fn writeIntNative(self: Self, comptime T: type, value: T) Error!void {
var bytes: [@as(u16, @intCast((@as(u17, @typeInfo(T).Int.bits) + 7) / 8))]u8 = undefined;
mem.writeIntNative(std.math.ByteAlignedInt(@TypeOf(value)), &bytes, value);
return self.writeAll(&bytes);
}
/// Write a foreign-endian integer.
pub fn writeIntForeign(self: Self, comptime T: type, value: T) Error!void {
var bytes: [@as(u16, @intCast((@as(u17, @typeInfo(T).Int.bits) + 7) / 8))]u8 = undefined;
mem.writeIntForeign(std.math.ByteAlignedInt(@TypeOf(value)), &bytes, value);
return self.writeAll(&bytes);
}
pub fn writeIntLittle(self: Self, comptime T: type, value: T) Error!void {
var bytes: [@as(u16, @intCast((@as(u17, @typeInfo(T).Int.bits) + 7) / 8))]u8 = undefined;
mem.writeIntLittle(std.math.ByteAlignedInt(@TypeOf(value)), &bytes, value);
return self.writeAll(&bytes);
}
pub fn writeIntBig(self: Self, comptime T: type, value: T) Error!void {
var bytes: [@as(u16, @intCast((@as(u17, @typeInfo(T).Int.bits) + 7) / 8))]u8 = undefined;
mem.writeIntBig(std.math.ByteAlignedInt(@TypeOf(value)), &bytes, value);
return self.writeAll(&bytes);
}
pub fn writeInt(self: Self, comptime T: type, value: T, endian: std.builtin.Endian) Error!void {
var bytes: [@as(u16, @intCast((@as(u17, @typeInfo(T).Int.bits) + 7) / 8))]u8 = undefined;
pub inline fn writeInt(self: Self, comptime T: type, value: T, endian: std.builtin.Endian) Error!void {
var bytes: [@divExact(@typeInfo(T).Int.bits, 8)]u8 = undefined;
mem.writeInt(std.math.ByteAlignedInt(@TypeOf(value)), &bytes, value, endian);
return self.writeAll(&bytes);
}

643
lib/std/mem.zig
View File

@@ -1587,68 +1587,40 @@ pub fn readVarPackedInt(
/// Reads an integer from memory with bit count specified by T.
/// The bit count of T must be evenly divisible by 8.
/// This function cannot fail and cannot cause undefined behavior.
/// Assumes the endianness of memory is native. This means the function can
/// simply pointer cast memory.
pub fn readIntNative(comptime T: type, bytes: *const [@divExact(@typeInfo(T).Int.bits, 8)]u8) T {
return @as(*align(1) const T, @ptrCast(bytes)).*;
pub inline fn readInt(comptime T: type, buffer: *const [@divExact(@typeInfo(T).Int.bits, 8)]u8, endian: Endian) T {
const value: T = @bitCast(buffer.*);
return if (endian == native_endian) value else @byteSwap(value);
}
/// Reads an integer from memory with bit count specified by T.
/// The bit count of T must be evenly divisible by 8.
/// This function cannot fail and cannot cause undefined behavior.
/// Assumes the endianness of memory is foreign, so it must byte-swap.
pub fn readIntForeign(comptime T: type, bytes: *const [@divExact(@typeInfo(T).Int.bits, 8)]u8) T {
return @byteSwap(readIntNative(T, bytes));
test readInt {
try testing.expect(readInt(u0, &[_]u8{}, .Big) == 0x0);
try testing.expect(readInt(u0, &[_]u8{}, .Little) == 0x0);
try testing.expect(readInt(u8, &[_]u8{0x32}, .Big) == 0x32);
try testing.expect(readInt(u8, &[_]u8{0x12}, .Little) == 0x12);
try testing.expect(readInt(u16, &[_]u8{ 0x12, 0x34 }, .Big) == 0x1234);
try testing.expect(readInt(u16, &[_]u8{ 0x12, 0x34 }, .Little) == 0x3412);
try testing.expect(readInt(u72, &[_]u8{ 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x24 }, .Big) == 0x123456789abcdef024);
try testing.expect(readInt(u72, &[_]u8{ 0xec, 0x10, 0x32, 0x54, 0x76, 0x98, 0xba, 0xdc, 0xfe }, .Little) == 0xfedcba9876543210ec);
try testing.expect(readInt(i8, &[_]u8{0xff}, .Big) == -1);
try testing.expect(readInt(i8, &[_]u8{0xfe}, .Little) == -2);
try testing.expect(readInt(i16, &[_]u8{ 0xff, 0xfd }, .Big) == -3);
try testing.expect(readInt(i16, &[_]u8{ 0xfc, 0xff }, .Little) == -4);
}
pub const readIntLittle = switch (native_endian) {
.Little => readIntNative,
.Big => readIntForeign,
};
pub const readIntBig = switch (native_endian) {
.Little => readIntForeign,
.Big => readIntNative,
};
/// Asserts that bytes.len >= @typeInfo(T).Int.bits / 8. Reads the integer starting from index 0
/// Asserts that buffer.len >= @typeInfo(T).Int.bits / 8. Reads the integer starting from index 0
/// and ignores extra bytes.
/// The bit count of T must be evenly divisible by 8.
/// Assumes the endianness of memory is native. This means the function can
/// simply pointer cast memory.
pub fn readIntSliceNative(comptime T: type, bytes: []const u8) T {
const n = @divExact(@typeInfo(T).Int.bits, 8);
assert(bytes.len >= n);
return readIntNative(T, bytes[0..n]);
}
/// Asserts that bytes.len >= @typeInfo(T).Int.bits / 8. Reads the integer starting from index 0
/// and ignores extra bytes.
/// The bit count of T must be evenly divisible by 8.
/// Assumes the endianness of memory is foreign, so it must byte-swap.
pub fn readIntSliceForeign(comptime T: type, bytes: []const u8) T {
return @byteSwap(readIntSliceNative(T, bytes));
}
pub const readIntSliceLittle = switch (native_endian) {
.Little => readIntSliceNative,
.Big => readIntSliceForeign,
};
pub const readIntSliceBig = switch (native_endian) {
.Little => readIntSliceForeign,
.Big => readIntSliceNative,
};
/// Reads an integer from memory with bit count specified by T.
/// The bit count of T must be evenly divisible by 8.
/// This function cannot fail and cannot cause undefined behavior.
pub fn readInt(comptime T: type, bytes: *const [@divExact(@typeInfo(T).Int.bits, 8)]u8, endian: Endian) T {
if (endian == native_endian) {
return readIntNative(T, bytes);
} else {
return readIntForeign(T, bytes);
}
pub inline fn readIntSlice(comptime T: type, buffer: []const u8, endian: Endian) T {
const byte_len = @divExact(@typeInfo(T).Int.bits, 8);
return switch (endian) {
.Little => readInt(T, buffer[0..byte_len], endian),
.Big => readInt(T, buffer[buffer.len - byte_len ..], endian),
};
}
fn readPackedIntLittle(comptime T: type, bytes: []const u8, bit_offset: usize) T {
@@ -1668,7 +1640,7 @@ fn readPackedIntLittle(comptime T: type, bytes: []const u8, bit_offset: usize) T
// Read by loading a LoadInt, and then follow it up with a 1-byte read
// of the tail if bit_offset pushed us over a byte boundary.
const read_bytes = bytes[bit_offset / 8 ..];
const val = @as(uN, @truncate(readIntLittle(LoadInt, read_bytes[0..load_size]) >> bit_shift));
const val = @as(uN, @truncate(readInt(LoadInt, read_bytes[0..load_size], .Little) >> bit_shift));
if (bit_shift > load_tail_bits) {
const tail_bits = @as(Log2N, @intCast(bit_shift - load_tail_bits));
const tail_byte = read_bytes[load_size];
@@ -1696,7 +1668,7 @@ fn readPackedIntBig(comptime T: type, bytes: []const u8, bit_offset: usize) T {
// of the tail if bit_offset pushed us over a byte boundary.
const end = bytes.len - (bit_offset / 8);
const read_bytes = bytes[(end - byte_count)..end];
const val = @as(uN, @truncate(readIntBig(LoadInt, bytes[(end - load_size)..end][0..load_size]) >> bit_shift));
const val = @as(uN, @truncate(readInt(LoadInt, bytes[(end - load_size)..end][0..load_size], .Big) >> bit_shift));
if (bit_shift > load_tail_bits) {
const tail_bits = @as(Log2N, @intCast(bit_shift - load_tail_bits));
const tail_byte = if (bit_count < 8) @as(uN, @truncate(read_bytes[0])) else @as(uN, read_bytes[0]);
@@ -1729,91 +1701,225 @@ pub fn readPackedInt(comptime T: type, bytes: []const u8, bit_offset: usize, end
}
}
/// Asserts that bytes.len >= @typeInfo(T).Int.bits / 8. Reads the integer starting from index 0
/// and ignores extra bytes.
/// The bit count of T must be evenly divisible by 8.
pub fn readIntSlice(comptime T: type, bytes: []const u8, endian: Endian) T {
const n = @divExact(@typeInfo(T).Int.bits, 8);
assert(bytes.len >= n);
return readInt(T, bytes[0..n], endian);
}
test "comptime read/write int" {
comptime {
var bytes: [2]u8 = undefined;
writeIntLittle(u16, &bytes, 0x1234);
const result = readIntBig(u16, &bytes);
writeInt(u16, &bytes, 0x1234, .Little);
const result = readInt(u16, &bytes, .Big);
try testing.expect(result == 0x3412);
}
comptime {
var bytes: [2]u8 = undefined;
writeIntBig(u16, &bytes, 0x1234);
const result = readIntLittle(u16, &bytes);
writeInt(u16, &bytes, 0x1234, .Big);
const result = readInt(u16, &bytes, .Little);
try testing.expect(result == 0x3412);
}
}
test "readIntBig and readIntLittle" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
try testing.expect(readIntSliceBig(u0, &[_]u8{}) == 0x0);
try testing.expect(readIntSliceLittle(u0, &[_]u8{}) == 0x0);
try testing.expect(readIntSliceBig(u8, &[_]u8{0x32}) == 0x32);
try testing.expect(readIntSliceLittle(u8, &[_]u8{0x12}) == 0x12);
try testing.expect(readIntSliceBig(u16, &[_]u8{ 0x12, 0x34 }) == 0x1234);
try testing.expect(readIntSliceLittle(u16, &[_]u8{ 0x12, 0x34 }) == 0x3412);
try testing.expect(readIntSliceBig(u72, &[_]u8{ 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x24 }) == 0x123456789abcdef024);
try testing.expect(readIntSliceLittle(u72, &[_]u8{ 0xec, 0x10, 0x32, 0x54, 0x76, 0x98, 0xba, 0xdc, 0xfe }) == 0xfedcba9876543210ec);
try testing.expect(readIntSliceBig(i8, &[_]u8{0xff}) == -1);
try testing.expect(readIntSliceLittle(i8, &[_]u8{0xfe}) == -2);
try testing.expect(readIntSliceBig(i16, &[_]u8{ 0xff, 0xfd }) == -3);
try testing.expect(readIntSliceLittle(i16, &[_]u8{ 0xfc, 0xff }) == -4);
}
/// Writes an integer to memory, storing it in twos-complement.
/// This function always succeeds, has defined behavior for all inputs, and
/// accepts any integer bit width.
/// This function stores in native endian, which means it is implemented as a simple
/// memory store.
pub fn writeIntNative(comptime T: type, buf: *[@as(u16, @intCast((@as(u17, @typeInfo(T).Int.bits) + 7) / 8))]u8, value: T) void {
@as(*align(1) T, @ptrCast(buf)).* = value;
}
/// Writes an integer to memory, storing it in twos-complement.
/// This function always succeeds, has defined behavior for all inputs, but
/// the integer bit width must be divisible by 8.
/// This function stores in foreign endian, which means it does a @byteSwap first.
pub fn writeIntForeign(comptime T: type, buf: *[@divExact(@typeInfo(T).Int.bits, 8)]u8, value: T) void {
writeIntNative(T, buf, @byteSwap(value));
pub inline fn writeInt(comptime T: type, buffer: *[@divExact(@typeInfo(T).Int.bits, 8)]u8, value: T, endian: Endian) void {
buffer.* = @bitCast(if (endian == native_endian) value else @byteSwap(value));
}
pub const writeIntLittle = switch (native_endian) {
.Little => writeIntNative,
.Big => writeIntForeign,
};
test writeInt {
var buf0: [0]u8 = undefined;
var buf1: [1]u8 = undefined;
var buf2: [2]u8 = undefined;
var buf9: [9]u8 = undefined;
pub const writeIntBig = switch (native_endian) {
.Little => writeIntForeign,
.Big => writeIntNative,
};
writeInt(u0, &buf0, 0x0, .Big);
try testing.expect(eql(u8, buf0[0..], &[_]u8{}));
writeInt(u0, &buf0, 0x0, .Little);
try testing.expect(eql(u8, buf0[0..], &[_]u8{}));
/// Writes an integer to memory, storing it in twos-complement.
/// This function always succeeds, has defined behavior for all inputs, but
/// the integer bit width must be divisible by 8.
pub fn writeInt(comptime T: type, buffer: *[@divExact(@typeInfo(T).Int.bits, 8)]u8, value: T, endian: Endian) void {
if (endian == native_endian) {
return writeIntNative(T, buffer, value);
} else {
return writeIntForeign(T, buffer, value);
writeInt(u8, &buf1, 0x12, .Big);
try testing.expect(eql(u8, buf1[0..], &[_]u8{0x12}));
writeInt(u8, &buf1, 0x34, .Little);
try testing.expect(eql(u8, buf1[0..], &[_]u8{0x34}));
writeInt(u16, &buf2, 0x1234, .Big);
try testing.expect(eql(u8, buf2[0..], &[_]u8{ 0x12, 0x34 }));
writeInt(u16, &buf2, 0x5678, .Little);
try testing.expect(eql(u8, buf2[0..], &[_]u8{ 0x78, 0x56 }));
writeInt(u72, &buf9, 0x123456789abcdef024, .Big);
try testing.expect(eql(u8, buf9[0..], &[_]u8{ 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x24 }));
writeInt(u72, &buf9, 0xfedcba9876543210ec, .Little);
try testing.expect(eql(u8, buf9[0..], &[_]u8{ 0xec, 0x10, 0x32, 0x54, 0x76, 0x98, 0xba, 0xdc, 0xfe }));
writeInt(i8, &buf1, -1, .Big);
try testing.expect(eql(u8, buf1[0..], &[_]u8{0xff}));
writeInt(i8, &buf1, -2, .Little);
try testing.expect(eql(u8, buf1[0..], &[_]u8{0xfe}));
writeInt(i16, &buf2, -3, .Big);
try testing.expect(eql(u8, buf2[0..], &[_]u8{ 0xff, 0xfd }));
writeInt(i16, &buf2, -4, .Little);
try testing.expect(eql(u8, buf2[0..], &[_]u8{ 0xfc, 0xff }));
}
/// Writes a twos-complement integer to memory, with the specified endianness.
/// Asserts that buf.len >= @typeInfo(T).Int.bits / 8.
/// The bit count of T must be evenly divisible by 8.
/// Any extra bytes in buffer not part of the integer are set to zero, with
/// respect to endianness. To avoid the branch to check for extra buffer bytes,
/// use writeInt instead.
pub inline fn writeIntSlice(comptime T: type, buffer: []u8, value: T, endian: Endian) void {
const byte_len = @divExact(@typeInfo(T).Int.bits, 8);
switch (endian) {
.Little => {
writeInt(T, buffer[0..byte_len], value, endian);
@memset(buffer[byte_len..], 0);
},
.Big => {
@memset(buffer[0 .. buffer.len - byte_len], 0);
writeInt(T, buffer[buffer.len - byte_len ..][0..byte_len], value, endian);
},
}
}
test writeIntSlice {
try testWriteIntImpl();
try comptime testWriteIntImpl();
}
fn testWriteIntImpl() !void {
var bytes: [8]u8 = undefined;
writeIntSlice(u0, bytes[0..], 0, .Big);
try testing.expect(eql(u8, &bytes, &[_]u8{
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
}));
writeIntSlice(u0, bytes[0..], 0, .Little);
try testing.expect(eql(u8, &bytes, &[_]u8{
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
}));
writeIntSlice(u64, bytes[0..], 0x12345678CAFEBABE, .Big);
try testing.expect(eql(u8, &bytes, &[_]u8{
0x12,
0x34,
0x56,
0x78,
0xCA,
0xFE,
0xBA,
0xBE,
}));
writeIntSlice(u64, bytes[0..], 0xBEBAFECA78563412, .Little);
try testing.expect(eql(u8, &bytes, &[_]u8{
0x12,
0x34,
0x56,
0x78,
0xCA,
0xFE,
0xBA,
0xBE,
}));
writeIntSlice(u32, bytes[0..], 0x12345678, .Big);
try testing.expect(eql(u8, &bytes, &[_]u8{
0x00,
0x00,
0x00,
0x00,
0x12,
0x34,
0x56,
0x78,
}));
writeIntSlice(u32, bytes[0..], 0x78563412, .Little);
try testing.expect(eql(u8, &bytes, &[_]u8{
0x12,
0x34,
0x56,
0x78,
0x00,
0x00,
0x00,
0x00,
}));
writeIntSlice(u16, bytes[0..], 0x1234, .Big);
try testing.expect(eql(u8, &bytes, &[_]u8{
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x12,
0x34,
}));
writeIntSlice(u16, bytes[0..], 0x1234, .Little);
try testing.expect(eql(u8, &bytes, &[_]u8{
0x34,
0x12,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
}));
writeIntSlice(i16, bytes[0..], @as(i16, -21555), .Little);
try testing.expect(eql(u8, &bytes, &[_]u8{
0xCD,
0xAB,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
}));
writeIntSlice(i16, bytes[0..], @as(i16, -21555), .Big);
try testing.expect(eql(u8, &bytes, &[_]u8{
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0xAB,
0xCD,
}));
writeIntSlice(u8, bytes[0..], 0x12, .Big);
try testing.expect(eql(u8, &bytes, &[_]u8{
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x12,
}));
writeIntSlice(u8, bytes[0..], 0x12, .Little);
try testing.expect(eql(u8, &bytes, &[_]u8{
0x12, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
}));
writeIntSlice(i8, bytes[0..], -1, .Big);
try testing.expect(eql(u8, &bytes, &[_]u8{
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0xff,
}));
writeIntSlice(i8, bytes[0..], -1, .Little);
try testing.expect(eql(u8, &bytes, &[_]u8{
0xff, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
}));
}
fn writePackedIntLittle(comptime T: type, bytes: []u8, bit_offset: usize, value: T) void {
const uN = std.meta.Int(.unsigned, @bitSizeOf(T));
const Log2N = std.math.Log2Int(T);
@@ -1844,7 +1950,7 @@ fn writePackedIntLittle(comptime T: type, bytes: []u8, bit_offset: usize, value:
write_value |= @as(StoreInt, tail) << (8 * (store_size - 1));
}
writeIntLittle(StoreInt, write_bytes[0..store_size], write_value);
writeInt(StoreInt, write_bytes[0..store_size], write_value, .Little);
}
fn writePackedIntBig(comptime T: type, bytes: []u8, bit_offset: usize, value: T) void {
@@ -1879,7 +1985,7 @@ fn writePackedIntBig(comptime T: type, bytes: []u8, bit_offset: usize, value: T)
write_value |= @as(StoreInt, tail) << (8 * (store_size - 1));
}
writeIntBig(StoreInt, write_bytes[(byte_count - store_size)..][0..store_size], write_value);
writeInt(StoreInt, write_bytes[(byte_count - store_size)..][0..store_size], write_value, .Big);
}
pub const writePackedIntNative = switch (native_endian) {
@@ -1908,91 +2014,6 @@ pub fn writePackedInt(comptime T: type, bytes: []u8, bit_offset: usize, value: T
}
}
/// Writes a twos-complement little-endian integer to memory.
/// Asserts that buf.len >= @typeInfo(T).Int.bits / 8.
/// The bit count of T must be divisible by 8.
/// Any extra bytes in buffer after writing the integer are set to zero. To
/// avoid the branch to check for extra buffer bytes, use writeIntLittle
/// instead.
fn writeIntSliceLittleNative(comptime T: type, buffer: []u8, value: T) void {
assert(buffer.len >= @divExact(@typeInfo(T).Int.bits, 8));
if (@typeInfo(T).Int.bits == 0) {
return @memset(buffer, 0);
} else if (@typeInfo(T).Int.bits == 8) {
@memset(buffer, 0);
buffer[0] = @as(u8, @bitCast(value));
return;
}
const write_end = @divExact(@typeInfo(T).Int.bits, 8);
@as(*align(1) T, @ptrCast(buffer)).* = value;
@memset(buffer[write_end..], 0);
}
fn writeIntSliceLittleForeign(comptime T: type, buffer: []u8, value: T) void {
return writeIntSliceLittleNative(T, buffer, @byteSwap(value));
}
pub const writeIntSliceLittle = switch (native_endian) {
.Little => writeIntSliceLittleNative,
.Big => writeIntSliceLittleForeign,
};
/// Writes a twos-complement big-endian integer to memory.
/// Asserts that buffer.len >= @typeInfo(T).Int.bits / 8.
/// The bit count of T must be divisible by 8.
/// Any extra bytes in buffer before writing the integer are set to zero. To
/// avoid the branch to check for extra buffer bytes, use writeIntBig instead.
fn writeIntSliceBigNative(comptime T: type, buffer: []u8, value: T) void {
assert(buffer.len >= @divExact(@typeInfo(T).Int.bits, 8));
if (@typeInfo(T).Int.bits == 0) {
return @memset(buffer, 0);
} else if (@typeInfo(T).Int.bits == 8) {
@memset(buffer, 0);
buffer[buffer.len - 1] = @as(u8, @bitCast(value));
return;
}
const write_start = buffer.len - @divExact(@typeInfo(T).Int.bits, 8);
@memset(buffer[0..write_start], 0);
@as(*align(1) T, @ptrCast(buffer[write_start..])).* = value;
}
fn writeIntSliceBigForeign(comptime T: type, buffer: []u8, value: T) void {
return writeIntSliceBigNative(T, buffer, @byteSwap(value));
}
pub const writeIntSliceBig = switch (native_endian) {
.Little => writeIntSliceBigForeign,
.Big => writeIntSliceBigNative,
};
pub const writeIntSliceNative = switch (native_endian) {
.Little => writeIntSliceLittleNative,
.Big => writeIntSliceBigNative,
};
pub const writeIntSliceForeign = switch (native_endian) {
.Little => writeIntSliceBigForeign,
.Big => writeIntSliceLittleForeign,
};
/// Writes a twos-complement integer to memory, with the specified endianness.
/// Asserts that buf.len >= @typeInfo(T).Int.bits / 8.
/// The bit count of T must be evenly divisible by 8.
/// Any extra bytes in buffer not part of the integer are set to zero, with
/// respect to endianness. To avoid the branch to check for extra buffer bytes,
/// use writeInt instead.
pub fn writeIntSlice(comptime T: type, buffer: []u8, value: T, endian: Endian) void {
comptime assert(@typeInfo(T).Int.bits % 8 == 0);
return switch (endian) {
.Little => writeIntSliceLittle(T, buffer, value),
.Big => writeIntSliceBig(T, buffer, value),
};
}
/// Stores an integer to packed memory with provided bit_count, bit_offset, and signedness.
/// If negative, the written value is sign-extended.
///
@@ -2055,45 +2076,6 @@ pub fn writeVarPackedInt(bytes: []u8, bit_offset: usize, bit_count: usize, value
write_bytes[@as(usize, @intCast(i))] |= @as(u8, @intCast(@as(uN, @bitCast(remaining)) & tail_mask));
}
test "writeIntBig and writeIntLittle" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
var buf0: [0]u8 = undefined;
var buf1: [1]u8 = undefined;
var buf2: [2]u8 = undefined;
var buf9: [9]u8 = undefined;
writeIntBig(u0, &buf0, 0x0);
try testing.expect(eql(u8, buf0[0..], &[_]u8{}));
writeIntLittle(u0, &buf0, 0x0);
try testing.expect(eql(u8, buf0[0..], &[_]u8{}));
writeIntBig(u8, &buf1, 0x12);
try testing.expect(eql(u8, buf1[0..], &[_]u8{0x12}));
writeIntLittle(u8, &buf1, 0x34);
try testing.expect(eql(u8, buf1[0..], &[_]u8{0x34}));
writeIntBig(u16, &buf2, 0x1234);
try testing.expect(eql(u8, buf2[0..], &[_]u8{ 0x12, 0x34 }));
writeIntLittle(u16, &buf2, 0x5678);
try testing.expect(eql(u8, buf2[0..], &[_]u8{ 0x78, 0x56 }));
writeIntBig(u72, &buf9, 0x123456789abcdef024);
try testing.expect(eql(u8, buf9[0..], &[_]u8{ 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x24 }));
writeIntLittle(u72, &buf9, 0xfedcba9876543210ec);
try testing.expect(eql(u8, buf9[0..], &[_]u8{ 0xec, 0x10, 0x32, 0x54, 0x76, 0x98, 0xba, 0xdc, 0xfe }));
writeIntBig(i8, &buf1, -1);
try testing.expect(eql(u8, buf1[0..], &[_]u8{0xff}));
writeIntLittle(i8, &buf1, -2);
try testing.expect(eql(u8, buf1[0..], &[_]u8{0xfe}));
writeIntBig(i16, &buf2, -3);
try testing.expect(eql(u8, buf2[0..], &[_]u8{ 0xff, 0xfd }));
writeIntLittle(i16, &buf2, -4);
try testing.expect(eql(u8, buf2[0..], &[_]u8{ 0xfc, 0xff }));
}
/// Swap the byte order of all the members of the fields of a struct
/// (Changing their endianness)
pub fn byteSwapAllFields(comptime S: type, ptr: *S) void {
@@ -3311,12 +3293,12 @@ fn testReadIntImpl() !void {
0x56,
0x78,
};
try testing.expect(readInt(u32, &bytes, Endian.Big) == 0x12345678);
try testing.expect(readIntBig(u32, &bytes) == 0x12345678);
try testing.expect(readIntBig(i32, &bytes) == 0x12345678);
try testing.expect(readInt(u32, &bytes, Endian.Little) == 0x78563412);
try testing.expect(readIntLittle(u32, &bytes) == 0x78563412);
try testing.expect(readIntLittle(i32, &bytes) == 0x78563412);
try testing.expect(readInt(u32, &bytes, .Big) == 0x12345678);
try testing.expect(readInt(u32, &bytes, .Big) == 0x12345678);
try testing.expect(readInt(i32, &bytes, .Big) == 0x12345678);
try testing.expect(readInt(u32, &bytes, .Little) == 0x78563412);
try testing.expect(readInt(u32, &bytes, .Little) == 0x78563412);
try testing.expect(readInt(i32, &bytes, .Little) == 0x78563412);
}
{
const buf = [_]u8{
@@ -3325,7 +3307,7 @@ fn testReadIntImpl() !void {
0x12,
0x34,
};
const answer = readInt(u32, &buf, Endian.Big);
const answer = readInt(u32, &buf, .Big);
try testing.expect(answer == 0x00001234);
}
{
@@ -3335,7 +3317,7 @@ fn testReadIntImpl() !void {
0x00,
0x00,
};
const answer = readInt(u32, &buf, Endian.Little);
const answer = readInt(u32, &buf, .Little);
try testing.expect(answer == 0x00003412);
}
{
@@ -3343,153 +3325,13 @@ fn testReadIntImpl() !void {
0xff,
0xfe,
};
try testing.expect(readIntBig(u16, &bytes) == 0xfffe);
try testing.expect(readIntBig(i16, &bytes) == -0x0002);
try testing.expect(readIntLittle(u16, &bytes) == 0xfeff);
try testing.expect(readIntLittle(i16, &bytes) == -0x0101);
try testing.expect(readInt(u16, &bytes, .Big) == 0xfffe);
try testing.expect(readInt(i16, &bytes, .Big) == -0x0002);
try testing.expect(readInt(u16, &bytes, .Little) == 0xfeff);
try testing.expect(readInt(i16, &bytes, .Little) == -0x0101);
}
}
test writeIntSlice {
try testWriteIntImpl();
try comptime testWriteIntImpl();
}
fn testWriteIntImpl() !void {
var bytes: [8]u8 = undefined;
writeIntSlice(u0, bytes[0..], 0, Endian.Big);
try testing.expect(eql(u8, &bytes, &[_]u8{
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
}));
writeIntSlice(u0, bytes[0..], 0, Endian.Little);
try testing.expect(eql(u8, &bytes, &[_]u8{
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
}));
writeIntSlice(u64, bytes[0..], 0x12345678CAFEBABE, Endian.Big);
try testing.expect(eql(u8, &bytes, &[_]u8{
0x12,
0x34,
0x56,
0x78,
0xCA,
0xFE,
0xBA,
0xBE,
}));
writeIntSlice(u64, bytes[0..], 0xBEBAFECA78563412, Endian.Little);
try testing.expect(eql(u8, &bytes, &[_]u8{
0x12,
0x34,
0x56,
0x78,
0xCA,
0xFE,
0xBA,
0xBE,
}));
writeIntSlice(u32, bytes[0..], 0x12345678, Endian.Big);
try testing.expect(eql(u8, &bytes, &[_]u8{
0x00,
0x00,
0x00,
0x00,
0x12,
0x34,
0x56,
0x78,
}));
writeIntSlice(u32, bytes[0..], 0x78563412, Endian.Little);
try testing.expect(eql(u8, &bytes, &[_]u8{
0x12,
0x34,
0x56,
0x78,
0x00,
0x00,
0x00,
0x00,
}));
writeIntSlice(u16, bytes[0..], 0x1234, Endian.Big);
try testing.expect(eql(u8, &bytes, &[_]u8{
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x12,
0x34,
}));
writeIntSlice(u16, bytes[0..], 0x1234, Endian.Little);
try testing.expect(eql(u8, &bytes, &[_]u8{
0x34,
0x12,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
}));
writeIntSlice(i16, bytes[0..], @as(i16, -21555), Endian.Little);
try testing.expect(eql(u8, &bytes, &[_]u8{
0xCD,
0xAB,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
}));
writeIntSlice(i16, bytes[0..], @as(i16, -21555), Endian.Big);
try testing.expect(eql(u8, &bytes, &[_]u8{
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0xAB,
0xCD,
}));
writeIntSlice(u8, bytes[0..], 0x12, Endian.Big);
try testing.expect(eql(u8, &bytes, &[_]u8{
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x12,
}));
writeIntSlice(u8, bytes[0..], 0x12, Endian.Little);
try testing.expect(eql(u8, &bytes, &[_]u8{
0x12, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
}));
writeIntSlice(i8, bytes[0..], -1, Endian.Big);
try testing.expect(eql(u8, &bytes, &[_]u8{
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0xff,
}));
writeIntSlice(i8, bytes[0..], -1, Endian.Little);
try testing.expect(eql(u8, &bytes, &[_]u8{
0xff, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
}));
}
/// Returns the smallest number in a slice. O(n).
/// `slice` must not be empty.
pub fn min(comptime T: type, slice: []const T) T {
@@ -4671,7 +4513,6 @@ pub fn alignInSlice(slice: anytype, comptime new_alignment: usize) ?AlignedSlice
}
test "read/write(Var)PackedInt" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
switch (builtin.cpu.arch) {

6
lib/std/net.zig
View File

@@ -1052,7 +1052,7 @@ fn linuxLookupName(
} else {
sa6.addr[0..12].* = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff".*;
da6.addr[0..12].* = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff".*;
mem.writeIntNative(u32, da6.addr[12..], addr.addr.in.sa.addr);
mem.writeInt(u32, da6.addr[12..], addr.addr.in.sa.addr, native_endian);
da4.addr = addr.addr.in.sa.addr;
da = @ptrCast(&da4);
dalen = @sizeOf(os.sockaddr.in);
@@ -1073,7 +1073,7 @@ fn linuxLookupName(
os.getsockname(fd, sa, &salen) catch break :syscalls;
if (addr.addr.any.family == os.AF.INET) {
// TODO sa6.addr[12..16] should return *[4]u8, making this cast unnecessary.
mem.writeIntNative(u32, @as(*[4]u8, @ptrCast(&sa6.addr[12])), sa4.addr);
mem.writeInt(u32, @as(*[4]u8, @ptrCast(&sa6.addr[12])), sa4.addr, native_endian);
}
if (dscope == @as(i32, scopeOf(sa6.addr))) key |= DAS_MATCHINGSCOPE;
if (dlabel == labelOf(sa6.addr)) key |= DAS_MATCHINGLABEL;
@@ -1569,7 +1569,7 @@ fn resMSendRc(
);
for (0..ns.len) |i| {
if (ns[i].any.family != os.AF.INET) continue;
mem.writeIntNative(u32, ns[i].in6.sa.addr[12..], ns[i].in.sa.addr);
mem.writeInt(u32, ns[i].in6.sa.addr[12..], ns[i].in.sa.addr, native_endian);
ns[i].in6.sa.addr[0..12].* = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff".*;
ns[i].any.family = os.AF.INET6;
ns[i].in6.sa.flowinfo = 0;

6
lib/std/os/test.zig
View File

@@ -609,7 +609,7 @@ test "mmap" {
var i: u32 = 0;
while (i < alloc_size / @sizeOf(u32)) : (i += 1) {
try stream.writeIntNative(u32, i);
try stream.writeInt(u32, i, .Little);
}
}
@@ -633,7 +633,7 @@ test "mmap" {
var i: u32 = 0;
while (i < alloc_size / @sizeOf(u32)) : (i += 1) {
try testing.expectEqual(i, try stream.readIntNative(u32));
try testing.expectEqual(i, try stream.readInt(u32, .Little));
}
}
@@ -657,7 +657,7 @@ test "mmap" {
var i: u32 = alloc_size / 2 / @sizeOf(u32);
while (i < alloc_size / @sizeOf(u32)) : (i += 1) {
try testing.expectEqual(i, try stream.readIntNative(u32));
try testing.expectEqual(i, try stream.readInt(u32, .Little));
}
}

26
lib/std/pdb.zig
View File

@@ -464,12 +464,12 @@ pub const PDBStringTableHeader = extern struct {
};
fn readSparseBitVector(stream: anytype, allocator: mem.Allocator) ![]u32 {
const num_words = try stream.readIntLittle(u32);
const num_words = try stream.readInt(u32, .Little);
var list = ArrayList(u32).init(allocator);
errdefer list.deinit();
var word_i: u32 = 0;
while (word_i != num_words) : (word_i += 1) {
const word = try stream.readIntLittle(u32);
const word = try stream.readInt(u32, .Little);
var bit_i: u5 = 0;
while (true) : (bit_i += 1) {
if (word & (@as(u32, 1) << bit_i) != 0) {
@@ -625,10 +625,10 @@ pub const Pdb = struct {
const reader = stream.reader();
// Parse the InfoStreamHeader.
const version = try reader.readIntLittle(u32);
const signature = try reader.readIntLittle(u32);
const version = try reader.readInt(u32, .Little);
const signature = try reader.readInt(u32, .Little);
_ = signature;
const age = try reader.readIntLittle(u32);
const age = try reader.readInt(u32, .Little);
const guid = try reader.readBytesNoEof(16);
if (version != 20000404) // VC70, only value observed by LLVM team
@@ -639,7 +639,7 @@ pub const Pdb = struct {
// Find the string table.
const string_table_index = str_tab_index: {
const name_bytes_len = try reader.readIntLittle(u32);
const name_bytes_len = try reader.readInt(u32, .Little);
const name_bytes = try self.allocator.alloc(u8, name_bytes_len);
defer self.allocator.free(name_bytes);
try reader.readNoEof(name_bytes);
@@ -667,8 +667,8 @@ pub const Pdb = struct {
defer self.allocator.free(deleted);
for (present) |_| {
const name_offset = try reader.readIntLittle(u32);
const name_index = try reader.readIntLittle(u32);
const name_offset = try reader.readInt(u32, .Little);
const name_index = try reader.readInt(u32, .Little);
if (name_offset > name_bytes.len)
return error.InvalidDebugInfo;
const name = mem.sliceTo(name_bytes[name_offset..], 0);
@@ -821,7 +821,7 @@ pub const Pdb = struct {
return error.MissingDebugInfo;
const reader = stream.reader();
const signature = try reader.readIntLittle(u32);
const signature = try reader.readInt(u32, .Little);
if (signature != 4)
return error.InvalidDebugInfo;
@@ -899,7 +899,7 @@ const Msf = struct {
try file.seekTo(superblock.BlockSize * superblock.BlockMapAddr);
var dir_blocks = try allocator.alloc(u32, dir_block_count);
for (dir_blocks) |*b| {
b.* = try in.readIntLittle(u32);
b.* = try in.readInt(u32, .Little);
}
var directory = MsfStream.init(
superblock.BlockSize,
@@ -908,7 +908,7 @@ const Msf = struct {
);
const begin = directory.pos;
const stream_count = try directory.reader().readIntLittle(u32);
const stream_count = try directory.reader().readInt(u32, .Little);
const stream_sizes = try allocator.alloc(u32, stream_count);
defer allocator.free(stream_sizes);
@@ -917,7 +917,7 @@ const Msf = struct {
// and must be taken into account when resolving stream indices.
const Nil = 0xFFFFFFFF;
for (stream_sizes) |*s| {
const size = try directory.reader().readIntLittle(u32);
const size = try directory.reader().readInt(u32, .Little);
s.* = if (size == Nil) 0 else blockCountFromSize(size, superblock.BlockSize);
}
@@ -932,7 +932,7 @@ const Msf = struct {
var blocks = try allocator.alloc(u32, size);
var j: u32 = 0;
while (j < size) : (j += 1) {
const block_id = try directory.reader().readIntLittle(u32);
const block_id = try directory.reader().readInt(u32, .Little);
const n = (block_id % superblock.BlockSize);
// 0 is for SuperBlock, 1 and 2 for FPMs.
if (block_id == 0 or n == 1 or n == 2 or block_id * superblock.BlockSize > file_len)

9
lib/std/rand.zig
View File

@@ -104,15 +104,16 @@ pub const Random = struct {
pub fn int(r: Random, comptime T: type) T {
const bits = @typeInfo(T).Int.bits;
const UnsignedT = std.meta.Int(.unsigned, bits);
const ByteAlignedT = std.meta.Int(.unsigned, @divTrunc(bits + 7, 8) * 8);
const ceil_bytes = comptime std.math.divCeil(u16, bits, 8) catch unreachable;
const ByteAlignedT = std.meta.Int(.unsigned, ceil_bytes * 8);
var rand_bytes: [@sizeOf(ByteAlignedT)]u8 = undefined;
r.bytes(rand_bytes[0..]);
var rand_bytes: [ceil_bytes]u8 = undefined;
r.bytes(&rand_bytes);
// use LE instead of native endian for better portability maybe?
// TODO: endian portability is pointless if the underlying prng isn't endian portable.
// TODO: document the endian portability of this library.
const byte_aligned_result = mem.readIntSliceLittle(ByteAlignedT, &rand_bytes);
const byte_aligned_result = mem.readInt(ByteAlignedT, &rand_bytes, .Little);
const unsigned_result: UnsignedT = @truncate(byte_aligned_result);
return @bitCast(unsigned_result);
}

2
lib/std/rand/Isaac64.zig
View File

@@ -228,7 +228,7 @@ test "isaac64 fill" {
for (seq) |s| {
var buf0: [8]u8 = undefined;
var buf1: [7]u8 = undefined;
std.mem.writeIntLittle(u64, &buf0, s);
std.mem.writeInt(u64, &buf0, s, .Little);
r.fill(&buf1);
try std.testing.expect(std.mem.eql(u8, buf0[0..7], buf1[0..]));
}

4
lib/std/rand/Pcg.zig
View File

@@ -111,8 +111,8 @@ test "pcg fill" {
var i: u32 = 0;
while (i < seq.len) : (i += 2) {
var buf0: [8]u8 = undefined;
std.mem.writeIntLittle(u32, buf0[0..4], seq[i]);
std.mem.writeIntLittle(u32, buf0[4..8], seq[i + 1]);
std.mem.writeInt(u32, buf0[0..4], seq[i], .Little);
std.mem.writeInt(u32, buf0[4..8], seq[i + 1], .Little);
var buf1: [7]u8 = undefined;
r.fill(&buf1);

2
lib/std/rand/RomuTrio.zig
View File

@@ -115,7 +115,7 @@ test "RomuTrio fill" {
for (seq) |s| {
var buf0: [8]u8 = undefined;
var buf1: [7]u8 = undefined;
std.mem.writeIntLittle(u64, &buf0, s);
std.mem.writeInt(u64, &buf0, s, .Little);
r.fill(&buf1);
try std.testing.expect(std.mem.eql(u8, buf0[0..7], buf1[0..]));
}

2
lib/std/rand/Sfc64.zig
View File

@@ -125,7 +125,7 @@ test "Sfc64 fill" {
for (seq) |s| {
var buf0: [8]u8 = undefined;
var buf1: [7]u8 = undefined;
std.mem.writeIntLittle(u64, &buf0, s);
std.mem.writeInt(u64, &buf0, s, .Little);
r.fill(&buf1);
try std.testing.expect(std.mem.eql(u8, buf0[0..7], buf1[0..]));
}

2
lib/std/rand/Xoroshiro128.zig
View File

@@ -140,7 +140,7 @@ test "xoroshiro fill" {
for (seq) |s| {
var buf0: [8]u8 = undefined;
var buf1: [7]u8 = undefined;
std.mem.writeIntLittle(u64, &buf0, s);
std.mem.writeInt(u64, &buf0, s, .Little);
r.fill(&buf1);
try std.testing.expect(std.mem.eql(u8, buf0[0..7], buf1[0..]));
}

2
lib/std/rand/Xoshiro256.zig
View File

@@ -139,7 +139,7 @@ test "xoroshiro fill" {
for (seq) |s| {
var buf0: [8]u8 = undefined;
var buf1: [7]u8 = undefined;
std.mem.writeIntLittle(u64, &buf0, s);
std.mem.writeInt(u64, &buf0, s, .Little);
r.fill(&buf1);
try std.testing.expect(std.mem.eql(u8, buf0[0..7], buf1[0..]));
}

2
lib/std/rand/test.zig
View File

@@ -71,7 +71,7 @@ const Dilbert = struct {
for (seq) |s| {
var buf0: [8]u8 = undefined;
var buf1: [8]u8 = undefined;
std.mem.writeIntBig(u64, &buf0, s);
std.mem.writeInt(u64, &buf0, s, .Big);
r.fill(&buf1);
try std.testing.expect(std.mem.eql(u8, buf0[0..], buf1[0..]));
}

8
lib/std/tz.zig
View File

@@ -98,7 +98,7 @@ pub const Tz = struct {
// Parse transition types
var i: usize = 0;
while (i < header.counts.timecnt) : (i += 1) {
transitions[i].ts = if (legacy) try reader.readIntBig(i32) else try reader.readIntBig(i64);
transitions[i].ts = if (legacy) try reader.readInt(i32, .Big) else try reader.readInt(i64, .Big);
}
i = 0;
@@ -111,7 +111,7 @@ pub const Tz = struct {
// Parse time types
i = 0;
while (i < header.counts.typecnt) : (i += 1) {
const offset = try reader.readIntBig(i32);
const offset = try reader.readInt(i32, .Big);
if (offset < -2147483648) return error.Malformed; // rfc8536: utoff [...] MUST NOT be -2**31
const dst = try reader.readByte();
if (dst != 0 and dst != 1) return error.Malformed; // rfc8536: (is)dst [...] The value MUST be 0 or 1.
@@ -144,12 +144,12 @@ pub const Tz = struct {
// Parse leap seconds
i = 0;
while (i < header.counts.leapcnt) : (i += 1) {
const occur: i64 = if (legacy) try reader.readIntBig(i32) else try reader.readIntBig(i64);
const occur: i64 = if (legacy) try reader.readInt(i32, .Big) else try reader.readInt(i64, .Big);
if (occur < 0) return error.Malformed; // rfc8536: occur [...] MUST be nonnegative
if (i > 0 and leapseconds[i - 1].occurrence + 2419199 > occur) return error.Malformed; // rfc8536: occur [...] each later value MUST be at least 2419199 greater than the previous value
if (occur > std.math.maxInt(i48)) return error.Malformed; // Unreasonably far into the future
const corr = try reader.readIntBig(i32);
const corr = try reader.readInt(i32, .Big);
if (i == 0 and corr != -1 and corr != 1) return error.Malformed; // rfc8536: The correction value in the first leap-second record, if present, MUST be either one (1) or minus one (-1)
if (i > 0 and leapseconds[i - 1].correction != corr + 1 and leapseconds[i - 1].correction != corr - 1) return error.Malformed; // rfc8536: The correction values in adjacent leap-second records MUST differ by exactly one (1)
if (corr > std.math.maxInt(i16)) return error.Malformed; // Unreasonably large correction

49
lib/std/unicode.zig
View File

@@ -1,8 +1,9 @@
const std = @import("./std.zig");
const builtin = @import("builtin");
const assert = std.debug.assert;
const testing = std.testing;
const mem = std.mem;
const builtin = @import("builtin");
const native_endian = builtin.cpu.arch.endian();
/// Use this to replace an unknown, unrecognized, or unrepresentable character.
///
@@ -175,7 +176,7 @@ pub fn utf8CountCodepoints(s: []const u8) !usize {
while (i < s.len) {
// Fast path for ASCII sequences
while (i + N <= s.len) : (i += N) {
const v = mem.readIntNative(usize, s[i..][0..N]);
const v = mem.readInt(usize, s[i..][0..N], native_endian);
if (v & MASK != 0) break;
len += N;
}
@@ -451,12 +452,12 @@ pub const Utf16LeIterator = struct {
assert(it.i <= it.bytes.len);
if (it.i == it.bytes.len) return null;
var code_units: [2]u16 = undefined;
code_units[0] = mem.readIntLittle(u16, it.bytes[it.i..][0..2]);
code_units[0] = mem.readInt(u16, it.bytes[it.i..][0..2], .Little);
it.i += 2;
if (utf16IsHighSurrogate(code_units[0])) {
// surrogate pair
if (it.i >= it.bytes.len) return error.DanglingSurrogateHalf;
code_units[1] = mem.readIntLittle(u16, it.bytes[it.i..][0..2]);
code_units[1] = mem.readInt(u16, it.bytes[it.i..][0..2], .Little);
const codepoint = try utf16DecodeSurrogatePair(&code_units);
it.i += 2;
return codepoint;
@@ -877,16 +878,16 @@ test "utf16leToUtf8" {
const utf16le_as_bytes = mem.sliceAsBytes(utf16le[0..]);
{
mem.writeIntSliceLittle(u16, utf16le_as_bytes[0..], 'A');
mem.writeIntSliceLittle(u16, utf16le_as_bytes[2..], 'a');
mem.writeInt(u16, utf16le_as_bytes[0..2], 'A', .Little);
mem.writeInt(u16, utf16le_as_bytes[2..4], 'a', .Little);
const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le);
defer std.testing.allocator.free(utf8);
try testing.expect(mem.eql(u8, utf8, "Aa"));
}
{
mem.writeIntSliceLittle(u16, utf16le_as_bytes[0..], 0x80);
mem.writeIntSliceLittle(u16, utf16le_as_bytes[2..], 0xffff);
mem.writeInt(u16, utf16le_as_bytes[0..2], 0x80, .Little);
mem.writeInt(u16, utf16le_as_bytes[2..4], 0xffff, .Little);
const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le);
defer std.testing.allocator.free(utf8);
try testing.expect(mem.eql(u8, utf8, "\xc2\x80" ++ "\xef\xbf\xbf"));
@@ -894,8 +895,8 @@ test "utf16leToUtf8" {
{
// the values just outside the surrogate half range
mem.writeIntSliceLittle(u16, utf16le_as_bytes[0..], 0xd7ff);
mem.writeIntSliceLittle(u16, utf16le_as_bytes[2..], 0xe000);
mem.writeInt(u16, utf16le_as_bytes[0..2], 0xd7ff, .Little);
mem.writeInt(u16, utf16le_as_bytes[2..4], 0xe000, .Little);
const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le);
defer std.testing.allocator.free(utf8);
try testing.expect(mem.eql(u8, utf8, "\xed\x9f\xbf" ++ "\xee\x80\x80"));
@@ -903,8 +904,8 @@ test "utf16leToUtf8" {
{
// smallest surrogate pair
mem.writeIntSliceLittle(u16, utf16le_as_bytes[0..], 0xd800);
mem.writeIntSliceLittle(u16, utf16le_as_bytes[2..], 0xdc00);
mem.writeInt(u16, utf16le_as_bytes[0..2], 0xd800, .Little);
mem.writeInt(u16, utf16le_as_bytes[2..4], 0xdc00, .Little);
const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le);
defer std.testing.allocator.free(utf8);
try testing.expect(mem.eql(u8, utf8, "\xf0\x90\x80\x80"));
@@ -912,24 +913,24 @@ test "utf16leToUtf8" {
{
// largest surrogate pair
mem.writeIntSliceLittle(u16, utf16le_as_bytes[0..], 0xdbff);
mem.writeIntSliceLittle(u16, utf16le_as_bytes[2..], 0xdfff);
mem.writeInt(u16, utf16le_as_bytes[0..2], 0xdbff, .Little);
mem.writeInt(u16, utf16le_as_bytes[2..4], 0xdfff, .Little);
const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le);
defer std.testing.allocator.free(utf8);
try testing.expect(mem.eql(u8, utf8, "\xf4\x8f\xbf\xbf"));
}
{
mem.writeIntSliceLittle(u16, utf16le_as_bytes[0..], 0xdbff);
mem.writeIntSliceLittle(u16, utf16le_as_bytes[2..], 0xdc00);
mem.writeInt(u16, utf16le_as_bytes[0..2], 0xdbff, .Little);
mem.writeInt(u16, utf16le_as_bytes[2..4], 0xdc00, .Little);
const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le);
defer std.testing.allocator.free(utf8);
try testing.expect(mem.eql(u8, utf8, "\xf4\x8f\xb0\x80"));
}
{
mem.writeIntSliceLittle(u16, utf16le_as_bytes[0..], 0xdcdc);
mem.writeIntSliceLittle(u16, utf16le_as_bytes[2..], 0xdcdc);
mem.writeInt(u16, utf16le_as_bytes[0..2], 0xdcdc, .Little);
mem.writeInt(u16, utf16le_as_bytes[2..4], 0xdcdc, .Little);
const result = utf16leToUtf8Alloc(std.testing.allocator, &utf16le);
try std.testing.expectError(error.UnexpectedSecondSurrogateHalf, result);
}
@@ -1140,12 +1141,12 @@ test "fmtUtf16le" {
try expectFmt("", "{}", .{fmtUtf16le(utf8ToUtf16LeStringLiteral(""))});
try expectFmt("foo", "{}", .{fmtUtf16le(utf8ToUtf16LeStringLiteral("foo"))});
try expectFmt("𐐷", "{}", .{fmtUtf16le(utf8ToUtf16LeStringLiteral("𐐷"))});
try expectFmt("퟿", "{}", .{fmtUtf16le(&[_]u16{std.mem.readIntNative(u16, "\xff\xd7")})});
try expectFmt("<EFBFBD>", "{}", .{fmtUtf16le(&[_]u16{std.mem.readIntNative(u16, "\x00\xd8")})});
try expectFmt("<EFBFBD>", "{}", .{fmtUtf16le(&[_]u16{std.mem.readIntNative(u16, "\xff\xdb")})});
try expectFmt("<EFBFBD>", "{}", .{fmtUtf16le(&[_]u16{std.mem.readIntNative(u16, "\x00\xdc")})});
try expectFmt("<EFBFBD>", "{}", .{fmtUtf16le(&[_]u16{std.mem.readIntNative(u16, "\xff\xdf")})});
try expectFmt("", "{}", .{fmtUtf16le(&[_]u16{std.mem.readIntNative(u16, "\x00\xe0")})});
try expectFmt("퟿", "{}", .{fmtUtf16le(&[_]u16{std.mem.readInt(u16, "\xff\xd7", native_endian)})});
try expectFmt("<EFBFBD>", "{}", .{fmtUtf16le(&[_]u16{std.mem.readInt(u16, "\x00\xd8", native_endian)})});
try expectFmt("<EFBFBD>", "{}", .{fmtUtf16le(&[_]u16{std.mem.readInt(u16, "\xff\xdb", native_endian)})});
try expectFmt("<EFBFBD>", "{}", .{fmtUtf16le(&[_]u16{std.mem.readInt(u16, "\x00\xdc", native_endian)})});
try expectFmt("<EFBFBD>", "{}", .{fmtUtf16le(&[_]u16{std.mem.readInt(u16, "\xff\xdf", native_endian)})});
try expectFmt("", "{}", .{fmtUtf16le(&[_]u16{std.mem.readInt(u16, "\x00\xe0", native_endian)})});
}
test "utf8ToUtf16LeStringLiteral" {

4
lib/std/zig/Server.zig
View File

@@ -279,12 +279,12 @@ fn bswap_u32_array(slice: []u32) void {
/// workaround for https://github.com/ziglang/zig/issues/14904
fn bswap_and_workaround_u32(bytes_ptr: *const [4]u8) u32 {
return std.mem.readIntLittle(u32, bytes_ptr);
return std.mem.readInt(u32, bytes_ptr, .Little);
}
/// workaround for https://github.com/ziglang/zig/issues/14904
fn bswap_and_workaround_tag(bytes_ptr: *const [4]u8) InMessage.Tag {
const int = std.mem.readIntLittle(u32, bytes_ptr);
const int = std.mem.readInt(u32, bytes_ptr, .Little);
return @as(InMessage.Tag, @enumFromInt(int));
}

4
lib/test_runner.zig
View File

@@ -13,7 +13,9 @@ var cmdline_buffer: [4096]u8 = undefined;
var fba = std.heap.FixedBufferAllocator.init(&cmdline_buffer);
pub fn main() void {
if (builtin.zig_backend == .stage2_aarch64) {
if (builtin.zig_backend == .stage2_aarch64 or
builtin.zig_backend == .stage2_wasm)
{
return mainSimple() catch @panic("test failure");
}

24
src/Package/Fetch/git.zig
View File

@@ -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().readIntBig(u32));
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().readIntBig(u64);
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.readIntBig(u32) 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.readIntBig(u32) 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.readIntBig(u32, header_bytes[4..8]);
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.readIntBig(u32) 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.writeIntBig(u32, IndexHeader.supported_version);
try writer.writeInt(u32, IndexHeader.supported_version, .Big);
for (fan_out_table) |fan_out_entry| {
try writer.writeIntBig(u32, fan_out_entry);
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.writeIntBig(u32, index_entries.get(oid).?.crc32);
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.writeIntBig(u32, @intCast(offset));
try writer.writeInt(u32, @intCast(offset), .Big);
} else {
const index = big_offsets.items.len;
try big_offsets.append(allocator, offset);
try writer.writeIntBig(u32, @as(u32, @intCast(index)) | (1 << 31));
try writer.writeInt(u32, @as(u32, @intCast(index)) | (1 << 31), .Big);
}
}
for (big_offsets.items) |offset| {
try writer.writeIntBig(u64, offset);
try writer.writeInt(u64, offset, .Big);
}
try writer.writeAll(&pack_checksum);

2
src/arch/wasm/CodeGen.zig
View File

@@ -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.readIntLittle(u64, &buf),
mem.readInt(u64, &buf, .Little),
);
return func.lowerConstant(int_val, backing_int_ty);
},

4
src/arch/wasm/Emit.zig
View File

@@ -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().writeIntLittle(u32, @as(u32, @bitCast(value)));
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().writeIntLittle(u64, value.data.toU64());
try emit.code.writer().writeInt(u64, value.data.toU64(), .Little);
}
fn emitMemArg(emit: *Emit, tag: Mir.Inst.Tag, inst: Mir.Inst.Index) !void {

2
src/arch/x86_64/Emit.zig
View File

@@ -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.writeIntLittle(i32, emit.code.items[reloc.offset..][0..4], disp);
mem.writeInt(i32, emit.code.items[reloc.offset..][0..4], disp, .Little);
}
}

8
src/arch/x86_64/encoder.zig
View File

@@ -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.writeIntLittle(i32, disp);
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.writeIntLittle(u16, imm);
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.writeIntLittle(u32, imm);
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.writeIntLittle(u64, imm);
try self.writer.writeInt(u64, imm, .Little);
}
};
}

10
src/glibc.zig
View File

@@ -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.readIntLittle(u16, metadata.inclusions[inc_i..][0..2]);
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.readIntLittle(u32, metadata.inclusions[inc_i..][0..4]);
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.readIntLittle(u16, metadata.inclusions[inc_i..][0..2]);
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.readIntLittle(u32, metadata.inclusions[inc_i..][0..4]);
const targets = mem.readInt(u32, metadata.inclusions[inc_i..][0..4], .Little);
inc_i += 4;
const size = mem.readIntLittle(u16, metadata.inclusions[inc_i..][0..2]);
const size = mem.readInt(u16, metadata.inclusions[inc_i..][0..2], .Little);
inc_i += 2;
const lib_index = metadata.inclusions[inc_i];

18
src/link/Coff.zig
View File

@@ -856,12 +856,12 @@ fn writeOffsetTableEntry(self: *Coff, index: usize) !void {
switch (self.ptr_width) {
.p32 => {
var buf: [4]u8 = undefined;
mem.writeIntLittle(u32, &buf, @as(u32, @intCast(entry_value + self.getImageBase())));
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.writeIntLittle(u64, &buf, entry_value + self.getImageBase());
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.writeIntLittle(u32, &buf, @as(u32, @intCast(entry_value + slide)));
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.writeIntLittle(u64, &buf, entry_value + slide);
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.writeIntLittle(u16, buffer.items[names_table_offset..][0..2], 0); // 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.writeIntLittle(u64, buffer.items[iat_offset..][0..lookup_entry_size], 0);
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.writeIntLittle(u32, buffer.items[0..4], @as(u32, @intCast(self.strtab.len())));
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.writeIntLittle(u32, buffer.items[0x3c..][0..4], msdos_stub.len);
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.writeIntLittle(u32, symbol.name[4..8], offset);
mem.writeInt(u32, symbol.name[4..8], offset, .Little);
}
fn logSymAttributes(sym: *const coff.Symbol, buf: *[4]u8) []const u8 {

21
src/link/Coff/Relocation.zig
View File

@@ -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.writeIntLittle(u32, buffer[0..4], inst.toU32());
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.writeIntLittle(u32, buffer[0..4], inst.toU32());
mem.writeInt(u32, buffer[0..4], inst.toU32(), .Little);
} else {
var inst = aarch64.Instruction{
.load_store_register = mem.bytesToValue(meta.TagPayload(
@@ -173,18 +173,19 @@ fn resolveAarch64(self: Relocation, ctx: Context) void {
}
};
inst.load_store_register.offset = offset;
mem.writeIntLittle(u32, buffer[0..4], inst.toU32());
mem.writeInt(u32, buffer[0..4], inst.toU32(), .Little);
}
},
.direct => {
assert(!self.pcrel);
switch (self.length) {
2 => mem.writeIntLittle(
2 => mem.writeInt(
u32,
buffer[0..4],
@as(u32, @truncate(ctx.target_vaddr + ctx.image_base)),
.Little,
),
3 => mem.writeIntLittle(u64, buffer[0..8], ctx.target_vaddr + ctx.image_base),
3 => mem.writeInt(u64, buffer[0..8], ctx.target_vaddr + ctx.image_base, .Little),
else => unreachable,
}
},
@@ -207,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.writeIntLittle(i32, buffer[0..4], disp);
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.writeIntLittle(i32, buffer[0..4], disp);
mem.writeInt(i32, buffer[0..4], disp, .Little);
} else switch (ctx.ptr_width) {
.p32 => mem.writeIntLittle(u32, buffer[0..4], @as(u32, @intCast(ctx.target_vaddr + ctx.image_base))),
.p32 => mem.writeInt(u32, buffer[0..4], @as(u32, @intCast(ctx.target_vaddr + ctx.image_base)), .Little),
.p64 => switch (self.length) {
2 => mem.writeIntLittle(u32, buffer[0..4], @as(u32, @truncate(ctx.target_vaddr + ctx.image_base))),
3 => mem.writeIntLittle(u64, buffer[0..8], ctx.target_vaddr + ctx.image_base),
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,
},
}

84
src/link/Elf/Atom.zig
View File

@@ -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.writeIntLittle(i32, @as(i32, @intCast(S + A - P))),
=> try cwriter.writeInt(i32, @as(i32, @intCast(S + A - P)), .Little),
elf.R_X86_64_GOTPCREL => try cwriter.writeIntLittle(i32, @as(i32, @intCast(G + GOT + A - P))),
elf.R_X86_64_GOTPC32 => try cwriter.writeIntLittle(i32, @as(i32, @intCast(GOT + A - P))),
elf.R_X86_64_GOTPC64 => try cwriter.writeIntLittle(i64, GOT + A - P),
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.writeIntLittle(i32, @as(i32, @intCast(S + A - P)));
try cwriter.writeInt(i32, @as(i32, @intCast(S + A - P)), .Little);
continue;
}
try cwriter.writeIntLittle(i32, @as(i32, @intCast(G + GOT + A - P)));
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.writeIntLittle(i32, @as(i32, @intCast(S + A - P)));
try cwriter.writeInt(i32, @as(i32, @intCast(S + A - P)), .Little);
continue;
}
try cwriter.writeIntLittle(i32, @as(i32, @intCast(G + GOT + A - P)));
try cwriter.writeInt(i32, @as(i32, @intCast(G + GOT + A - P)), .Little);
},
elf.R_X86_64_32 => try cwriter.writeIntLittle(u32, @as(u32, @truncate(@as(u64, @intCast(S + A))))),
elf.R_X86_64_32S => try cwriter.writeIntLittle(i32, @as(i32, @truncate(S + A))),
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.writeIntLittle(i32, @as(i32, @truncate(S + A - TP))),
elf.R_X86_64_TPOFF64 => try cwriter.writeIntLittle(i64, S + A - TP),
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.writeIntLittle(i32, @as(i32, @truncate(S + A - DTP))),
elf.R_X86_64_DTPOFF64 => try cwriter.writeIntLittle(i64, S + A - DTP),
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.writeIntLittle(i32, @as(i32, @intCast(S_ + A - P)));
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.writeIntLittle(i32, @as(i32, @intCast(S_ + A - P)));
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.writeIntLittle(i32, @as(i32, @intCast(S_ + A - P)));
try cwriter.writeInt(i32, @as(i32, @intCast(S_ + A - P)), .Little);
} else {
try x86_64.relaxGotPcTlsDesc(code[r_offset - 3 ..]);
try cwriter.writeIntLittle(i32, @as(i32, @intCast(S - TP)));
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.writeIntLittle(i32, @as(i32, @intCast(S_ + A - P)));
try cwriter.writeInt(i32, @as(i32, @intCast(S_ + A - P)), .Little);
} else {
x86_64.relaxGotTpOff(code[r_offset - 3 ..]) catch unreachable;
try cwriter.writeIntLittle(i32, @as(i32, @intCast(S - TP)));
try cwriter.writeInt(i32, @as(i32, @intCast(S - TP)), .Little);
}
},
elf.R_X86_64_GOT32 => try cwriter.writeIntLittle(i32, @as(i32, @intCast(G + GOT + A))),
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.writeIntLittle(u32, @as(u32, @intCast(ZIG_GOT + A))),
Elf.R_X86_64_ZIG_GOTPCREL => try cwriter.writeIntLittle(i32, @as(i32, @intCast(ZIG_GOT + A - P))),
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.writeIntLittle(i32, @as(i32, @truncate(S + A))),
=> 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.writeIntLittle(i32, @as(i32, @truncate(S + A)));
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.writeIntLittle(i32, @as(i32, @truncate(S + A)));
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.writeIntLittle(i64, value);
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.writeIntLittle(u8, @as(u8, @bitCast(@as(i8, @intCast(S + A))))),
elf.R_X86_64_16 => try cwriter.writeIntLittle(u16, @as(u16, @bitCast(@as(i16, @intCast(S + A))))),
elf.R_X86_64_32 => try cwriter.writeIntLittle(u32, @as(u32, @bitCast(@as(i32, @intCast(S + A))))),
elf.R_X86_64_32S => try cwriter.writeIntLittle(i32, @as(i32, @intCast(S + A))),
elf.R_X86_64_64 => try cwriter.writeIntLittle(i64, S + A),
elf.R_X86_64_DTPOFF32 => try cwriter.writeIntLittle(i32, @as(i32, @intCast(S + A - DTP))),
elf.R_X86_64_DTPOFF64 => try cwriter.writeIntLittle(i64, S + A - DTP),
elf.R_X86_64_GOTOFF64 => try cwriter.writeIntLittle(i64, S + A - GOT),
elf.R_X86_64_GOTPC64 => try cwriter.writeIntLittle(i64, GOT + A),
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.writeIntLittle(u32, @as(u32, @bitCast(@as(i32, @intCast(size + A)))));
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.writeIntLittle(i64, @as(i64, @intCast(size + A)));
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.writeIntLittle(i32, insts[12..][0..4], value - 12);
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.writeIntLittle(i32, insts[8..][0..4], value);
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.writeIntLittle(i32, insts[8..][0..4], value);
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.writeIntLittle(i32, insts[12..][0..4], value);
std.mem.writeInt(i32, insts[12..][0..4], value, .Little);
try stream.seekBy(-4);
try writer.writeAll(&insts);
relocs_log.debug(" relaxing {} and {}", .{

28
src/link/Elf/eh_frame.zig
View File

@@ -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.readIntLittle(u32, fde_data[4..8]);
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.readIntLittle(u32);
var size = try reader.readInt(u32, .Little);
if (size == 0xFFFFFFFF) @panic("TODO");
const id = try reader.readIntLittle(u32);
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.writeIntLittle(i32, where[0..4], @as(i32, @truncate(S + A))),
elf.R_X86_64_64 => std.mem.writeIntLittle(i64, where[0..8], S + A),
elf.R_X86_64_PC32 => std.mem.writeIntLittle(i32, where[0..4], @as(i32, @intCast(S - P + A))),
elf.R_X86_64_PC64 => std.mem.writeIntLittle(i64, where[0..8], S - P + A),
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,
}
}
@@ -338,10 +338,11 @@ pub fn writeEhFrame(elf_file: *Elf, writer: anytype) !void {
const contents = try gpa.dupe(u8, fde.data(elf_file));
defer gpa.free(contents);
std.mem.writeIntLittle(
std.mem.writeInt(
i32,
contents[4..8],
@as(i32, @truncate(@as(i64, @intCast(fde.out_offset + 4)) - @as(i64, @intCast(fde.cie(elf_file).out_offset)))),
@truncate(@as(i64, @intCast(fde.out_offset + 4)) - @as(i64, @intCast(fde.cie(elf_file).out_offset))),
.Little,
);
for (fde.relocs(elf_file)) |rel| {
@@ -353,7 +354,7 @@ pub fn writeEhFrame(elf_file: *Elf, writer: anytype) !void {
}
}
try writer.writeIntLittle(u32, 0);
try writer.writeInt(u32, 0, .Little);
}
pub fn writeEhFrameHdr(elf_file: *Elf, writer: anytype) !void {
@@ -365,14 +366,15 @@ pub fn writeEhFrameHdr(elf_file: *Elf, writer: anytype) !void {
const eh_frame_shdr = elf_file.shdrs.items[elf_file.eh_frame_section_index.?];
const eh_frame_hdr_shdr = elf_file.shdrs.items[elf_file.eh_frame_hdr_section_index.?];
const num_fdes = @as(u32, @intCast(@divExact(eh_frame_hdr_shdr.sh_size - eh_frame_hdr_header_size, 8)));
try writer.writeIntLittle(
try writer.writeInt(
u32,
@as(u32, @bitCast(@as(
i32,
@truncate(@as(i64, @intCast(eh_frame_shdr.sh_addr)) - @as(i64, @intCast(eh_frame_hdr_shdr.sh_addr)) - 4),
))),
.Little,
);
try writer.writeIntLittle(u32, num_fdes);
try writer.writeInt(u32, num_fdes, .Little);
const Entry = struct {
init_addr: u32,
@@ -401,7 +403,7 @@ pub fn writeEhFrameHdr(elf_file: *Elf, writer: anytype) !void {
const S = @as(i64, @intCast(sym.address(.{}, elf_file)));
const A = rel.r_addend;
entries.appendAssumeCapacity(.{
.init_addr = @as(u32, @bitCast(@as(i32, @truncate(S + A - @as(i64, @intCast(eh_frame_hdr_shdr.sh_addr)))))),
.init_addr = @bitCast(@as(i32, @truncate(S + A - @as(i64, @intCast(eh_frame_hdr_shdr.sh_addr))))),
.fde_addr = @as(
u32,
@bitCast(@as(i32, @truncate(P - @as(i64, @intCast(eh_frame_hdr_shdr.sh_addr))))),

30
src/link/Elf/synthetic_sections.zig
View File

@@ -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.writeIntLittle(i32, preamble[8..][0..4], @as(i32, @intCast(disp)));
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.writeIntLittle(i32, preamble[14..][0..4], @as(i32, @intCast(disp)));
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.writeIntLittle(i32, entry[6..][0..4], @as(i32, @intCast(i)));
mem.writeIntLittle(i32, entry[12..][0..4], @as(i32, @intCast(disp)));
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.writeIntLittle(u64, symbol.value);
try writer.writeInt(u64, symbol.value, .Little);
}
// [1]: 0x0
// [2]: 0x0
try writer.writeIntLittle(u64, 0x0);
try writer.writeIntLittle(u64, 0x0);
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.writeIntLittle(u64, plt_addr);
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.writeIntLittle(i32, entry[6..][0..4], @as(i32, @intCast(disp)));
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).writeIntLittle(u32, @as(u32, @intCast(nsyms))) catch unreachable;
hs.buffer.writer(gpa).writeIntLittle(u32, @as(u32, @intCast(nsyms))) 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.writeIntLittle(u32, hash.num_buckets);
try cwriter.writeIntLittle(u32, export_off);
try cwriter.writeIntLittle(u32, hash.num_bloom);
try cwriter.writeIntLittle(u32, bloom_shift);
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);

14
src/link/MachO.zig
View File

@@ -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.writeIntLittle(u64, &buf, entry_value);
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.writeIntLittle(u64, &buf, stub_helper_addr);
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.readIntLittle(i64, code[rel_offset..][0..8]);
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.writeIntLittle(u32, iundefsym + ctx.imports_table.get(entry).?);
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.writeIntLittle(u32, iundefsym + ctx.imports_table.get(entry).?);
try writer.writeInt(u32, iundefsym + ctx.imports_table.get(entry).?, .Little);
} else {
try writer.writeIntLittle(u32, macho.INDIRECT_SYMBOL_LOCAL);
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.writeIntLittle(u32, iundefsym + ctx.imports_table.get(entry).?);
try writer.writeInt(u32, iundefsym + ctx.imports_table.get(entry).?, .Little);
}
}

8
src/link/MachO/Archive.zig
View File

@@ -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.readIntLittle(u32);
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.readIntLittle(u32);
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.readIntLittle(u32) 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.readIntLittle(u32);
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);

52
src/link/MachO/Atom.zig
View File

@@ -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.readIntLittle(u64, ctx.code[rel_offset..][0..8])
mem.readInt(u64, ctx.code[rel_offset..][0..8], .Little)
else
mem.readIntLittle(u32, ctx.code[rel_offset..][0..4]);
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.readIntLittle(i32, ctx.code[rel_offset..][0..4]);
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.writeIntLittle(u32, code, inst.toU32());
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.writeIntLittle(u32, code, inst.toU32());
mem.writeInt(u32, code, inst.toU32(), .Little);
addend = null;
},
@@ -821,7 +821,7 @@ fn resolveRelocsArm64(
), code),
};
inst.add_subtract_immediate.imm12 = off;
mem.writeIntLittle(u32, code, inst.toU32());
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.writeIntLittle(u32, code, inst.toU32());
mem.writeInt(u32, code, inst.toU32(), .Little);
}
addend = null;
},
@@ -858,7 +858,7 @@ fn resolveRelocsArm64(
), code),
};
inst.load_store_register.offset = off;
mem.writeIntLittle(u32, code, inst.toU32());
mem.writeInt(u32, code, inst.toU32(), .Little);
addend = null;
},
@@ -918,7 +918,7 @@ fn resolveRelocsArm64(
.sf = @as(u1, @truncate(reg_info.size)),
},
};
mem.writeIntLittle(u32, code, inst.toU32());
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.writeIntLittle(u32, atom_code[rel_offset..][0..4], @as(u32, @bitCast(result)));
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.readIntLittle(i64, atom_code[rel_offset..][0..8])
mem.readInt(i64, atom_code[rel_offset..][0..8], .Little)
else
mem.readIntLittle(i32, atom_code[rel_offset..][0..4]);
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.writeIntLittle(u64, atom_code[rel_offset..][0..8], @as(u64, @bitCast(result)));
mem.writeInt(u64, atom_code[rel_offset..][0..8], @as(u64, @bitCast(result)), .Little);
} else {
mem.writeIntLittle(u32, atom_code[rel_offset..][0..4], @as(u32, @truncate(@as(u64, @bitCast(result)))));
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.readIntLittle(i32, atom_code[rel_offset..][0..4]);
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.writeIntLittle(i32, atom_code[rel_offset..][0..4], disp);
mem.writeInt(i32, atom_code[rel_offset..][0..4], disp, .Little);
},
.X86_64_RELOC_GOT,
.X86_64_RELOC_GOT_LOAD,
=> {
const addend = mem.readIntLittle(i32, atom_code[rel_offset..][0..4]);
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.writeIntLittle(i32, atom_code[rel_offset..][0..4], disp);
mem.writeInt(i32, atom_code[rel_offset..][0..4], disp, .Little);
},
.X86_64_RELOC_TLV => {
const addend = mem.readIntLittle(i32, atom_code[rel_offset..][0..4]);
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.writeIntLittle(i32, atom_code[rel_offset..][0..4], disp);
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.readIntLittle(i32, atom_code[rel_offset..][0..4]) + 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.writeIntLittle(i32, atom_code[rel_offset..][0..4], disp);
mem.writeInt(i32, atom_code[rel_offset..][0..4], disp, .Little);
},
.X86_64_RELOC_UNSIGNED => {
var addend = if (rel.r_length == 3)
mem.readIntLittle(i64, atom_code[rel_offset..][0..8])
mem.readInt(i64, atom_code[rel_offset..][0..8], .Little)
else
mem.readIntLittle(i32, atom_code[rel_offset..][0..4]);
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.writeIntLittle(u64, atom_code[rel_offset..][0..8], @as(u64, @bitCast(result)));
mem.writeInt(u64, atom_code[rel_offset..][0..8], @as(u64, @bitCast(result)), .Little);
} else {
mem.writeIntLittle(u32, atom_code[rel_offset..][0..4], @as(u32, @truncate(@as(u64, @bitCast(result)))));
mem.writeInt(u32, atom_code[rel_offset..][0..4], @as(u32, @truncate(@as(u64, @bitCast(result)))), .Little);
}
subtractor = null;

58
src/link/MachO/CodeSignature.zig
View File

@@ -115,14 +115,14 @@ pub fn writeAdhocSignature(
self.code_directory.inner.length = self.code_directory.size();
header.length += self.code_directory.size();
try writer.writeIntBig(u32, header.magic);
try writer.writeIntBig(u32, header.length);
try writer.writeIntBig(u32, header.count);
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.writeIntBig(u32, blob.slotType());
try writer.writeIntBig(u32, offset);
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.writeIntBig(u32, self.inner.magic);
try writer.writeIntBig(u32, self.inner.length);
try writer.writeIntBig(u32, self.inner.version);
try writer.writeIntBig(u32, self.inner.flags);
try writer.writeIntBig(u32, self.inner.hashOffset);
try writer.writeIntBig(u32, self.inner.identOffset);
try writer.writeIntBig(u32, self.inner.nSpecialSlots);
try writer.writeIntBig(u32, self.inner.nCodeSlots);
try writer.writeIntBig(u32, self.inner.codeLimit);
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.writeIntBig(u32, self.inner.spare2);
try writer.writeIntBig(u32, self.inner.scatterOffset);
try writer.writeIntBig(u32, self.inner.teamOffset);
try writer.writeIntBig(u32, self.inner.spare3);
try writer.writeIntBig(u64, self.inner.codeLimit64);
try writer.writeIntBig(u64, self.inner.execSegBase);
try writer.writeIntBig(u64, self.inner.execSegLimit);
try writer.writeIntBig(u64, self.inner.execSegFlags);
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.writeIntBig(u32, macho.CSMAGIC_REQUIREMENTS);
try writer.writeIntBig(u32, self.size());
try writer.writeIntBig(u32, 0);
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.writeIntBig(u32, macho.CSMAGIC_EMBEDDED_ENTITLEMENTS);
try writer.writeIntBig(u32, self.size());
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.writeIntBig(u32, macho.CSMAGIC_BLOBWRAPPER);
try writer.writeIntBig(u32, self.size());
try writer.writeInt(u32, macho.CSMAGIC_BLOBWRAPPER, .Big);
try writer.writeInt(u32, self.size(), .Big);
}
};

34
src/link/MachO/DwarfInfo.zig
View File

@@ -121,19 +121,19 @@ pub const CompileUnit = struct {
address_size: u8,
fn read(reader: anytype) !Header {
var length: u64 = try reader.readIntLittle(u32);
var length: u64 = try reader.readInt(u32, .Little);
const is_64bit = length == 0xffffffff;
if (is_64bit) {
length = try reader.readIntLittle(u64);
length = try reader.readInt(u64, .Little);
}
const version = try reader.readIntLittle(u16);
const version = try reader.readInt(u16, .Little);
const debug_abbrev_offset = if (is_64bit)
try reader.readIntLittle(u64)
try reader.readInt(u64, .Little)
else
try reader.readIntLittle(u32);
const address_size = try reader.readIntLittle(u8);
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.readIntLittle(u64, debug_info[0..8])
mem.readInt(u64, debug_info[0..8], .Little)
else
mem.readIntLittle(u32, debug_info[0..4]);
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.readIntLittle(u16, debug_info[0..2]),
dwarf.FORM.data4 => mem.readIntLittle(u32, debug_info[0..4]),
dwarf.FORM.data8 => mem.readIntLittle(u64, debug_info[0..8]),
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.readIntLittle(u16, debug_info[0..2]),
4 => mem.readIntLittle(u32, debug_info[0..4]),
8 => mem.readIntLittle(u64, debug_info[0..8]),
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.readIntLittle(u8),
dwarf.FORM.block2 => try reader.readIntLittle(u16),
dwarf.FORM.block4 => try reader.readIntLittle(u32),
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,
};

18
src/link/MachO/Relocation.zig
View File

@@ -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.writeIntLittle(u32, buffer[0..4], inst.toU32());
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.writeIntLittle(u32, buffer[0..4], inst.toU32());
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.writeIntLittle(u32, buffer[0..4], inst.toU32());
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.writeIntLittle(u32, buffer[0..4], inst.toU32());
mem.writeInt(u32, buffer[0..4], inst.toU32(), .Little);
}
},
.tlv_initializer, .unsigned => switch (self.length) {
2 => mem.writeIntLittle(u32, buffer[0..4], @as(u32, @truncate(@as(u64, @bitCast(target_addr))))),
3 => mem.writeIntLittle(u64, buffer[0..8], @as(u64, @bitCast(target_addr))),
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.writeIntLittle(u32, code[self.offset..][0..4], @as(u32, @bitCast(displacement)));
mem.writeInt(u32, code[self.offset..][0..4], @as(u32, @bitCast(displacement)), .Little);
},
.tlv_initializer, .unsigned => {
switch (self.length) {
2 => {
mem.writeIntLittle(u32, code[self.offset..][0..4], @as(u32, @truncate(@as(u64, @bitCast(target_addr)))));
mem.writeInt(u32, code[self.offset..][0..4], @as(u32, @truncate(@as(u64, @bitCast(target_addr)))), .Little);
},
3 => {
mem.writeIntLittle(u64, code[self.offset..][0..8], @as(u64, @bitCast(target_addr)));
mem.writeInt(u64, code[self.offset..][0..8], @as(u64, @bitCast(target_addr)), .Little);
},
else => unreachable,
}

2
src/link/MachO/UnwindInfo.zig
View File

@@ -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.writeIntLittle(u32, enc);
try writer.writeInt(u32, enc, .Little);
}
assert(page.count > 0);

52
src/link/MachO/eh_frame.zig
View File

@@ -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.writeIntLittle(u32, record.size);
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.readIntLittle(i64, rec.data[4..][0..8]);
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.writeIntLittle(i64, rec.data[4..][0..8], addend);
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.writeIntLittle(i32, rec.data[rel_offset..][0..4], result);
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.writeIntLittle(i64, rec.data[rel_offset..][0..8], @as(i64, @intCast(result)));
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.readIntLittle(i32, rec.data[rel_offset..][0..4]);
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.writeIntLittle(i32, rec.data[rel_offset..][0..4], disp);
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.readIntLittle(u32, rec.data[0..4]);
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.readIntLittle(u32, rec.data[0..4]);
return mem.readInt(u32, rec.data[0..4], .Little);
}
pub fn setCiePointer(rec: *Record, ptr: u32) void {
assert(rec.tag == .fde);
mem.writeIntLittle(u32, rec.data[0..4], ptr);
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.readIntLittle(u64))),
EH_PE.udata2 => @as(i16, @bitCast(try reader.readIntLittle(u16))),
EH_PE.udata4 => @as(i32, @bitCast(try reader.readIntLittle(u32))),
EH_PE.udata8 => @as(i64, @bitCast(try reader.readIntLittle(u64))),
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.readIntLittle(i16),
EH_PE.sdata4 => try reader.readIntLittle(i32),
EH_PE.sdata8 => try reader.readIntLittle(i64),
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.writeIntLittle(u64, @as(u64, @bitCast(actual))),
EH_PE.udata2 => try writer.writeIntLittle(u16, @as(u16, @bitCast(@as(i16, @intCast(actual))))),
EH_PE.udata4 => try writer.writeIntLittle(u32, @as(u32, @bitCast(@as(i32, @intCast(actual))))),
EH_PE.udata8 => try writer.writeIntLittle(u64, @as(u64, @bitCast(actual))),
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.writeIntLittle(i16, @as(i16, @intCast(actual))),
EH_PE.sdata4 => try writer.writeIntLittle(i32, @as(i32, @intCast(actual))),
EH_PE.sdata8 => try writer.writeIntLittle(i64, 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.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.readIntLittle(u32);
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.readIntLittle(u32);
const id = try reader.readInt(u32, .Little);
const tag: EhFrameRecordTag = if (id == 0) .cie else .fde;
const offset: u32 = 4;
const record = EhFrameRecord(false){

38
src/link/MachO/stubs.zig
View File

@@ -53,7 +53,7 @@ pub fn writeStubHelperPreambleCode(args: struct {
args.dyld_private_addr,
0,
);
try writer.writeIntLittle(i32, disp);
try writer.writeInt(i32, disp, .Little);
}
try writer.writeAll(&.{ 0x41, 0x53, 0xff, 0x25 });
{
@@ -62,37 +62,37 @@ pub fn writeStubHelperPreambleCode(args: struct {
args.dyld_stub_binder_got_addr,
0,
);
try writer.writeIntLittle(i32, disp);
try writer.writeInt(i32, disp, .Little);
}
},
.aarch64 => {
{
const pages = Relocation.calcNumberOfPages(args.source_addr, args.dyld_private_addr);
try writer.writeIntLittle(u32, aarch64.Instruction.adrp(.x17, pages).toU32());
try writer.writeInt(u32, aarch64.Instruction.adrp(.x17, pages).toU32(), .Little);
}
{
const off = try Relocation.calcPageOffset(args.dyld_private_addr, .arithmetic);
try writer.writeIntLittle(u32, aarch64.Instruction.add(.x17, .x17, off, false).toU32());
try writer.writeInt(u32, aarch64.Instruction.add(.x17, .x17, off, false).toU32(), .Little);
}
try writer.writeIntLittle(u32, aarch64.Instruction.stp(
try writer.writeInt(u32, aarch64.Instruction.stp(
.x16,
.x17,
aarch64.Register.sp,
aarch64.Instruction.LoadStorePairOffset.pre_index(-16),
).toU32());
).toU32(), .Little);
{
const pages = Relocation.calcNumberOfPages(args.source_addr + 12, args.dyld_stub_binder_got_addr);
try writer.writeIntLittle(u32, aarch64.Instruction.adrp(.x16, pages).toU32());
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);
try writer.writeIntLittle(u32, aarch64.Instruction.ldr(
try writer.writeInt(u32, aarch64.Instruction.ldr(
.x16,
.x16,
aarch64.Instruction.LoadStoreOffset.imm(off),
).toU32());
).toU32(), .Little);
}
try writer.writeIntLittle(u32, aarch64.Instruction.br(.x16).toU32());
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.writeIntLittle(i32, disp);
try writer.writeInt(i32, disp, .Little);
}
},
.aarch64 => {
@@ -117,13 +117,13 @@ pub fn writeStubHelperCode(args: struct {
const div_res = try std.math.divExact(u64, stub_size - @sizeOf(u32), 4);
break :blk std.math.cast(u18, div_res) orelse return error.Overflow;
};
try writer.writeIntLittle(u32, aarch64.Instruction.ldrLiteral(
try writer.writeInt(u32, aarch64.Instruction.ldrLiteral(
.w16,
literal,
).toU32());
).toU32(), .Little);
{
const disp = try Relocation.calcPcRelativeDisplacementArm64(args.source_addr + 4, args.target_addr);
try writer.writeIntLittle(u32, aarch64.Instruction.b(disp).toU32());
try writer.writeInt(u32, aarch64.Instruction.b(disp).toU32(), .Little);
}
try writer.writeAll(&.{ 0x0, 0x0, 0x0, 0x0 });
},
@@ -141,23 +141,23 @@ 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.writeIntLittle(i32, disp);
try writer.writeInt(i32, disp, .Little);
}
},
.aarch64 => {
{
const pages = Relocation.calcNumberOfPages(args.source_addr, args.target_addr);
try writer.writeIntLittle(u32, aarch64.Instruction.adrp(.x16, pages).toU32());
try writer.writeInt(u32, aarch64.Instruction.adrp(.x16, pages).toU32(), .Little);
}
{
const off = try Relocation.calcPageOffset(args.target_addr, .load_store_64);
try writer.writeIntLittle(u32, aarch64.Instruction.ldr(
try writer.writeInt(u32, aarch64.Instruction.ldr(
.x16,
.x16,
aarch64.Instruction.LoadStoreOffset.imm(off),
).toU32());
).toU32(), .Little);
}
try writer.writeIntLittle(u32, aarch64.Instruction.br(.x16).toU32());
try writer.writeInt(u32, aarch64.Instruction.br(.x16).toU32(), .Little);
},
else => unreachable,
}

6
src/link/MachO/thunks.zig
View File

@@ -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.writeIntLittle(u32, aarch64.Instruction.adrp(.x16, pages).toU32());
try writer.writeInt(u32, aarch64.Instruction.adrp(.x16, pages).toU32(), .Little);
const off = try Relocation.calcPageOffset(target_addr, .arithmetic);
try writer.writeIntLittle(u32, aarch64.Instruction.add(.x16, .x16, off, false).toU32());
try writer.writeIntLittle(u32, aarch64.Instruction.br(.x16).toU32());
try writer.writeInt(u32, aarch64.Instruction.add(.x16, .x16, off, false).toU32(), .Little);
try writer.writeInt(u32, aarch64.Instruction.br(.x16).toU32(), .Little);
}
}

4
src/link/MachO/zld.zig
View File

@@ -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().writeIntLittle(u64, sym.n_value) 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().writeIntLittle(u64, target_addr) catch unreachable;
buffer.writer().writeInt(u64, target_addr, .Little) catch unreachable;
}
log.debug("writing __DATA,__la_symbol_ptr contents at file offset 0x{x}", .{

14
src/link/Plan9.zig
View File

@@ -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().writeIntBig(u16, 1);
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().writeIntBig(u16, num);
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().writeIntBig(u16, self.file_segments_i);
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().writeIntBig(i32, delta_line);
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.writeIntSliceBig(u64, hdr_buf[32..40], self.entry_val.?);
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.writeIntBig(u32, @as(u32, @intCast(sym.value)));
try w.writeInt(u32, @as(u32, @intCast(sym.value)), .Big);
} else {
try w.writeIntBig(u64, sym.value);
try w.writeInt(u64, sym.value, .Big);
}
try w.writeByte(@intFromEnum(sym.type));
try w.writeAll(sym.name);

2
src/link/Plan9/aout.zig
View File

@@ -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.writeIntSliceBig(u32, buf[i..][0..4], @field(self, f.name));
std.mem.writeInt(u32, buf[i..][0..4], @field(self, f.name), .Big);
i += 4;
}
return buf;

10
src/link/Wasm.zig
View File

@@ -2371,7 +2371,7 @@ fn setupErrorsLen(wasm: *Wasm) !void {
atom.deinit(wasm);
break :blk index;
} else new_atom: {
const atom_index = @as(Atom.Index, @intCast(wasm.managed_atoms.items.len));
const atom_index: Atom.Index = @intCast(wasm.managed_atoms.items.len);
try wasm.symbol_atom.put(wasm.base.allocator, loc, atom_index);
try wasm.managed_atoms.append(wasm.base.allocator, undefined);
break :new_atom atom_index;
@@ -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).writeIntLittle(u16, @as(u16, @intCast(errors_len)));
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).writeIntLittle(u32, len - 1);
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.writeIntLittle(u32, @as(u32, @bitCast(val)));
try writer.writeInt(u32, @bitCast(val), .Little);
},
.f64_const => |val| {
try writer.writeByte(std.wasm.opcode(.f64_const));
try writer.writeIntLittle(u64, @as(u64, @bitCast(val)));
try writer.writeInt(u64, @bitCast(val), .Little);
},
.global_get => |val| {
try writer.writeByte(std.wasm.opcode(.global_get));

4
src/link/Wasm/Archive.zig
View File

@@ -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.readIntBig(u32);
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.readIntBig(u32);
index.* = try reader.readInt(u32, .Big);
}
const sym_tab = try allocator.alloc(u8, sym_tab_size - 4 - (4 * num_symbols));

4
src/link/Wasm/Atom.zig
View File

@@ -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.writeIntLittle(u32, atom.code.items[reloc.offset..][0..4], @as(u32, @intCast(value))),
=> 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.writeIntLittle(u64, atom.code.items[reloc.offset..][0..8], value),
=> 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,

2
src/link/Wasm/Object.zig
View File

@@ -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().readIntLittle(u32);
const version = try parser.reader.reader().readInt(u32, .Little);
parser.object.version = version;
var relocatable_data = std.ArrayList(RelocatableData).init(gpa);

4
src/resinator/ani.zig
View File

@@ -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.readIntLittle(u32); // 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.readIntLittle(u32);
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, .{});

Some files were not shown because too many files have changed in this diff Show More