srctree

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)}),

.global_get => try writer.print("global.get {x}\n", .{try std.leb.readULEB128(u32, reader)}),

else => unreachable,

}

 

var idx: usize = 0;

var out_idx: usize = 0;

while (idx + 15 < source.len) : (idx += 12) {

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) {

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];

if ((new_bits & invalid_char_tst) != 0) return error.InvalidCharacter;

bits |= (new_bits << (24 * i));

}

}

while (fast_src_idx + 4 < source.len and dest_idx + 3 < dest.len) : ({

fast_src_idx += 4;

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;

}

var remaining = source[fast_src_idx..];

for (remaining, fast_src_idx..) |c, src_idx| {

 

.capable_io_mode = .blocking,

.intended_io_mode = .blocking,

};

}

 

fn readIntFd(fd: i32) !ErrInt {

.capable_io_mode = .blocking,

.intended_io_mode = .blocking,

};

}

 

/// Caller must free result.

 

 

pub fn getNameOffset(self: Symbol) ?u32 {

if (!std.mem.eql(u8, self.name[0..4], "\x00\x00\x00\x00")) return null;

return offset;

}

};

var stream = std.io.fixedBufferStream(data);

const reader = stream.reader();

try stream.seekTo(pe_pointer_offset);

try stream.seekTo(coff_header_offset);

var buf: [4]u8 = undefined;

try reader.readNoEof(&buf);

if (!mem.eql(u8, &cv_signature, "RSDS"))

return error.InvalidPEMagic;

try reader.readNoEof(self.guid[0..]);

 

// Finally read the null-terminated string.

var byte = try reader.readByte();

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;

if ((offset + size) > self.data.len) return error.InvalidStrtabSize;

 

return Strtab{ .buffer = self.data[offset..][0..size] };

fn asSymbol(raw: []const u8) Symbol {

return .{

.name = raw[0..8].*,

.storage_class = @as(StorageClass, @enumFromInt(raw[16])),

.number_of_aux_symbols = raw[17],

};

fn asDebugInfo(raw: []const u8) DebugInfoDefinition {

return .{

.unused_1 = raw[0..4].*,

.unused_2 = raw[6..12].*,

.unused_3 = raw[16..18].*,

};

}

 

fn asFuncDef(raw: []const u8) FunctionDefinition {

return .{

.unused = raw[16..18].*,

};

}

 

fn asWeakExtDef(raw: []const u8) WeakExternalDefinition {

return .{

.unused = raw[8..18].*,

};

}

 

fn asSectDef(raw: []const u8) SectionDefinition {

return .{

.selection = @as(ComdatSelection, @enumFromInt(raw[14])),

.unused = raw[15..18].*,

};

 

const FLG = header[3];

// Modification time, as a Unix timestamp.

// If zero there's no timestamp available.

// Extra flags

const XFL = header[8];

// Operating system where the compression took place

_ = XFL;

 

const extra = if (FLG & FEXTRA != 0) blk: {

const tmp_buf = try allocator.alloc(u8, len);

errdefer allocator.free(tmp_buf);

 

errdefer if (comment) |p| allocator.free(p);

 

if (FLG & FHCRC != 0) {

if (hash != @as(u16, @truncate(hasher.hasher.final())))

return error.WrongChecksum;

}

}

 

// We've reached the end of stream, check if the checksum matches

if (hash != self.hasher.final())

return error.WrongChecksum;

 

// The ISIZE field is the size of the uncompressed input modulo 2^32

if (self.read_amt & 0xffffffff != input_size)

return error.CorruptedData;

 

 

props /= 5;

const pb = @as(u3, @intCast(props));

 

const dict_size = @max(0x1000, dict_size_provided);

 

const unpacked_size = switch (options.unpacked_size) {

.read_from_header => blk: {

const marker_mandatory = unpacked_size_provided == 0xFFFF_FFFF_FFFF_FFFF;

break :blk if (marker_mandatory)

null

unpacked_size_provided;

},

.read_header_but_use_provided => |x| blk: {

break :blk x;

},

.use_provided => |x| x,

 

}

return RangeDecoder{

.range = 0xFFFF_FFFF,

};

}

 

 

const unpacked_size = blk: {

var tmp: u64 = status & 0x1F;

tmp <<= 16;

break :blk tmp + 1;

};

 

const packed_size = blk: {

break :blk tmp + 1;

};

 

accum: *LzAccumBuffer,

reset_dict: bool,

) !void {

 

if (reset_dict) {

try accum.reset(writer);

 

break :blk hasher.hasher.final();

};

 

if (hash_a != hash_b)

return error.WrongChecksum;

 

}

 

const hash_a = hasher.hasher.final();

if (hash_a != hash_b)

return error.WrongChecksum;

 

break :blk counter.bytes_read;

};

 

 

const hash_b = blk: {

var hasher = std.compress.hashedReader(self.in_reader, Crc32.init());

const hashed_reader = hasher.reader();

 

if (backward_size != index_size)

return error.CorruptInput;

 

 

}

 

const hash_a = header_hasher.hasher.final();

if (hash_a != hash_b)

return error.WrongChecksum;

}

.none => {},

.crc32 => {

const hash_a = Crc32.hash(unpacked_bytes);

if (hash_a != hash_b)

return error.WrongChecksum;

},

.crc64 => {

const hash_a = Crc64.hash(unpacked_bytes);

if (hash_a != hash_b)

return error.WrongChecksum;

},

 

 

fn init(allocator: mem.Allocator, source: ReaderType) !Self {

// Zlib header format is specified in RFC1950

 

// verify the header checksum

if (header_u16 % 31 != 0)

}

 

// We've reached the end of stream, check if the checksum matches

if (hash != self.hasher.final())

return error.WrongChecksum;

 

};

header.checksum = @as(u5, @truncate(31 - @as(u16, @bitCast(header)) % 31));

 

 

const compression_level: deflate.Compression = switch (options.level) {

.no_compression => .no_compression,

pub fn finish(self: *Self) !void {

const hash = self.hasher.final();

try self.deflator.close();

}

};

}

 

if (block_header.last_block) {

self.state = .LastBlock;

if (self.frame_context.has_checksum) {

return error.MalformedFrame;

if (comptime options.verify_checksum) {

if (self.frame_context.hasher_opt) |*hasher| {

 

 

const decodeFseTable = @import("fse.zig").decodeFseTable;

 

pub const Error = error{

BlockSizeOverMaximum,

MalformedBlockSize,

 

if (stream_data.len < 6) return error.MalformedLiteralsSection;

 

 

const stream_1_start = 6;

const stream_2_start = stream_1_start + stream_1_length;

 

 

const readers = @import("readers.zig");

 

/// 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;

/// skippable frames.

/// - `error.EndOfStream` if `source` contains fewer than 4 bytes

pub fn decodeFrameType(source: anytype) error{ BadMagic, EndOfStream }!frame.Kind {

return frameType(magic);

}

 

/// - `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 frame_type = try frameType(magic);

switch (frame_type) {

.zstandard => return FrameHeader{ .zstandard = try decodeZstandardHeader(source) },

.skippable => return FrameHeader{

.skippable = .{

.magic_number = magic,

},

},

}

switch (try decodeFrameType(fbs.reader())) {

.zstandard => return decodeZstandardFrame(dest, src, verify_checksum),

.skippable => {

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;

) (error{ BadMagic, OutOfMemory, SkippableSizeTooLarge } || FrameContext.Error || FrameError)!usize {

var fbs = std.io.fixedBufferStream(src);

const reader = fbs.reader();

switch (try frameType(magic)) {

.zstandard => return decodeZstandardFrameArrayList(

allocator,

window_size_max,

),

.skippable => {

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;

WindowSizeUnknown,

DictionaryIdFlagUnsupported,

} || FrameError)!ReadWriteCount {

var consumed_count: usize = 4;

 

var frame_context = context: {

if (written_count != content_size) return error.BadContentSize;

if (frame_context.has_checksum) {

if (src.len < consumed_count + 4) return error.EndOfStream;

consumed_count += 4;

if (frame_context.hasher_opt) |*hasher| {

if (checksum != computeChecksum(hasher)) return error.ChecksumFailure;

verify_checksum: bool,

window_size_max: usize,

) (error{OutOfMemory} || FrameContext.Error || FrameError)!usize {

var consumed_count: usize = 4;

 

var frame_context = context: {

 

if (frame_context.has_checksum) {

if (src.len < consumed_count + 4) return error.EndOfStream;

consumed_count += 4;

if (frame_context.hasher_opt) |*hasher| {

if (checksum != computeChecksum(hasher)) return error.ChecksumFailure;

/// 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 {

assert(isSkippableMagic(magic));

return .{

.magic_number = magic,

.frame_size = frame_size,

 

const std = @import("std");

const builtin = @import("builtin");

const crypto = std.crypto;

 

const NonCanonicalError = crypto.errors.NonCanonicalError;

const NotSquareError = crypto.errors.NotSquareError;

/// Unpack a field element

pub fn fromBytes(s: [32]u8) Fe {

var fe: Fe = undefined;

 

return fe;

}

var reduced = fe;

reduced.reduce();

var s: [32]u8 = undefined;

 

return s;

}

 

 

const field_order_s = s: {

var s: [32]u8 = undefined;

break :s s;

};

 

var bytes: CompressedScalar = undefined;

var i: usize = 0;

while (i < 4) : (i += 1) {

}

return bytes;

}

 

var limbs: Limbs = undefined;

var i: usize = 0;

while (i < 9) : (i += 1) {

}

limbs[i] = @as(u64, bytes[i * 7]);

return ScalarDouble{ .limbs = limbs };

var limbs: Limbs = undefined;

var i: usize = 0;

while (i < 4) : (i += 1) {

}

@memset(limbs[5..], 0);

return ScalarDouble{ .limbs = limbs };

}

 

 

var table_idx: u32 = 0;

while (table_idx < table_list.len) : (table_idx += 1) {

}

 

const now_sec = std.time.timestamp();

 

var record_idx: u32 = 0;

while (record_idx < record_list.len) : (record_idx += 1) {

}

 

for (record_list) |record_offset| {

 

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;

const tmp = AesBlock.fromBytes(&sizes).xorBlocks(blocks[2]);

var i: usize = 0;

while (i < 7) : (i += 1) {

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;

const tmp = AesBlock.fromBytes(&sizes).xorBlocks(blocks[3]);

var i: usize = 0;

while (i < 7) : (i += 1) {

 

 

/// Convert a byte sequence into an internal representation.

pub inline fn fromBytes(bytes: *const [16]u8) Block {

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;

return bytes;

}

 

// 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)));

x = sbox_lookup(&sbox_encrypt, @as(u8, @truncate(s1)), @as(u8, @truncate(s2 >> 8)), @as(u8, @truncate(s3 >> 16)), @as(u8, @truncate(s0 >> 24)));

x = sbox_lookup(&sbox_encrypt, @as(u8, @truncate(s2)), @as(u8, @truncate(s3 >> 8)), @as(u8, @truncate(s0 >> 16)), @as(u8, @truncate(s1 >> 24)));

x = sbox_lookup(&sbox_encrypt, @as(u8, @truncate(s3)), @as(u8, @truncate(s0 >> 8)), @as(u8, @truncate(s1 >> 16)), @as(u8, @truncate(s2 >> 24)));

 

t0 ^= round_key.repr[0];

t1 ^= round_key.repr[1];

// 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)));

x = sbox_lookup(&sbox_decrypt, @as(u8, @truncate(s1)), @as(u8, @truncate(s0 >> 8)), @as(u8, @truncate(s3 >> 16)), @as(u8, @truncate(s2 >> 24)));

x = sbox_lookup(&sbox_decrypt, @as(u8, @truncate(s2)), @as(u8, @truncate(s1 >> 8)), @as(u8, @truncate(s0 >> 16)), @as(u8, @truncate(s3 >> 24)));

x = sbox_lookup(&sbox_decrypt, @as(u8, @truncate(s3)), @as(u8, @truncate(s2 >> 8)), @as(u8, @truncate(s1 >> 16)), @as(u8, @truncate(s0 >> 24)));

 

t0 ^= round_key.repr[0];

t1 ^= round_key.repr[1];

// 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)));

}

}.func;

 

var round_keys: [rounds + 1]Block = undefined;

comptime var i: usize = 0;

inline while (i < words_in_key) : (i += 1) {

}

inline while (i < round_keys.len * 4) : (i += 1) {

var t = round_keys[(i - 1) / 4].repr[(i - 1) % 4];

 

var t: [16]u8 = undefined;

var j: [16]u8 = undefined;

j[0..nonce_length].* = npub;

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;

mac.update(ad);

mac.pad();

 

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;

mac.update(&final_block);

mac.final(tag);

for (t, 0..) |x, i| {

var t: [16]u8 = undefined;

var j: [16]u8 = undefined;

j[0..nonce_length].* = npub;

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;

mac.pad();

 

var final_block = h;

mac.update(&final_block);

var computed_tag: [Ghash.mac_length]u8 = undefined;

mac.final(&computed_tag);

return error.AuthenticationFailed;

}

 

modes.ctr(@TypeOf(aes), aes, m, c, j, std.builtin.Endian.Big);

}

};

 

upto: usize,

 

inline fn double(l: Block) Block {

const l_2 = (l_ << 1) ^ (0x87 & -%(l_ >> 127));

var l2: Block = undefined;

return l2;

}

 

nx[15] &= 0xc0;

var ktop_: Block = undefined;

aes_enc_ctx.encrypt(&ktop_, &nx);

var stretch = (@as(u192, ktop) << 64) | @as(u192, @as(u64, @truncate(ktop >> 64)) ^ @as(u64, @truncate(ktop >> 56)));

var offset: Block = undefined;

return offset;

}

 

 

var parameters: [24]u8 = undefined;

var tmp: [4]u8 = undefined;

var b2 = Blake2b512.init(.{});

b2.update(&parameters);

b2.update(&tmp);

b2.update(password);

b2.update(&tmp);

b2.update(salt);

const secret = params.secret orelse "";

std.debug.assert(secret.len <= max_int);

b2.update(&tmp);

b2.update(secret);

const ad = params.ad orelse "";

std.debug.assert(ad.len <= max_int);

b2.update(&tmp);

b2.update(ad);

b2.final(h0[0..Blake2b512.digest_length]);

fn blake2bLong(out: []u8, in: []const u8) void {

const H = Blake2b512;

var outlen_bytes: [4]u8 = undefined;

 

var out_buf: [H.digest_length]u8 = undefined;

 

var lane: u24 = 0;

while (lane < threads) : (lane += 1) {

const j = lane * (memory / threads);

 

blake2bLong(&block0, h0);

for (&blocks.items[j + 0], 0..) |*v, i| {

}

 

blake2bLong(&block0, h0);

for (&blocks.items[j + 1], 0..) |*v, i| {

}

}

}

}

var block: [1024]u8 = undefined;

for (blocks.items[memory - 1], 0..) |v, i| {

}

blake2bLong(out, &block);

}

 

//! It is not meant to be used directly, but as a building block for symmetric cryptography.

 

const std = @import("std");

const debug = std.debug;

const mem = std.mem;

const testing = std.testing;

const rotr = std.math.rotr;

 

/// An Ascon state.

///

///

/// The NIST submission (v1.2) serializes these words as big-endian,

/// but software implementations are free to use native endianness.

return struct {

const Self = @This();

 

 

var i: usize = 0;

while (i + 8 <= in.len) : (i += 8) {

}

if (i < in.len) {

var padded = [_]u8{0} ** 8;

@memcpy(padded[0 .. in.len - i], in[i..]);

@memcpy(out[i..], padded[0 .. in.len - i]);

}

}

 

 

var ct: [ct_length]u8 = undefined;

for (cdata, 0..) |c, i| {

}

return ct[0..dk_length].*;

}

// copy out

var out: [32]u8 = undefined;

for (cdata, 0..) |v, i| {

}

 

// zap

 

d.buf_len = 0;

 

if (options.salt) |salt| {

}

if (options.context) |context| {

}

if (key_len > 0) {

@memset(d.buf[key_len..], 0);

var v: [16]u32 = undefined;

 

for (&m, 0..) |*r, i| {

}

 

var k: usize = 0;

d.buf_len = 0;

 

if (options.salt) |salt| {

}

if (options.context) |context| {

}

if (key_len > 0) {

@memset(d.buf[key_len..], 0);

var v: [16]u64 = undefined;

 

for (&m, 0..) |*r, i| {

}

 

var k: usize = 0;

 

fn wordsFromLittleEndianBytes(comptime count: usize, bytes: [count * 4]u8) [count]u32 {

var words: [count]u32 = undefined;

for (&words, 0..) |*word, i| {

}

return words;

}

var word_counter: usize = 0;

while (out_word_it.next()) |out_word| {

var word_bytes: [4]u8 = undefined;

@memcpy(out_word, word_bytes[0..out_word.len]);

word_counter += 1;

}

 

switch (degree) {

1 => {

const constant_le = Lane{

};

return BlockVec{

constant_le,

},

2 => {

const constant_le = Lane{

};

const n1 = @addWithOverflow(d[0], 1);

return BlockVec{

const n2 = @addWithOverflow(d[0], 2);

const n3 = @addWithOverflow(d[0], 3);

const constant_le = Lane{

};

return BlockVec{

constant_le,

inline fn hashToBytes(comptime dm: usize, out: *[64 * dm]u8, x: BlockVec) void {

for (0..dm) |d| {

for (0..4) |i| {

}

}

}

fn hchacha20(input: [16]u8, key: [32]u8) [32]u8 {

var c: [4]u32 = undefined;

for (c, 0..) |_, i| {

}

const ctx = initContext(keyToWords(key), c);

var x: BlockVec = undefined;

chacha20Core(x[0..], ctx);

var out: [32]u8 = undefined;

return out;

}

};

fn initContext(key: [8]u32, d: [4]u32) BlockVec {

const c = "expand 32-byte k";

const constant_le = comptime [4]u32{

};

return BlockVec{

constant_le[0], constant_le[1], constant_le[2], constant_le[3],

 

inline fn hashToBytes(out: *[64]u8, x: BlockVec) void {

for (0..4) |i| {

}

}

 

fn hchacha20(input: [16]u8, key: [32]u8) [32]u8 {

var c: [4]u32 = undefined;

for (c, 0..) |_, i| {

}

const ctx = initContext(keyToWords(key), c);

var x: BlockVec = undefined;

chacha20Core(x[0..], ctx);

var out: [32]u8 = undefined;

return out;

}

};

fn keyToWords(key: [32]u8) [8]u32 {

var k: [8]u32 = undefined;

for (0..8) |i| {

}

return k;

}

 

var d: [4]u32 = undefined;

d[0] = counter;

ChaChaImpl(rounds_nb).chacha20Xor(out, in, keyToWords(key), d, false);

}

 

 

var d: [4]u32 = undefined;

d[0] = counter;

ChaChaImpl(rounds_nb).chacha20Stream(out, keyToWords(key), d, false);

}

};

var c: [4]u32 = undefined;

c[0] = @as(u32, @truncate(counter));

c[1] = @as(u32, @truncate(counter >> 32));

ChaChaImpl(rounds_nb).chacha20Xor(out, in, k, c, true);

}

 

var c: [4]u32 = undefined;

c[0] = @as(u32, @truncate(counter));

c[1] = @as(u32, @truncate(counter >> 32));

ChaChaImpl(rounds_nb).chacha20Stream(out, k, c, true);

}

};

mac.update(zeros[0..padding]);

}

var lens: [16]u8 = undefined;

mac.update(lens[0..]);

mac.final(tag);

}

mac.update(zeros[0..padding]);

}

var lens: [16]u8 = undefined;

mac.update(lens[0..]);

var computed_tag: [16]u8 = undefined;

mac.final(computed_tag[0..]);

 

 

fn double(l: Block) Block {

const Int = std.meta.Int(.unsigned, block_length * 8);

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

else => @compileError("unsupported block length"),

};

var l2: Block = undefined;

return l2;

}

};

 

fn trickle(k: [16]u8, iv: [8]u8, y: []const u8, comptime out_len: usize) [out_len]u8 {

var isap = IsapA128A{

.st = Ascon.initFromWords(.{

0,

0,

}),

fn mac(c: []const u8, ad: []const u8, npub: [16]u8, key: [16]u8) [16]u8 {

var isap = IsapA128A{

.st = Ascon.initFromWords(.{

0,

0,

}),

const nb = trickle(key, iv3, npub[0..], 24);

var isap = IsapA128A{

.st = Ascon.initFromWords(.{

}),

};

isap.st.permuteR(6);

 

const std = @import("std");

const assert = std.debug.assert;

const math = std.math;

const mem = std.mem;

 

/// The Keccak-f permutation.

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| {

}

return self;

}

pub fn setBytes(self: *Self, bytes: []const u8) void {

var i: usize = 0;

while (i + @sizeOf(T) <= bytes.len) : (i += @sizeOf(T)) {

}

if (i < bytes.len) {

var padded = [_]u8{0} ** @sizeOf(T);

@memcpy(padded[0 .. bytes.len - i], bytes[i..]);

}

}

 

pub fn addBytes(self: *Self, bytes: []const u8) void {

var i: usize = 0;

while (i + @sizeOf(T) <= bytes.len) : (i += @sizeOf(T)) {

}

if (i < bytes.len) {

var padded = [_]u8{0} ** @sizeOf(T);

@memcpy(padded[0 .. bytes.len - i], bytes[i..]);

}

}

 

pub fn extractBytes(self: *Self, out: []u8) void {

var i: usize = 0;

while (i + @sizeOf(T) <= out.len) : (i += @sizeOf(T)) {

}

if (i < out.len) {

var padded = [_]u8{0} ** @sizeOf(T);

@memcpy(out[i..], padded[0 .. out.len - i]);

}

}

 

var i: usize = 0;

while (i + @sizeOf(T) <= in.len) : (i += @sizeOf(T)) {

}

if (i < in.len) {

var padded = [_]u8{0} ** @sizeOf(T);

@memcpy(padded[0 .. in.len - i], in[i..]);

@memcpy(out[i..], padded[0 .. in.len - i]);

}

}

 

d.round(d.buf[0..]);

 

for (d.s, 0..) |s, j| {

}

}

 

 

var i: usize = 0;

while (i < 16) : (i += 1) {

}

 

var v: [4]u32 = [_]u32{

 

var s = if (endian == .Little) s_ else orderSwap(s_);

const field_order_s = comptime fos: {

var fos: [encoded_length]u8 = undefined;

break :fos fos;

};

if (crypto.utils.timingSafeCompare(u8, &s, &field_order_s, .Little) != .lt) {

/// Create a field element from an integer.

pub fn fromInt(comptime x: IntRepr) NonCanonicalError!Fe {

var s: [encoded_length]u8 = undefined;

return fromBytes(s, .Little);

}

 

/// Return the field element as an integer.

pub fn toInt(fe: Fe) IntRepr {

const s = fe.toBytes(.Little);

}

 

/// Return true if the field element is zero.

 

 

const lambda_s = s: {

var buf: [32]u8 = undefined;

break :s buf;

};

 

pub fn splitScalar(s: [32]u8, endian: std.builtin.Endian) NonCanonicalError!SplitScalar {

const b1_neg_s = comptime s: {

var buf: [32]u8 = undefined;

break :s buf;

};

const b2_neg_s = comptime s: {

var buf: [32]u8 = undefined;

break :s buf;

};

const k = mem.readInt(u256, &s, endian);

 

var buf: [32]u8 = undefined;

 

const c1x = try scalar.mul(buf, b1_neg_s, .Little);

 

const c2x = try scalar.mul(buf, b2_neg_s, .Little);

 

const r2 = try scalar.add(c1x, c2x, .Little);

 

pub fn init(key: *const [key_length]u8) Poly1305 {

return Poly1305{

.r = [_]u64{

},

.pad = [_]u64{

},

};

}

var i: usize = 0;

 

while (i + block_length <= m.len) : (i += block_length) {

 

// Add the input message to H

var v = @addWithOverflow(h0, in0);

const c = ((h0 & st.pad[0]) | ((h0 | st.pad[0]) & ~st.h[0])) >> 63;

st.h[1] = h1 +% st.pad[1] +% c;

 

 

utils.secureZero(u8, @as([*]u8, @ptrCast(st))[0..@sizeOf(Poly1305)]);

}

 

fn initContext(key: [8]u32, d: [4]u32) BlockVec {

const c = "expand 32-byte k";

const constant_le = comptime [4]u32{

};

return BlockVec{

Lane{ key[0], key[1], key[2], key[3] },

fn hashToBytes(out: *[64]u8, x: BlockVec) void {

var i: usize = 0;

while (i < 4) : (i += 1) {

}

}

 

fn hsalsa(input: [16]u8, key: [32]u8) [32]u8 {

var c: [4]u32 = undefined;

for (c, 0..) |_, i| {

}

const ctx = initContext(keyToWords(key), c);

var x: BlockVec = undefined;

salsaCore(x[0..], ctx, false);

var out: [32]u8 = undefined;

return out;

}

};

fn initContext(key: [8]u32, d: [4]u32) BlockVec {

const c = "expand 32-byte k";

const constant_le = comptime [4]u32{

};

return BlockVec{

constant_le[0], key[0], key[1], key[2],

 

fn hashToBytes(out: *[64]u8, x: BlockVec) void {

for (x, 0..) |w, i| {

}

}

 

fn hsalsa(input: [16]u8, key: [32]u8) [32]u8 {

var c: [4]u32 = undefined;

for (c, 0..) |_, i| {

}

const ctx = initContext(keyToWords(key), c);

var x: BlockVec = undefined;

salsaCore(x[0..], ctx, false);

var out: [32]u8 = undefined;

return out;

}

};

var k: [8]u32 = undefined;

var i: usize = 0;

while (i < 8) : (i += 1) {

}

return k;

}

debug.assert(in.len == out.len);

 

var d: [4]u32 = undefined;

d[2] = @as(u32, @truncate(counter));

d[3] = @as(u32, @truncate(counter >> 32));

SalsaImpl(rounds).salsaXor(out, in, keyToWords(key), d);

 

var y: []align(16) u32 = @alignCast(xy[32 * r ..]);

 

for (x, 0..) |*v1, j| {

}

 

var tmp: [16]u32 align(16) = undefined;

}

 

for (x, 0..) |v1, j| {

}

}

 

std.debug.assert(dst.len == decodedLen(src.len));

var i: usize = 0;

while (i < src.len / 4) : (i += 1) {

}

const leftover = src[i * 4 ..];

var v: u24 = 0;

std.debug.assert(dst.len == encodedLen(src.len));

var i: usize = 0;

while (i < src.len / 3) : (i += 1) {

}

const leftover = src[i * 3 ..];

var v: u24 = 0;

 

d.round(d.buf[0..]);

 

for (d.s, 0..) |s, j| {

}

}

 

roundParam(0, 1, 2, 3, 4, 15),

};

inline for (round0a) |r| {

 

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));

 

const rr = d.s[0 .. params.digest_bits / 32];

 

for (rr, 0..) |s, j| {

}

}

 

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| {

}

 

if (!@inComptime()) {

const rr = d.s[0 .. params.digest_bits / 64];

 

for (rr, 0..) |s, j| {

}

}

 

 

var i: usize = 0;

while (i < 16) : (i += 1) {

}

while (i < 80) : (i += 1) {

s[i] = s[i - 16] +% s[i - 7] +%

 

msg_len: u8,

 

fn init(key: *const [key_length]u8) Self {

 

var d = Self{

.v0 = k0 ^ 0x736f6d6570736575,

}

 

fn round(self: *Self, b: [8]u8) void {

self.v3 ^= m;

 

comptime var i: usize = 0;

/// 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 {

}

 

pub fn finalResult(self: *Self) [mac_length]u8 {

 

const max_context_len = 255;

const tls13 = "tls13 ";

var buf: [2 + 1 + tls13.len + max_label_len + 1 + max_context_len]u8 = undefined;

buf[2] = @as(u8, @intCast(tls13.len + label.len));

buf[3..][0..tls13.len].* = tls13.*;

var i: usize = 3 + tls13.len;

 

}

const ct: tls.ContentType = @enumFromInt(frag[in]);

in += 1;

in += 2;

_ = legacy_version;

if (record_len > max_ciphertext_len) return error.TlsRecordOverflow;

in += 2;

const end = in + record_len;

while (true) {

const handshake_type: tls.HandshakeType = @enumFromInt(cleartext[ct_i]);

ct_i += 1;

ct_i += 3;

const next_handshake_i = ct_i + handshake_len;

if (next_handshake_i > cleartext.len - 1)

 

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);

separate_debug_filename = debug_filename;

continue;

}

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];

if (name_size != 4) continue;

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];

 

const math = std.math;

const leb = @import("leb128.zig");

const assert = std.debug.assert;

 

pub const TAG = @import("dwarf/TAG.zig");

pub const AT = @import("dwarf/AT.zig");

context.cfa = switch (row.cfa.rule) {

.val_offset => |offset| blk: {

const register = row.cfa.register orelse return error.InvalidCFARule;

break :blk try call_frame.applyOffset(value, offset);

},

.expression => |expression| blk: {

}

 

if (has_return_address) {

context.thread_context,

cie.return_address_register,

context.reg_context,

} else {

context.pc = 0;

}

 

const abi = dwarf.abi;

const expressions = dwarf.expressions;

const assert = std.debug.assert;

 

const Opcode = enum(u8) {

advance_loc = 0x1 << 6,

const addr = try applyOffset(cfa, offset);

if (expression_context.isValidMemory) |isValidMemory| if (!isValidMemory(addr)) return error.InvalidAddress;

const ptr: *const usize = @ptrFromInt(addr);

} else return error.InvalidCFA;

},

.val_offset => |offset| {

if (context.cfa) |cfa| {

} else return error.InvalidCFA;

},

.register => |register| {

 

if (!context.isValidMemory(addr)) return error.InvalidExpressionAddress;

const ptr: *usize = @ptrFromInt(addr);

},

.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;

} else return error.NoExpressionValue;

},

.architectural => return error.UnimplementedRegisterRule,

 

const abi = dwarf.abi;

const mem = std.mem;

const assert = std.debug.assert;

 

/// 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

.regval_type => |regval_type| regval_type.value,

.const_type => |const_type| {

const value: u64 = switch (const_type.value_bytes.len) {

else => return error.InvalidIntegralTypeSize,

};

 

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;

try self.stack.append(allocator, .{ .generic = value });

},

 

if (context.thread_context == null) return error.IncompleteExpressionContext;

 

const base_register = operand.?.base_register;

context.thread_context.?,

base_register.base_register,

context.reg_context,

value += base_register.offset;

try self.stack.append(allocator, .{ .generic = @intCast(value) });

},

OP.regval_type => {

const register_type = operand.?.register_type;

context.thread_context.?,

register_type.register,

context.reg_context,

try self.stack.append(allocator, .{

.regval_type = .{

.type_offset = register_type.type_offset,

 

var block_stream = std.io.fixedBufferStream(block);

const register = (try readOperand(&block_stream, block[0], context)).?.register;

try self.stack.append(allocator, .{ .generic = value });

} else {

var stack_machine: Self = .{};

var mock_debug_addr = std.ArrayList(u8).init(allocator);

defer mock_debug_addr.deinit();

 

 

const context = ExpressionContext{

.compile_unit = &mock_compile_unit,

 

// TODO: Test fbreg (once implemented): mock a DIE and point compile_unit.frame_base at it

 

(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;

 

const value: usize = @truncate(0xffeeffee_ffeeffee);

var value_bytes: [options.addr_size]u8 = undefined;

 

// Convert to generic type

stack_machine.reset();

};

 

if (abi.regBytes(&thread_context, 0, reg_context)) |reg_bytes| {

 

var sub_program = std.ArrayList(u8).init(allocator);

defer sub_program.deinit();

 

}

 

pub fn readU64Unchecked(self: FloatStream) u64 {

}

 

pub fn readU64(self: FloatStream) ?u64 {

 

if (!isEightDigits(v)) {

break;

}

d.num_digits += 8;

stream.advance(8);

}

 

}

 

fn fetch32(ptr: [*]const u8, offset: usize) u32 {

}

 

fn fetch64(ptr: [*]const u8, offset: usize) u64 {

}

 

pub const CityHash32 = struct {

 

const p = input[i..][0..8];

 

// Unrolling this way gives ~50Mb/s increase

 

self.crc =

lookup_tables[0][p[7]] ^

 

for (0..256) |i| {

buf[i] = @intCast(i);

const h = hashMaybeSeed(hash_fn, 256 - i, buf[0..i]);

}

 

return @truncate(hashMaybeSeed(hash_fn, 0, buf_all[0..]));

 

inline fn read(comptime bytes: usize, data: []const u8) u64 {

std.debug.assert(bytes <= 8);

const T = std.meta.Int(.unsigned, 8 * bytes);

}

 

inline fn mum(a: *u64, b: *u64) void {

 

}

 

fn processStripe(self: *Accumulator, buf: *const [32]u8) void {

}

 

fn merge(self: Accumulator) u64 {

 

fn finalize8(v: u64, bytes: *const [8]u8) u64 {

var acc = v;

acc ^= round(0, lane);

acc = rotl(u64, acc, 27) *% prime_1;

acc +%= prime_4;

 

fn finalize4(v: u64, bytes: *const [4]u8) u64 {

var acc = v;

acc ^= lane *% prime_1;

acc = rotl(u64, acc, 23) *% prime_2;

acc +%= prime_3;

}

 

fn processStripe(self: *Accumulator, buf: *const [16]u8) void {

}

 

fn merge(self: Accumulator) u32 {

 

fn finalize4(v: u32, bytes: *const [4]u8) u32 {

var acc = v;

acc +%= lane *% prime_3;

acc = rotl(u32, acc, 17) *% prime_4;

return acc;

 

return @errorCast(self.any().readBoundedBytes(num_bytes));

}

 

pub inline fn readInt(self: Self, comptime T: type, endian: std.builtin.Endian) NoEofError!T {

return @errorCast(self.any().readInt(T, endian));

}

 

return result;

}

 

return mem.readInt(T, &bytes, endian);

}

 

 

}

}

 

mem.writeInt(std.math.ByteAlignedInt(@TypeOf(value)), &bytes, value, endian);

return self.writeAll(&bytes);

}

 

/// 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.

}

 

}

 

/// and ignores extra bytes.

/// The bit count of T must be evenly divisible by 8.

}

 

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 ..];

if (bit_shift > load_tail_bits) {

const tail_bits = @as(Log2N, @intCast(bit_shift - load_tail_bits));

const tail_byte = read_bytes[load_size];

// 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];

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]);

}

}

 

test "comptime read/write int" {

comptime {

var bytes: [2]u8 = undefined;

try testing.expect(result == 0x3412);

}

comptime {

var bytes: [2]u8 = undefined;

try testing.expect(result == 0x3412);

}

}

 

/// 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.

}

 

 

 

}

}

 

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);

write_value |= @as(StoreInt, tail) << (8 * (store_size - 1));

}

 

}

 

fn writePackedIntBig(comptime T: type, bytes: []u8, bit_offset: usize, value: T) void {

write_value |= @as(StoreInt, tail) << (8 * (store_size - 1));

}

 

}

 

pub const writePackedIntNative = switch (native_endian) {

}

}

 

/// Stores an integer to packed memory with provided bit_count, bit_offset, and signedness.

/// If negative, the written value is sign-extended.

///

write_bytes[@as(usize, @intCast(i))] |= @as(u8, @intCast(@as(uN, @bitCast(remaining)) & tail_mask));

}

 

/// 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 {

0x56,

0x78,

};

}

{

const buf = [_]u8{

0x12,

0x34,

};

try testing.expect(answer == 0x00001234);

}

{

0x00,

0x00,

};

try testing.expect(answer == 0x00003412);

}

{

0xff,

0xfe,

};

}

}

 

/// Returns the smallest number in a slice. O(n).

/// `slice` must not be empty.

pub fn min(comptime T: type, slice: []const T) T {

}

 

test "read/write(Var)PackedInt" {

if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;

 

switch (builtin.cpu.arch) {

 

} 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".*;

da4.addr = addr.addr.in.sa.addr;

da = @ptrCast(&da4);

dalen = @sizeOf(os.sockaddr.in);

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.

}

if (dscope == @as(i32, scopeOf(sa6.addr))) key |= DAS_MATCHINGSCOPE;

if (dlabel == labelOf(sa6.addr)) key |= DAS_MATCHINGLABEL;

);

for (0..ns.len) |i| {

if (ns[i].any.family != os.AF.INET) continue;

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;

 

 

var i: u32 = 0;

while (i < alloc_size / @sizeOf(u32)) : (i += 1) {

}

}

 

 

var i: u32 = 0;

while (i < alloc_size / @sizeOf(u32)) : (i += 1) {

}

}

 

 

var i: u32 = alloc_size / 2 / @sizeOf(u32);

while (i < alloc_size / @sizeOf(u32)) : (i += 1) {

}

}

 

 

};

 

fn readSparseBitVector(stream: anytype, allocator: mem.Allocator) ![]u32 {

var list = ArrayList(u32).init(allocator);

errdefer list.deinit();

var word_i: u32 = 0;

while (word_i != num_words) : (word_i += 1) {

var bit_i: u5 = 0;

while (true) : (bit_i += 1) {

if (word & (@as(u32, 1) << bit_i) != 0) {

const reader = stream.reader();

 

// Parse the InfoStreamHeader.

_ = signature;

const guid = try reader.readBytesNoEof(16);

 

if (version != 20000404) // VC70, only value observed by LLVM team

 

// Find the string table.

const string_table_index = str_tab_index: {

const name_bytes = try self.allocator.alloc(u8, name_bytes_len);

defer self.allocator.free(name_bytes);

try reader.readNoEof(name_bytes);

defer self.allocator.free(deleted);

 

for (present) |_| {

if (name_offset > name_bytes.len)

return error.InvalidDebugInfo;

const name = mem.sliceTo(name_bytes[name_offset..], 0);

return error.MissingDebugInfo;

const reader = stream.reader();

 

if (signature != 4)

return error.InvalidDebugInfo;

 

try file.seekTo(superblock.BlockSize * superblock.BlockMapAddr);

var dir_blocks = try allocator.alloc(u32, dir_block_count);

for (dir_blocks) |*b| {

}

var directory = MsfStream.init(

superblock.BlockSize,

);

 

const begin = directory.pos;

const stream_sizes = try allocator.alloc(u32, stream_count);

defer allocator.free(stream_sizes);

 

// and must be taken into account when resolving stream indices.

const Nil = 0xFFFFFFFF;

for (stream_sizes) |*s| {

s.* = if (size == Nil) 0 else blockCountFromSize(size, superblock.BlockSize);

}

 

var blocks = try allocator.alloc(u32, size);

var j: u32 = 0;

while (j < size) : (j += 1) {

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)

 

pub fn int(r: Random, comptime T: type) T {

const bits = @typeInfo(T).Int.bits;

const UnsignedT = std.meta.Int(.unsigned, bits);

 

 

// 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 unsigned_result: UnsignedT = @truncate(byte_aligned_result);

return @bitCast(unsigned_result);

}

 

for (seq) |s| {

var buf0: [8]u8 = undefined;

var buf1: [7]u8 = undefined;

r.fill(&buf1);

try std.testing.expect(std.mem.eql(u8, buf0[0..7], buf1[0..]));

}

 

var i: u32 = 0;

while (i < seq.len) : (i += 2) {

var buf0: [8]u8 = undefined;

 

var buf1: [7]u8 = undefined;

r.fill(&buf1);

 

for (seq) |s| {

var buf0: [8]u8 = undefined;

var buf1: [7]u8 = undefined;

r.fill(&buf1);

try std.testing.expect(std.mem.eql(u8, buf0[0..7], buf1[0..]));

}

 

for (seq) |s| {

var buf0: [8]u8 = undefined;

var buf1: [7]u8 = undefined;

r.fill(&buf1);

try std.testing.expect(std.mem.eql(u8, buf0[0..7], buf1[0..]));

}

 

for (seq) |s| {

var buf0: [8]u8 = undefined;

var buf1: [7]u8 = undefined;

r.fill(&buf1);

try std.testing.expect(std.mem.eql(u8, buf0[0..7], buf1[0..]));

}

 

for (seq) |s| {

var buf0: [8]u8 = undefined;

var buf1: [7]u8 = undefined;

r.fill(&buf1);

try std.testing.expect(std.mem.eql(u8, buf0[0..7], buf1[0..]));

}

 

for (seq) |s| {

var buf0: [8]u8 = undefined;

var buf1: [8]u8 = undefined;

r.fill(&buf1);

try std.testing.expect(std.mem.eql(u8, buf0[0..], buf1[0..]));

}

 

// Parse transition types

var i: usize = 0;

while (i < header.counts.timecnt) : (i += 1) {

}

 

i = 0;

// Parse time types

i = 0;

while (i < header.counts.typecnt) : (i += 1) {

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.

// Parse leap seconds

i = 0;

while (i < header.counts.leapcnt) : (i += 1) {

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

 

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

 

const std = @import("./std.zig");

const assert = std.debug.assert;

const testing = std.testing;

const mem = std.mem;

 

/// Use this to replace an unknown, unrecognized, or unrepresentable character.

///

while (i < s.len) {

// Fast path for ASCII sequences

while (i + N <= s.len) : (i += N) {

if (v & MASK != 0) break;

len += N;

}

assert(it.i <= it.bytes.len);

if (it.i == it.bytes.len) return null;

var code_units: [2]u16 = undefined;

it.i += 2;

if (utf16IsHighSurrogate(code_units[0])) {

// surrogate pair

if (it.i >= it.bytes.len) return error.DanglingSurrogateHalf;

const codepoint = try utf16DecodeSurrogatePair(&code_units);

it.i += 2;

return codepoint;

const utf16le_as_bytes = mem.sliceAsBytes(utf16le[0..]);

 

{

const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le);

defer std.testing.allocator.free(utf8);

try testing.expect(mem.eql(u8, utf8, "Aa"));

}

 

{

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"));

 

{

// the values just outside the surrogate half range

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"));

 

{

// smallest surrogate pair

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"));

 

{

// largest surrogate pair

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"));

}

 

{

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"));

}

 

{

const result = utf16leToUtf8Alloc(std.testing.allocator, &utf16le);

try std.testing.expectError(error.UnexpectedSecondSurrogateHalf, result);

}

try expectFmt("", "{}", .{fmtUtf16le(utf8ToUtf16LeStringLiteral(""))});

try expectFmt("foo", "{}", .{fmtUtf16le(utf8ToUtf16LeStringLiteral("foo"))});

try expectFmt("𐐷", "{}", .{fmtUtf16le(utf8ToUtf16LeStringLiteral("𐐷"))});

}

 

test "utf8ToUtf16LeStringLiteral" {

 

 

/// workaround for https://github.com/ziglang/zig/issues/14904

fn bswap_and_workaround_u32(bytes_ptr: *const [4]u8) u32 {

}

 

/// workaround for https://github.com/ziglang/zig/issues/14904

fn bswap_and_workaround_tag(bytes_ptr: *const [4]u8) InMessage.Tag {

return @as(InMessage.Tag, @enumFromInt(int));

}

 

 

var fba = std.heap.FixedBufferAllocator.init(&cmdline_buffer);

 

pub fn main() void {

return mainSimple() catch @panic("test failure");

}

 

 

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 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);

} else {

break :pack_offset l1_offset.value;

}

else => |other| return other,

};

if (!mem.eql(u8, &actual_signature, signature)) return error.InvalidHeader;

error.EndOfStream => return error.InvalidHeader,

else => |other| return other,

};

if (version != supported_version) return error.UnsupportedVersion;

error.EndOfStream => return error.InvalidHeader,

else => |other| return other,

};

fn read(reader: anytype) !IndexHeader {

var header_bytes = try reader.readBytesNoEof(size);

if (!mem.eql(u8, header_bytes[0..4], signature)) return error.InvalidHeader;

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| {

}

return .{ .fan_out_table = fan_out_table };

}

var index_hashed_writer = hashedWriter(index_writer, Sha1.init(.{}));

const writer = index_hashed_writer.writer();

try writer.writeAll(IndexHeader.signature);

for (fan_out_table) |fan_out_entry| {

}

 

for (oids.items) |oid| {

}

 

for (oids.items) |oid| {

}

 

var big_offsets = std.ArrayListUnmanaged(u64){};

for (oids.items) |oid| {

const offset = index_entries.get(oid).?.offset;

if (offset <= std.math.maxInt(u31)) {

} else {

const index = big_offsets.items.len;

try big_offsets.append(allocator, offset);

}

}

for (big_offsets.items) |offset| {

}

 

try writer.writeAll(&pack_checksum);

 

const backing_int_ty = struct_type.backingIntType(ip).toType();

const int_val = try mod.intValue(

backing_int_ty,

);

return func.lowerConstant(int_val, backing_int_ty);

},

 

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));

}

 

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));

}

 

fn emitMemArg(emit: *Emit, tag: Mir.Inst.Tag, inst: Mir.Inst.Index) !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))));

}

}

 

 

///

/// It is sign-extended to 64 bits by the cpu.

pub fn disp32(self: Self, disp: i32) !void {

}

 

/// Encode an 8 bit immediate

///

/// It is sign-extended to 64 bits by the cpu.

pub fn imm16(self: Self, imm: u16) !void {

}

 

/// Encode an 32 bit immediate

///

/// It is sign-extended to 64 bits by the cpu.

pub fn imm32(self: Self, imm: u32) !void {

}

 

/// Encode an 64 bit immediate

///

/// It is sign-extended to 64 bits by the cpu.

pub fn imm64(self: Self, imm: u64) !void {

}

};

}

 

 

var inc_i: usize = 0;

 

inc_i += 2;

 

var sym_i: usize = 0;

versions_len = 0;

break :n name;

};

inc_i += 4;

 

const lib_index = metadata.inclusions[inc_i];

 

try stubs_asm.appendSlice(".data\n");

 

inc_i += 2;

 

sym_i = 0;

versions_len = 0;

break :n name;

};

inc_i += 4;

 

inc_i += 2;

 

const lib_index = metadata.inclusions[inc_i];

 

switch (self.ptr_width) {

.p32 => {

var buf: [4]u8 = undefined;

try self.base.file.?.pwriteAll(&buf, file_offset);

},

.p64 => {

var buf: [8]u8 = undefined;

try self.base.file.?.pwriteAll(&buf, file_offset);

},

}

switch (self.ptr_width) {

.p32 => {

var buf: [4]u8 = undefined;

writeMem(handle, pvaddr, &buf) catch |err| {

log.warn("writing to protected memory failed with error: {s}", .{@errorName(err)});

};

},

.p64 => {

var buf: [8]u8 = undefined;

writeMem(handle, pvaddr, &buf) catch |err| {

log.warn("writing to protected memory failed with error: {s}", .{@errorName(err)});

};

lookup_table_offset += lookup_entry_size;

 

// Names table entry

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));

}

 

// IAT sentinel

iat_offset += 8;

 

// Lookup table sentinel

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.

 

try self.base.file.?.pwriteAll(buffer.items, self.strtab_offset.?);

}

 

try buffer.ensureTotalCapacity(self.getSizeOfHeaders());

writer.writeAll(msdos_stub) catch unreachable;

 

writer.writeAll("PE\x00\x00") catch unreachable;

var flags = coff.CoffHeaderFlags{

}

const offset = try self.strtab.insert(self.base.allocator, name);

@memset(symbol.name[0..4], 0);

}

 

fn logSymAttributes(sym: *const coff.Symbol, buf: *[4]u8) []const u8 {

 

};

inst.pc_relative_address.immhi = @as(u19, @truncate(pages >> 2));

inst.pc_relative_address.immlo = @as(u2, @truncate(pages));

},

.got_pageoff, .import_pageoff, .pageoff => {

assert(!self.pcrel);

), buffer[0..4]),

};

inst.add_subtract_immediate.imm12 = narrowed;

} else {

var inst = aarch64.Instruction{

.load_store_register = mem.bytesToValue(meta.TagPayload(

}

};

inst.load_store_register.offset = offset;

}

},

.direct => {

assert(!self.pcrel);

switch (self.length) {

u32,

buffer[0..4],

@as(u32, @truncate(ctx.target_vaddr + ctx.image_base)),

),

else => unreachable,

}

},

.got, .import => {

assert(self.pcrel);

const disp = @as(i32, @intCast(ctx.target_vaddr)) - @as(i32, @intCast(ctx.source_vaddr)) - 4;

},

.direct => {

if (self.pcrel) {

const disp = @as(i32, @intCast(ctx.target_vaddr)) - @as(i32, @intCast(ctx.source_vaddr)) - 4;

} else switch (ctx.ptr_width) {

.p64 => switch (self.length) {

else => unreachable,

},

}

 

 

elf.R_X86_64_PLT32,

elf.R_X86_64_PC32,

 

 

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;

continue;

}

},

 

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;

continue;

}

},

 

 

 

 

elf.R_X86_64_TLSGD => {

if (target.flags.has_tlsgd) {

const S_ = @as(i64, @intCast(target.tlsGdAddress(elf_file)));

} 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);

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)));

} else {

try x86_64.relaxTlsLdToLe(

self,

elf.R_X86_64_GOTPC32_TLSDESC => {

if (target.flags.has_tlsdesc) {

const S_ = @as(i64, @intCast(target.tlsDescAddress(elf_file)));

} else {

try x86_64.relaxGotPcTlsDesc(code[r_offset - 3 ..]);

}

},

 

elf.R_X86_64_GOTTPOFF => {

if (target.flags.has_gottp) {

const S_ = @as(i64, @intCast(target.gotTpAddress(elf_file)));

} else {

x86_64.relaxGotTpOff(code[r_offset - 3 ..]) catch unreachable;

}

},

 

 

// Zig custom relocations

 

else => {},

}

.copyrel,

.cplt,

.none,

 

.dyn_copyrel => {

if (is_writeable or elf_file.base.options.z_nocopyreloc) {

});

try applyDynamicReloc(A, elf_file, writer);

} else {

}

},

 

});

try applyDynamicReloc(A, elf_file, writer);

} else {

}

},

 

fn applyDynamicReloc(value: i64, elf_file: *Elf, writer: anytype) !void {

_ = elf_file;

// if (elf_file.options.apply_dynamic_relocs) {

// }

}

 

 

switch (r_type) {

elf.R_X86_64_NONE => unreachable,

elf.R_X86_64_SIZE32 => {

const size = @as(i64, @intCast(target.elfSym(elf_file).st_size));

},

elf.R_X86_64_SIZE64 => {

const size = @as(i64, @intCast(target.elfSym(elf_file).st_size));

},

else => try self.reportUnhandledRelocError(rel, elf_file),

}

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

};

try stream.seekBy(-4);

try writer.writeAll(&insts);

},

0x64, 0x48, 0x8b, 0, // mov %fs:(%rax), %rax

0x48, 0x2d, 0, 0, 0, 0, // sub $tls_size, %rax

};

try stream.seekBy(-3);

try writer.writeAll(&insts);

},

0x48, 0x2d, 0, 0, 0, 0, // sub $tls_size, %rax

0x90, // nop

};

try stream.seekBy(-3);

try writer.writeAll(&insts);

},

0x64, 0x48, 0x8b, 0x04, 0x25, 0, 0, 0, 0, // movq %fs:0,%rax

0x48, 0x81, 0xc0, 0, 0, 0, 0, // add $tp_offset, %rax

};

try stream.seekBy(-4);

try writer.writeAll(&insts);

relocs_log.debug(" relaxing {} and {}", .{

 

 

pub fn ciePointer(fde: Fde, elf_file: *Elf) u32 {

const fde_data = fde.data(elf_file);

}

 

pub fn calcSize(fde: Fde) usize {

var stream = std.io.fixedBufferStream(it.data[it.pos..]);

const reader = stream.reader();

 

if (size == 0xFFFFFFFF) @panic("TODO");

 

const record = Record{

.tag = if (id == 0) .cie else .fde,

.offset = it.pos,

 

var where = contents[offset..];

switch (rel.r_type()) {

else => unreachable,

}

}

const contents = try gpa.dupe(u8, fde.data(elf_file));

defer gpa.free(contents);

 

i32,

contents[4..8],

);

 

for (fde.relocs(elf_file)) |rel| {

}

}

 

}

 

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)));

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),

))),

);

 

const Entry = struct {

init_addr: u32,

const S = @as(i64, @intCast(sym.address(.{}, elf_file)));

const A = rel.r_addend;

entries.appendAssumeCapacity(.{

.fde_addr = @as(

u32,

@bitCast(@as(i32, @truncate(P - @as(i64, @intCast(eh_frame_hdr_shdr.sh_addr))))),

 

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;

disp = @as(i64, @intCast(got_plt_addr + 16)) - @as(i64, @intCast(plt_addr + 14)) - 4;

try writer.writeAll(&preamble);

try writer.writeByteNTimes(0xcc, preamble_size - preamble.len);

 

0x41, 0xbb, 0x00, 0x00, 0x00, 0x00, // mov r11d, N

0xff, 0x25, 0x00, 0x00, 0x00, 0x00, // jmp qword ptr [rip] -> .got.plt[N]

};

try writer.writeAll(&entry);

}

}

{

// [0]: _DYNAMIC

const symbol = elf_file.symbol(elf_file.dynamic_index.?);

}

// [1]: 0x0

// [2]: 0x0

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

}

}

}

0xff, 0x25, 0x00, 0x00, 0x00, 0x00, // jmp qword ptr [rip] -> .got[N]

0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,

};

try writer.writeAll(&entry);

}

}

}

 

try hs.buffer.ensureTotalCapacityPrecise(gpa, (2 + nsyms * 2) * 4);

hs.buffer.writer(gpa).writeAll(mem.sliceAsBytes(buckets)) catch unreachable;

hs.buffer.writer(gpa).writeAll(mem.sliceAsBytes(chains)) catch unreachable;

}

var counting = std.io.countingWriter(writer);

const cwriter = counting.writer();

 

 

const gpa = elf_file.base.allocator;

const hashes = try gpa.alloc(u32, exports.len);

 

log.debug("writing GOT entry {d}: @{x} => {x}", .{ index, vmaddr, entry_value });

 

var buf: [@sizeOf(u64)]u8 = undefined;

try self.base.file.?.pwriteAll(&buf, file_offset);

 

if (is_hot_update_compatible) {

 

{

var buf: [@sizeOf(u64)]u8 = undefined;

const off = laptr_header.offset + @sizeOf(u64) * index;

try self.base.file.?.pwriteAll(&buf, off);

}

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 dylib_ordinal = @divTrunc(@as(i16, @bitCast(bind_sym.n_desc)), macho.N_SYMBOL_RESOLVER);

log.debug(" | bind at {x}, import('{s}') in dylib({d})", .{

if (!self.stub_table.lookup.contains(entry)) continue;

const target_sym = self.getSymbol(entry);

assert(target_sym.undf());

}

}

 

if (!self.got_table.lookup.contains(entry)) continue;

const target_sym = self.getSymbol(entry);

if (target_sym.undf()) {

} else {

}

}

}

if (!self.stub_table.lookup.contains(entry)) continue;

const target_sym = self.getSymbol(entry);

assert(target_sym.undf());

}

}

 

 

}

 

fn parseTableOfContents(self: *Archive, allocator: Allocator, reader: anytype) !void {

var symtab = try allocator.alloc(u8, symtab_size);

defer allocator.free(symtab);

 

return error.MalformedArchive;

};

 

var strtab = try allocator.alloc(u8, strtab_size);

defer allocator.free(strtab);

 

var symtab_reader = symtab_stream.reader();

 

while (true) {

error.EndOfStream => break,

else => |e| return e,

};

 

const sym_name = mem.sliceTo(@as([*:0]const u8, @ptrCast(strtab.ptr + n_strx)), 0);

const owned_name = try allocator.dupe(u8, sym_name);

 

 

const address_in_section = if (ctx.rel.r_pcrel == 0) blk: {

break :blk if (ctx.rel.r_length == 3)

else

} 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))) {

.X86_64_RELOC_SIGNED_4 => 4,

else => unreachable,

};

const target_address = @as(i64, @intCast(ctx.base_addr)) + ctx.rel.r_address + 4 + correction + addend;

break :blk @as(u64, @intCast(target_address));

};

), code),

};

inst.unconditional_branch_immediate.imm26 = @as(u26, @truncate(@as(u28, @bitCast(displacement >> 2))));

},

 

.ARM64_RELOC_PAGE21,

};

inst.pc_relative_address.immhi = @as(u19, @truncate(pages >> 2));

inst.pc_relative_address.immlo = @as(u2, @truncate(pages));

addend = null;

},

 

), code),

};

inst.add_subtract_immediate.imm12 = off;

} else {

var inst = aarch64.Instruction{

.load_store_register = mem.bytesToValue(meta.TagPayload(

3 => .load_store_64,

});

inst.load_store_register.offset = off;

}

addend = null;

},

), code),

};

inst.load_store_register.offset = off;

addend = null;

},

 

.sf = @as(u1, @truncate(reg_info.size)),

},

};

addend = null;

},

 

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;

},

 

.ARM64_RELOC_UNSIGNED => {

var ptr_addend = if (rel.r_length == 3)

else

 

if (rel.r_extern == 0) {

const base_addr = if (target.sym_index >= object.source_address_lookup.len)

relocs_log.debug(" | target_addr = 0x{x}", .{result});

 

if (rel.r_length == 3) {

} else {

}

 

subtractor = null;

 

switch (rel_type) {

.X86_64_RELOC_BRANCH => {

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);

},

 

.X86_64_RELOC_GOT,

.X86_64_RELOC_GOT_LOAD,

=> {

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);

},

 

.X86_64_RELOC_TLV => {

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);

atom_code[rel_offset - 2] = 0x8d;

}

 

},

 

.X86_64_RELOC_SIGNED,

.X86_64_RELOC_SIGNED_4 => 4,

else => unreachable,

};

 

if (rel.r_extern == 0) {

const base_addr = if (target.sym_index >= object.source_address_lookup.len)

relocs_log.debug(" | target_addr = 0x{x}", .{adjusted_target_addr});

 

const disp = try Relocation.calcPcRelativeDisplacementX86(source_addr, adjusted_target_addr, correction);

},

 

.X86_64_RELOC_UNSIGNED => {

var addend = if (rel.r_length == 3)

else

 

if (rel.r_extern == 0) {

const base_addr = if (target.sym_index >= object.source_address_lookup.len)

relocs_log.debug(" | target_addr = 0x{x}", .{result});

 

if (rel.r_length == 3) {

} else {

}

 

subtractor = null;

 

self.code_directory.inner.length = self.code_directory.size();

header.length += self.code_directory.size();

 

 

var offset: u32 = @sizeOf(macho.SuperBlob) + @sizeOf(macho.BlobIndex) * @as(u32, @intCast(blobs.items.len));

for (blobs.items) |blob| {

offset += blob.size();

}

 

}

 

fn write(self: CodeDirectory, writer: anytype) !void {

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.writeAll(self.ident);

try writer.writeByte(0);

}

 

fn write(self: Requirements, writer: anytype) !void {

}

};

 

}

 

fn write(self: Entitlements, writer: anytype) !void {

try writer.writeAll(self.inner);

}

};

}

 

fn write(self: Signature, writer: anytype) !void {

}

};

 

 

address_size: u8,

 

fn read(reader: anytype) !Header {

 

const is_64bit = length == 0xffffffff;

if (is_64bit) {

}

 

const debug_abbrev_offset = if (is_64bit)

else

 

return Header{

.is_64bit = is_64bit,

},

dwarf.FORM.strp => {

const off = if (cuh.is_64bit)

else

return ctx.getString(off);

},

else => return null,

 

return switch (self.form) {

dwarf.FORM.data1 => debug_info[0],

dwarf.FORM.udata => try leb.readULEB128(u64, reader),

dwarf.FORM.sdata => try leb.readILEB128(i64, reader),

else => null,

const debug_info = self.getDebugInfo(ctx);

return switch (cuh.address_size) {

1 => debug_info[0],

else => unreachable,

};

}

dwarf.FORM.block,

=> {

const len: u64 = switch (form) {

dwarf.FORM.block => try leb.readULEB128(u64, reader),

else => unreachable,

};

 

), buffer[0..4]),

};

inst.unconditional_branch_immediate.imm26 = @as(u26, @truncate(@as(u28, @bitCast(displacement >> 2))));

},

.page, .got_page => {

const source_page = @as(i32, @intCast(source_addr >> 12));

};

inst.pc_relative_address.immhi = @as(u19, @truncate(pages >> 2));

inst.pc_relative_address.immlo = @as(u2, @truncate(pages));

},

.pageoff, .got_pageoff => {

const narrowed = @as(u12, @truncate(@as(u64, @intCast(target_addr))));

), buffer[0..4]),

};

inst.add_subtract_immediate.imm12 = narrowed;

} else {

var inst = aarch64.Instruction{

.load_store_register = mem.bytesToValue(meta.TagPayload(

}

};

inst.load_store_register.offset = offset;

}

},

.tlv_initializer, .unsigned => switch (self.length) {

else => unreachable,

},

.got, .signed, .tlv => unreachable, // Invalid target architecture.

switch (self.type) {

.branch, .got, .tlv, .signed => {

const displacement = @as(i32, @intCast(@as(i64, @intCast(target_addr)) - @as(i64, @intCast(source_addr)) - 4));

},

.tlv_initializer, .unsigned => {

switch (self.length) {

2 => {

},

3 => {

},

else => unreachable,

}

 

 

for (page.page_encodings[0..page.page_encodings_count]) |record_id| {

const enc = info.records.items[record_id].compactUnwindEncoding;

}

 

assert(page.count > 0);

 

const writer = buffer.writer();

 

for (eh_records.values()) |record| {

try buffer.appendSlice(record.data);

}

 

base_offset: u64,

}) u64 {

assert(rec.tag == .fde);

return @as(u64, @intCast(@as(i64, @intCast(ctx.base_addr + ctx.base_offset + 8)) + addend));

}

 

}) !void {

assert(rec.tag == .fde);

const addend = @as(i64, @intCast(value)) - @as(i64, @intCast(ctx.base_addr + ctx.base_offset + 8));

}

 

pub fn getPersonalityPointerReloc(

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;

},

.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));

},

else => unreachable,

}

switch (rel_type) {

.X86_64_RELOC_GOT => {

const target_addr = macho_file.getGotEntryAddress(target).?;

const adjusted_target_addr = @as(u64, @intCast(@as(i64, @intCast(target_addr)) + addend));

const disp = try Relocation.calcPcRelativeDisplacementX86(source_addr, adjusted_target_addr, 0);

},

else => unreachable,

}

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;

switch (cpu_arch) {

.aarch64 => {

const relocs = getRelocs(macho_file, object_id, offset);

 

pub fn getCiePointer(rec: Record) u32 {

assert(rec.tag == .fde);

}

 

pub fn setCiePointer(rec: *Record, ptr: u32) void {

assert(rec.tag == .fde);

}

 

pub fn getAugmentationString(rec: Record) []const u8 {

if (enc == EH_PE.omit) return null;

 

var ptr: i64 = switch (enc & 0x0F) {

EH_PE.uleb128 => @as(i64, @bitCast(try leb.readULEB128(u64, reader))),

EH_PE.sleb128 => try leb.readILEB128(i64, reader),

else => return null,

};

}

 

switch (enc & 0x0F) {

EH_PE.uleb128 => try leb.writeULEB128(writer, @as(u64, @bitCast(actual))),

EH_PE.sleb128 => try leb.writeILEB128(writer, actual),

else => unreachable,

}

var stream = std.io.fixedBufferStream(it.data[it.pos..]);

const reader = stream.reader();

 

if (size == 0xFFFFFFFF) {

log.debug("MachO doesn't support 64bit DWARF CFI __eh_frame records", .{});

return error.BadDwarfCfi;

}

 

const tag: EhFrameRecordTag = if (id == 0) .cie else .fde;

const offset: u32 = 4;

const record = EhFrameRecord(false){

 

args.dyld_private_addr,

0,

);

}

try writer.writeAll(&.{ 0x41, 0x53, 0xff, 0x25 });

{

args.dyld_stub_binder_got_addr,

0,

);

}

},

.aarch64 => {

{

const pages = Relocation.calcNumberOfPages(args.source_addr, args.dyld_private_addr);

}

{

const off = try Relocation.calcPageOffset(args.dyld_private_addr, .arithmetic);

}

.x16,

.x17,

aarch64.Register.sp,

aarch64.Instruction.LoadStorePairOffset.pre_index(-16),

{

const pages = Relocation.calcNumberOfPages(args.source_addr + 12, args.dyld_stub_binder_got_addr);

}

{

const off = try Relocation.calcPageOffset(args.dyld_stub_binder_got_addr, .load_store_64);

.x16,

.x16,

aarch64.Instruction.LoadStoreOffset.imm(off),

}

},

else => unreachable,

}

try writer.writeAll(&.{ 0x68, 0x0, 0x0, 0x0, 0x0, 0xe9 });

{

const disp = try Relocation.calcPcRelativeDisplacementX86(args.source_addr + 6, args.target_addr, 0);

}

},

.aarch64 => {

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;

};

.w16,

literal,

{

const disp = try Relocation.calcPcRelativeDisplacementArm64(args.source_addr + 4, args.target_addr);

}

try writer.writeAll(&.{ 0x0, 0x0, 0x0, 0x0 });

},

try writer.writeAll(&.{ 0xff, 0x25 });

{

const disp = try Relocation.calcPcRelativeDisplacementX86(args.source_addr + 2, args.target_addr, 0);

}

},

.aarch64 => {

{

const pages = Relocation.calcNumberOfPages(args.source_addr, args.target_addr);

}

{

const off = try Relocation.calcPageOffset(args.target_addr, .load_store_64);

.x16,

.x16,

aarch64.Instruction.LoadStoreOffset.imm(off),

}

},

else => unreachable,

}

 

.atom => macho_file.getSymbol(target).n_value,

};

const pages = Relocation.calcNumberOfPages(source_addr, target_addr);

const off = try Relocation.calcPageOffset(target_addr, .arithmetic);

}

}

 

 

defer buffer.deinit();

for (table.entries.items) |entry| {

const sym = macho_file.getSymbol(entry);

}

log.debug("writing __DATA_CONST,__got contents at file offset 0x{x}", .{header.offset});

try macho_file.base.file.?.pwriteAll(buffer.items, header.offset);

for (0..macho_file.stub_table.count()) |index| {

const target_addr = stub_helper_header.addr + stubs.stubHelperPreambleSize(cpu_arch) +

stubs.stubHelperSize(cpu_arch) * index;

}

 

log.debug("writing __DATA,__la_symbol_ptr contents at file offset 0x{x}", .{

 

// every 'z' starts with 0

try a.append(0);

// path component value of '/'

 

// getting the full file path

var buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;

var it = std.mem.tokenizeScalar(u8, path, sep);

while (it.next()) |component| {

if (self.file_segments.get(component)) |num| {

} else {

self.file_segments_i += 1;

try self.file_segments.put(self.base.allocator, component, self.file_segments_i);

}

}

}

try l.append(toadd);

} else if (delta_line != 0) {

try l.append(0);

}

}

 

@memcpy(hdr_slice, self.hdr.toU8s()[0..hdr_size]);

// write the fat header for 64 bit entry points

if (self.sixtyfour_bit) {

}

// perform the relocs

{

// 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) {

} else {

}

try w.writeByte(@intFromEnum(sym.type));

try w.writeAll(sym.name);

 

var buf: [40]u8 = undefined;

var i: u8 = 0;

inline for (std.meta.fields(@This())) |f| {

i += 4;

}

return buf;

 

atom.deinit(wasm);

break :blk index;

} else new_atom: {

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;

atom.* = Atom.empty;

atom.sym_index = loc.index;

atom.size = 2;

 

try wasm.parseAtom(atom_index, .{ .data = .read_only });

}

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

// create relocation to the error name

try atom.relocs.append(wasm.base.allocator, .{

.index = names_atom.sym_index,

},

.f32_const => |val| {

try writer.writeByte(std.wasm.opcode(.f32_const));

},

.f64_const => |val| {

try writer.writeByte(std.wasm.opcode(.f64_const));

},

.global_get => |val| {

try writer.writeByte(std.wasm.opcode(.global_get));

 

const size_trimmed = mem.trim(u8, &archive.header.ar_size, " ");

const sym_tab_size = try std.fmt.parseInt(u32, size_trimmed, 10);

 

const symbol_positions = try allocator.alloc(u32, num_symbols);

defer allocator.free(symbol_positions);

for (symbol_positions) |*index| {

}

 

const sym_tab = try allocator.alloc(u8, sym_tab_size - 4 - (4 * num_symbols));

 

.R_WASM_GLOBAL_INDEX_I32,

.R_WASM_MEMORY_ADDR_I32,

.R_WASM_SECTION_OFFSET_I32,

.R_WASM_TABLE_INDEX_I64,

.R_WASM_MEMORY_ADDR_I64,

.R_WASM_GLOBAL_INDEX_LEB,

.R_WASM_EVENT_INDEX_LEB,

.R_WASM_FUNCTION_INDEX_LEB,

 

fn parseObject(parser: *ObjectParser, gpa: Allocator, is_object_file: *bool) Error!void {

errdefer parser.object.deinit(gpa);

try parser.verifyMagicBytes();

 

parser.object.version = version;

var relocatable_data = std.ArrayList(RelocatableData).init(gpa);

 

const riff_header = try reader.readBytesNoEof(4);

if (!std.mem.eql(u8, &riff_header, "RIFF")) return error.InvalidFormat;

 

 

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);

if (!std.mem.eql(u8, &chunk_id, "anih")) {

// TODO: Move file cursor instead of skipBytes

try reader.skipBytes(chunk_len, .{});

 

 

const std = @import("std");

const BitmapHeader = @import("ico.zig").BitmapHeader;

 

pub const file_header_len = 14;

 

pub const ReadError = error{

var bitmap_info: BitmapInfo = undefined;

const file_header = reader.readBytesNoEof(file_header_len) catch return error.UnexpectedEOF;

 

if (id != windows_format_id) return error.InvalidFileHeader;

 

if (bitmap_info.pixel_data_offset > max_size) return error.ImpossiblePixelDataOffset;

 

if (bitmap_info.pixel_data_offset < file_header_len + bitmap_info.dib_header_size) return error.ImpossiblePixelDataOffset;

const dib_version = BitmapHeader.Version.get(bitmap_info.dib_header_size);

switch (dib_version) {

.@"nt3.1", .@"nt4.0", .@"nt5.0" => {

var dib_header_buf: [@sizeOf(BITMAPINFOHEADER)]u8 align(@alignOf(BITMAPINFOHEADER)) = undefined;

reader.readNoEof(dib_header_buf[4..]) catch return error.UnexpectedEOF;

var dib_header: *BITMAPINFOHEADER = @ptrCast(&dib_header_buf);

structFieldsLittleToNative(BITMAPINFOHEADER, dib_header);

},

.@"win2.0" => {

var dib_header_buf: [@sizeOf(BITMAPCOREHEADER)]u8 align(@alignOf(BITMAPCOREHEADER)) = undefined;

reader.readNoEof(dib_header_buf[4..]) catch return error.UnexpectedEOF;

var dib_header: *BITMAPCOREHEADER = @ptrCast(&dib_header_buf);

structFieldsLittleToNative(BITMAPCOREHEADER, dib_header);

 

const lang = @import("lang.zig");

const code_pages = @import("code_pages.zig");

const errors = @import("errors.zig");

 

pub const CompileOptions = struct {

cwd: std.fs.Dir,

// > resource if a RESDIR structure contains information about a cursor.

// where LOCALHEADER is `struct { WORD xHotSpot; WORD yHotSpot; }`

if (icon_dir.image_type == .cursor) {

}

 

try file.seekTo(entry.data_offset_from_start_of_file);

},

.dib => {

var bitmap_header: *ico.BitmapHeader = @ptrCast(@alignCast(&header_bytes));

std.mem.byteSwapAllFields(ico.BitmapHeader, bitmap_header);

}

const bitmap_version = ico.BitmapHeader.Version.get(bitmap_header.bcSize);

if (bitmap_info.getActualPaletteByteLen() > bitmap_info.getExpectedPaletteByteLen()) {

const num_ignored_bytes = bitmap_info.getActualPaletteByteLen() - bitmap_info.getExpectedPaletteByteLen();

var number_as_bytes: [8]u8 = undefined;

const value_string_index = try self.diagnostics.putString(&number_as_bytes);

try self.addErrorDetails(.{

.err = .bmp_ignored_palette_bytes,

const max_missing_bytes = 4096;

if (num_padding_bytes > max_missing_bytes) {

var numbers_as_bytes: [16]u8 = undefined;

const values_string_index = try self.diagnostics.putString(&numbers_as_bytes);

try self.addErrorDetails(.{

.err = .bmp_too_many_missing_palette_bytes,

}

 

var number_as_bytes: [8]u8 = undefined;

const value_string_index = try self.diagnostics.putString(&number_as_bytes);

try self.addErrorDetails(.{

.err = .bmp_missing_palette_bytes,

const pixel_data_len = bitmap_info.getPixelDataLen(file_size);

if (pixel_data_len > 0) {

const miscompiled_bytes = @min(pixel_data_len, num_padding_bytes);

const miscompiled_bytes_string_index = try self.diagnostics.putString(&number_as_bytes);

try self.addErrorDetails(.{

.err = .rc_would_miscompile_bmp_palette_padding,

pub fn write(self: Data, writer: anytype) !void {

switch (self) {

.number => |number| switch (number.is_long) {

},

.ascii_string => |ascii_string| {

try writer.writeAll(ascii_string);

 

try data_writer.writeByte(modifiers.value);

try data_writer.writeByte(0); // padding

}

}

 

if (node.help_id == null) break :help_id 0;

break :help_id evaluateNumberExpression(node.help_id.?, self.source, self.input_code_pages).value;

};

} else {

}

// This limit is enforced by the parser, so we know the number of controls

// is within the range of a u16.

 

// Menu

if (optional_statement_values.menu) |menu| {

try menu.write(data_writer);

} else {

}

// Class

if (optional_statement_values.class) |class| {

try class.write(data_writer);

} else {

}

// Caption

if (optional_statement_values.caption) |caption| {

defer self.allocator.free(parsed);

try data_writer.writeAll(std.mem.sliceAsBytes(parsed[0 .. parsed.len + 1]));

} else {

}

// Font

if (optional_statement_values.font) |font| {

switch (resource) {

.dialog => {

// Note: Reverse order from DIALOGEX

},

.dialogex => {

const help_id: u32 = if (control.help_id) |help_id_expression|

evaluateNumberExpression(help_id_expression, self.source, self.input_code_pages).value

else

0;

// Note: Reverse order from DIALOG

},

else => unreachable,

}

const control_width = evaluateNumberExpression(control.width, self.source, self.input_code_pages);

const control_height = evaluateNumberExpression(control.height, self.source, self.input_code_pages);

 

 

const control_id = evaluateNumberExpression(control.id, self.source, self.input_code_pages);

switch (resource) {

else => unreachable,

}

 

}

// We know the extra_data_buf size fits within a u16.

const extra_data_size: u16 = @intCast(extra_data_buf.items.len);

try data_writer.writeAll(extra_data_buf.items);

}

 

 

// I'm assuming this is some sort of version

// TODO: Try to find something mentioning this

 

for (node.buttons) |button_or_sep| {

switch (button_or_sep.id) {

.literal => { // This is always SEPARATOR

std.debug.assert(button_or_sep.cast(.literal).?.token.id == .literal);

},

.simple_statement => {

const value_node = button_or_sep.cast(.simple_statement).?.value;

const value = evaluateNumberExpression(value_node, self.source, self.input_code_pages);

},

else => unreachable, // This is a bug in the parser

}

pub fn writeDialogFont(self: *Compiler, resource: Resource, values: FontStatementValues, writer: anytype) !void {

const node = values.node;

const point_size = evaluateNumberExpression(node.point_size, self.source, self.input_code_pages);

 

if (resource == .dialogex) {

}

 

if (resource == .dialogex) {

}

 

if (node.char_set) |char_set| {

const value = evaluateNumberExpression(char_set, self.source, self.input_code_pages);

} else if (resource == .dialogex) {

}

 

const typeface = try self.parseQuotedStringAsWideString(node.typeface);

pub fn writeMenuData(self: *Compiler, node: *Node.Menu, data_writer: anytype, resource: Resource) !void {

// menu header

const version: u16 = if (resource == .menu) 0 else 1;

const header_size: u16 = if (resource == .menu) 0 else 4;

// Note: There can be extra bytes at the end of this header (`rgbExtra`),

// but they are always zero-length for us, so we don't write anything

// (the length of the rgbExtra field is inferred from the header_size).

if (resource == .menuex) {

if (node.help_id) |help_id_node| {

const help_id = evaluateNumberExpression(help_id_node, self.source, self.input_code_pages);

} else {

}

}

 

// compiler still uses this alternate form, so that's what we use too.

var flags = res.MenuItemFlags{};

if (is_last_of_parent) flags.markLast();

},

.menu_item => {

const menu_item = @fieldParentPtr(Node.MenuItem, "base", node);

flags.apply(option);

}

if (is_last_of_parent) flags.markLast();

 

var result = evaluateNumberExpression(menu_item.result, self.source, self.input_code_pages);

 

var text = try self.parseQuotedStringAsWideString(menu_item.text);

defer self.allocator.free(text);

flags.apply(option);

}

if (is_last_of_parent) flags.markLast();

 

var text = try self.parseQuotedStringAsWideString(popup.text);

defer self.allocator.free(text);

 

if (menu_item.type) |flags| {

const value = evaluateNumberExpression(flags, self.source, self.input_code_pages);

} else {

}

 

if (menu_item.state) |state| {

const value = evaluateNumberExpression(state, self.source, self.input_code_pages);

} else {

}

 

if (menu_item.id) |id| {

const value = evaluateNumberExpression(id, self.source, self.input_code_pages);

} else {

}

 

var flags: u16 = 0;

if (is_last_of_parent) flags |= comptime @as(u16, @intCast(res.MF.END));

// This constant doesn't seem to have a named #define, it's different than MF_POPUP

if (node_type == .popup_ex) flags |= 0x01;

 

var text = try self.parseQuotedStringAsWideString(menu_item.text);

defer self.allocator.free(text);

if (node_type == .popup_ex) {

if (menu_item.help_id) |help_id_node| {

const help_id = evaluateNumberExpression(help_id_node, self.source, self.input_code_pages);

} else {

}

 

for (menu_item.items, 0..) |item, i| {

var limited_writer = limitedWriter(data_buffer.writer(), std.math.maxInt(u16));

const data_writer = limited_writer.writer();

 

const key_bytes = std.mem.sliceAsBytes(res.FixedFileInfo.key[0 .. res.FixedFileInfo.key.len + 1]);

try data_writer.writeAll(key_bytes);

// The number of bytes written up to this point is always the same, since the name

// of the node is a constant (FixedFileInfo.key). The total number of bytes

// written so far is 38, so we need 2 padding bytes to get back to DWORD alignment

 

var fixed_file_info = res.FixedFileInfo{};

for (node.fixed_info) |fixed_info| {

// limited the writer to maxInt(u16)

const data_size: u16 = @intCast(data_buffer.items.len);

// And now that we know the full size of this node (including its children), set its size

 

var header = try self.resourceHeader(node.id, node.versioninfo, .{

.data_size = data_size,

try writeDataPadding(writer, @as(u16, @intCast(buf.items.len)));

 

const node_and_children_size_offset = buf.items.len;

const data_size_offset = buf.items.len;

const data_type_offset = buf.items.len;

// Data type is string unless the node contains values that are numbers.

 

switch (node.id) {

inline .block, .block_value => |node_type| {

const is_empty = parsed_to_first_null.len == 0;

const is_only = block_or_value.values.len == 1;

if ((!is_empty or !is_only) and (is_last or value_value_node.trailing_comma)) {

values_size += if (has_number_value) 2 else 1;

}

}

}

var data_size_slice = buf.items[data_size_offset..];

 

if (has_number_value) {

const data_type_slice = buf.items[data_type_offset..];

}

 

if (node_type == .block) {

 

const node_and_children_size = buf.items.len - node_and_children_size_offset;

const node_and_children_size_slice = buf.items[node_and_children_size_offset..];

}

 

pub fn writeStringTable(self: *Compiler, node: *Node.StringTable) !void {

}

 

fn writeSizeInfo(self: ResourceHeader, writer: anytype, size_info: SizeInfo) !void {

try self.type_value.write(writer); // TYPE

try self.name_value.write(writer); // NAME

try writer.writeByteNTimes(0, size_info.padding_after_name);

 

}

 

pub fn predefinedResourceType(self: ResourceHeader) ?res.RT {

defer header.deinit(compiler.allocator);

 

try header.writeAssertNoOverflow(writer);

for (self.fonts.items) |font| {

// The format of the FONTDIR is a strange beast.

// Technically, each FONT is seemingly meant to be written as a

// device name/face name in the FONTDIR is reliable.

 

// First, the ID is written, though

try writer.writeAll(&font.header_bytes);

try writer.writeByteNTimes(0, 2);

}

var string_i: u8 = 0;

while (true) : (i += 1) {

if (!self.set_indexes.isSet(i)) {

if (i == 15) break else continue;

}

 

// If the option is set, then a NUL terminator is added unconditionally.

// We already trimmed any trailing NULs, so we know it will be a new addition to the string.

if (compiler.null_terminate_string_table_strings) string_len_in_utf16_code_units += 1;

try data_writer.writeAll(std.mem.sliceAsBytes(trimmed_string));

if (compiler.null_terminate_string_table_strings) {

}

 

if (i == 15) break;

 

const parse = @import("parse.zig");

const lang = @import("lang.zig");

const CodePage = @import("code_pages.zig").CodePage;

 

pub const Diagnostics = struct {

errors: std.ArrayListUnmanaged(ErrorDetails) = .{},

},

.bmp_ignored_palette_bytes => {

const bytes = strings[self.extra.number];

try writer.print("bitmap has {d} extra bytes preceding the pixel data which will be ignored", .{ignored_bytes});

},

.bmp_missing_palette_bytes => {

const bytes = strings[self.extra.number];

try writer.print("bitmap has {d} missing color palette bytes which will be padded with zeroes", .{missing_bytes});

},

.rc_would_miscompile_bmp_palette_padding => {

const bytes = strings[self.extra.number];

try writer.print("the missing color palette bytes would be miscompiled by the Win32 RC compiler (the added padding bytes would include {d} bytes of the pixel data)", .{miscompiled_bytes});

},

.bmp_too_many_missing_palette_bytes => switch (self.type) {

.err, .warning => {

const bytes = strings[self.extra.number];

try writer.print("bitmap has {} missing color palette bytes which exceeds the maximum of {}", .{ missing_bytes, max_missing_bytes });

},

// TODO: command line option

 

//! https://learn.microsoft.com/en-us/windows/win32/menurc/localheader

 

const std = @import("std");

 

pub const ReadError = std.mem.Allocator.Error || error{ InvalidHeader, InvalidImageType, ImpossibleDataSize, UnexpectedEOF, ReadError };

 

// to do this. Maybe it makes more sense to handle the translation

// at the call site instead of having a helper function here.

pub fn readAnyError(allocator: std.mem.Allocator, reader: anytype, max_size: u64) !IconDir {

if (reserved != 0) {

return error.InvalidHeader;

}

else => |e| return e,

};

 

 

// To avoid over-allocation in the case of a file that says it has way more

// entries than it actually does, we use an ArrayList with a conservatively

switch (image_type) {

.icon => {

entry.type_specific_data = .{ .icon = .{

} };

},

.cursor => {

entry.type_specific_data = .{ .cursor = .{

} };

},

}

// Validate that the offset/data size is feasible

if (@as(u64, entry.data_offset_from_start_of_file) + entry.data_size_in_bytes > max_size) {

return error.ImpossibleDataSize;

}

 

pub fn writeResData(self: IconDir, writer: anytype, first_image_id: u16) !void {

// We know that entries.len must fit into a u16

 

var image_id = first_image_id;

for (self.entries) |entry| {

pub fn writeResData(self: Entry, writer: anytype, id: u16) !void {

switch (self.type_specific_data) {

.icon => |icon_data| {

},

.cursor => |cursor_data| {

},

}

}

};

 

png,

riff,

 

 

pub fn detect(header_bytes: *const [16]u8) ImageFormat {

return .dib;

}

 

pub fn validate(format: ImageFormat, header_bytes: *const [16]u8) bool {

return switch (format) {

.dib => true,

};

}

 

try writer.writeAll(std.mem.sliceAsBytes(name[0 .. name.len + 1]));

},

.ordinal => |ordinal| {

},

}

}

 

pub fn writeEmpty(writer: anytype) !void {

}

 

pub fn fromString(allocator: Allocator, bytes: SourceBytes) !NameOrOrdinal {

};

 

pub fn write(self: FixedFileInfo, writer: anytype) !void {

}

};

 

 

if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

 

if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .macos) {

return error.SkipZigTest; // TODO

 

if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

 

const U = extern union {

fd: i32,

var runtime: usize = 1234;

const ptr = &S{ .events = 0, .data = .{ .u64 = runtime } };

const array = @as(*const [12]u8, @ptrCast(ptr));

try expect(result == 1234);

}