srctree

\\#define __ORDER_PDP_ENDIAN__ 3412

\\

);

\\#define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__

\\#define __LITTLE_ENDIAN__ 1

\\

 

.thumb,

.thumbeb,

=> switch (arm_endianness orelse target.cpu.arch.endian()) {

},

.aarch64 => "aarch64linux",

.aarch64_be => "aarch64linuxb",

 

 

var ordered: [2]u8 = @bitCast(full);

switch (native_endian) {

try expect(ordered[0] == 0x12);

try expect(ordered[1] == 0x34);

},

try expect(ordered[0] == 0x34);

try expect(ordered[1] == 0x12);

},

 

pub const HalfT = if (signed_half) HalfTS else HalfTU;

 

all: T,

extern struct { low: HalfT, high: HalfT }

else

extern struct { high: HalfT, low: HalfT },

 

const bPtr_u16: [*]u16 = @ptrCast(&bmod);

 

const exp_and_sign_index = comptime switch (builtin.target.cpu.arch.endian()) {

};

const low_index = comptime switch (builtin.target.cpu.arch.endian()) {

};

const high_index = comptime switch (builtin.target.cpu.arch.endian()) {

};

 

const signA = aPtr_u16[exp_and_sign_index] & 0x8000;

 

const HalveInt = @import("common.zig").HalveInt;

 

const lo = switch (builtin.cpu.arch.endian()) {

};

const hi = 1 - lo;

 

 

 

/// Get the value of a limb.

inline fn limb(x: []const u32, i: usize) u32 {

}

 

/// Change the value of a limb.

inline fn limb_set(x: []u32, i: usize, v: u32) void {

x[i] = v;

} else {

x[x.len - 1 - i] = v;

 

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

 

/// This data structure is used by the Zig language code generation and

/// therefore must be kept in sync with the compiler implementation.

pub const Endian = enum {

};

 

/// This data structure is used by the Zig language code generation and

 

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

 

};

 

fn readStreamFlags(reader: anytype, check: *Check) !void {

 

const reserved1 = try bit_reader.readBitsNoEof(u8, 8);

if (reserved1 != 0)

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,

if (descriptor.dictionary_id_flag > 0) {

// if flag is 3 then field_size = 4, else field_size = flag

const field_size = (@as(u4, 1) << descriptor.dictionary_id_flag) >> 1;

}

 

var content_size: ?u64 = null;

if (descriptor.single_segment_flag or descriptor.content_size_flag > 0) {

const field_size = @as(u4, 1) << descriptor.content_size_flag;

if (field_size == 2) content_size.? += 256;

}

 

 

/// FSE compressed data.

pub const ReverseBitReader = struct {

byte_reader: ReversedByteReader,

 

pub fn init(self: *ReverseBitReader, bytes: []const u8) error{BitStreamHasNoStartBit}!void {

self.byte_reader = ReversedByteReader.init(bytes);

if (bytes.len == 0) return;

var i: usize = 0;

while (i < 8 and 0 == self.readBitsNoEof(u1, 1) catch unreachable) : (i += 1) {}

 

pub fn BitReader(comptime Reader: type) type {

return struct {

 

pub fn readBitsNoEof(self: *@This(), comptime U: type, num_bits: usize) !U {

return self.underlying.readBitsNoEof(U, num_bits);

}

 

pub fn bitReader(reader: anytype) BitReader(@TypeOf(reader)) {

}

 

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

}

 

// Reject modulus below 512 bits.

// 512-bit RSA was factored in 1999, so this limit barely means anything,

// but establish some limit now to ratchet in what we can.

if (_n.bits() < 512) return error.CertificatePublicKeyInvalid;

 

// Exponent must be odd and greater than 2.

// Windows commonly does.

// [1] https://learn.microsoft.com/en-us/windows/win32/api/wincrypt/ns-wincrypt-rsapubkey

if (pub_bytes.len > 4) return error.CertificatePublicKeyInvalid;

if (!_e.isOdd()) return error.CertificatePublicKeyInvalid;

const e_v = _e.toPrimitive(u32) catch return error.CertificatePublicKeyInvalid;

if (e_v < 2) return error.CertificatePublicKeyInvalid;

};

 

fn encrypt(comptime modulus_len: usize, msg: [modulus_len]u8, public_key: PublicKey) ![modulus_len]u8 {

const e = public_key.n.powPublic(m, public_key.e) catch unreachable;

var res: [modulus_len]u8 = undefined;

return res;

}

};

 

 

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

 

 

var out: [exp_out.len]u8 = undefined;

var ctx = Aes128.initEnc(key);

try testing.expectEqualSlices(u8, exp_out[0..], out[0..]);

}

 

 

 

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

 

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;

}

 

}

};

}

 

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

 

/// XOR a byte into the state at a given offset.

pub fn addByte(self: *Self, byte: u8, offset: usize) void {

const z = switch (endian) {

};

self.st[offset / 8] ^= @as(u64, byte) << z;

}

 

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

}

}

}

 

test "ascon" {

const bytes = [_]u8{0x01} ** Ascon.block_bytes;

var st = Ascon.init(bytes);

var out: [Ascon.block_bytes]u8 = undefined;

 

 

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;

}

};

 

 

const k = deterministicScalar(h_slice.*, self.secret_key.bytes, self.noise);

 

const r = reduceToScalar(Curve.Fe.encoded_length, xs);

if (r.isZero()) return error.IdentityElement;

 

const k_inv = k.invert();

const s = k_inv.mul(zrs);

if (s.isZero()) return error.IdentityElement;

 

}

};

 

public_key: PublicKey,

 

fn init(sig: Signature, public_key: PublicKey) (IdentityElementError || NonCanonicalError)!Verifier {

if (r.isZero() or s.isZero()) return error.IdentityElement;

 

return Verifier{

}

 

const s_inv = self.s.invert();

const vr = reduceToScalar(Curve.Fe.encoded_length, vxs);

if (!self.r.equivalent(vr)) {

return error.SignatureVerificationFailed;

}

const h = [_]u8{0x00} ** Hash.digest_length;

const k0 = [_]u8{0x01} ** SecretKey.encoded_length;

return fromSecretKey(SecretKey{ .bytes = secret_key });

}

 

/// Return the public key corresponding to the secret key.

pub fn fromSecretKey(secret_key: SecretKey) IdentityElementError!KeyPair {

return KeyPair{ .secret_key = secret_key, .public_key = PublicKey{ .p = public_key } };

}

 

if (unreduced_len >= 48) {

var xs = [_]u8{0} ** 64;

@memcpy(xs[xs.len - s.len ..], s[0..]);

}

var xs = [_]u8{0} ** 48;

@memcpy(xs[xs.len - s.len ..], s[0..]);

}

 

// Create a deterministic scalar according to a secret key and optional noise.

Hmac.create(m_v, m_v, &k);

@memcpy(t[t_off..t_end], m_v[0 .. t_end - t_off]);

}

m_i.* = 0x00;

Hmac.create(&k, m[0 .. m_v.len + 1], &k);

Hmac.create(m_v, m_v, &k);

 

@memset(bytes, 0);

var shift: usize = 0;

var out_i: usize = switch (endian) {

};

for (0..self.limbs.len) |i| {

var remaining_bits = t_bits;

remaining_bits -= consumed;

shift = 0;

switch (endian) {

if (out_i == 0) {

if (i != self.limbs.len - 1 or limb != 0) {

return error.Overflow;

}

out_i -= 1;

},

out_i += 1;

if (out_i == bytes.len) {

if (i != self.limbs.len - 1 or limb != 0) {

var out = Self.zero;

var out_i: usize = 0;

var i: usize = switch (endian) {

};

while (true) {

const bi = bytes[i];

out.limbs.set(out_i, overflow);

}

switch (endian) {

if (i == 0) break;

i -= 1;

},

i += 1;

if (i == bytes.len) break;

},

Limb,

x.limbs.constSlice(),

y.limbs.constSlice(),

);

}

 

var out = self.one();

self.toMontgomery(&out) catch unreachable;

 

// Do not use a precomputation table for short, public exponents

var x_m = x;

if (x.montgomery == false) {

self.toMontgomery(&x_m) catch unreachable;

}

var s = switch (endian) {

};

while (true) {

const b = e[s];

if (j == 0) break;

}

switch (endian) {

s += 1;

if (s == e.len) break;

},

if (s == 0) break;

s -= 1;

},

}

var t0 = self.zero;

var s = switch (endian) {

};

while (true) {

const b = e[s];

}

}

switch (endian) {

s += 1;

if (s == e.len) break;

},

if (s == 0) break;

s -= 1;

},

var e_normalized = Fe{ .v = e.v.normalize() };

var buf_: [Fe.encoded_bytes]u8 = undefined;

var buf = buf_[0 .. math.divCeil(usize, e_normalized.v.limbs_count() * t_bits, 8) catch unreachable];

const leading = @clz(e_normalized.v.limbs.get(e_normalized.v.limbs_count() - carry_bits));

buf = buf[0 .. buf.len - leading / 8];

}

 

/// Returns x^e (mod m), with the exponent provided as a byte string.

 

/// It is not a general purpose hash function - The key must be secret, unpredictable and never reused.

///

/// GHASH is typically used to compute the authentication tag in the AES-GCM construction.

 

/// POLYVAL is a universal hash function that uses multiplication by a fixed

/// parameter within a Galois field.

/// It is not a general purpose hash function - The key must be secret, unpredictable and never reused.

///

/// POLYVAL is typically used to compute the authentication tag in the AES-GCM-SIV construction.

 

fn Hash(comptime endian: std.builtin.Endian, comptime shift_key: bool) type {

return struct {

 

const mem = std.mem;

const math = std.math;

const testing = std.testing;

const AuthenticationError = crypto.errors.AuthenticationError;

 

/// ISAPv2 is an authenticated encryption system hardened against side channels and fault attacks.

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{

 

 

/// Reject non-canonical encodings of an element.

pub fn rejectNonCanonical(s_: [encoded_length]u8, endian: std.builtin.Endian) NonCanonicalError!void {

const field_order_s = comptime fos: {

var fos: [encoded_length]u8 = undefined;

break :fos fos;

};

return error.NonCanonical;

}

}

 

/// Unpack a field element.

pub fn fromBytes(s_: [encoded_length]u8, endian: std.builtin.Endian) NonCanonicalError!Fe {

var limbs_z: NonMontgomeryDomainFieldElement = undefined;

fiat.fromBytes(&limbs_z, s);

var limbs: MontgomeryDomainFieldElement = undefined;

fiat.fromMontgomery(&limbs_z, fe.limbs);

var s: [encoded_length]u8 = undefined;

fiat.toBytes(&s, limbs_z);

}

 

/// Element as an integer.

/// Create a field element from an integer.

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

var s: [encoded_length]u8 = undefined;

}

 

/// Return the field element as an integer.

pub fn toInt(fe: Fe) IntRepr {

}

 

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

 

/// Return true if the element is odd.

pub fn isOdd(fe: Fe) bool {

return @as(u1, @truncate(s[0])) != 0;

}

 

 

},

2, 3 => {

if (encoded.len != 32) return error.InvalidEncoding;

const y_is_odd = (encoding_type == 3);

const y = try recoverY(x, y_is_odd);

return P256{ .x = x, .y = y };

},

4 => {

if (encoded.len != 64) return error.InvalidEncoding;

return P256.fromAffineCoordinates(.{ .x = x, .y = y });

},

else => return error.InvalidEncoding,

var out: [33]u8 = undefined;

const xy = p.affineCoordinates();

out[0] = if (xy.y.isOdd()) 3 else 2;

return out;

}

 

var out: [65]u8 = undefined;

out[0] = 4;

const xy = p.affineCoordinates();

return out;

}

 

/// Return a random point.

pub fn random() P256 {

}

 

/// Flip the sign of the X coordinate.

/// Multiply an elliptic curve point by a scalar.

/// Return error.IdentityElement if the result is the identity element.

pub fn mul(p: P256, s_: [32]u8, endian: std.builtin.Endian) IdentityElementError!P256 {

if (p.is_base) {

return pcMul16(&basePointPc, s, false);

}

/// Multiply an elliptic curve point by a *PUBLIC* scalar *IN VARIABLE TIME*

/// This can be used for signature verification.

pub fn mulPublic(p: P256, s_: [32]u8, endian: std.builtin.Endian) IdentityElementError!P256 {

if (p.is_base) {

return pcMul16(&basePointPc, s, true);

}

/// Double-base multiplication of public parameters - Compute (p1*s1)+(p2*s2) *IN VARIABLE TIME*

/// This can be used for signature verification.

pub fn mulDoubleBasePublic(p1: P256, s1_: [32]u8, p2: P256, s2_: [32]u8, endian: std.builtin.Endian) IdentityElementError!P256 {

try p1.rejectIdentity();

var pc1_array: [9]P256 = undefined;

const pc1 = if (p1.is_base) basePointPc[0..9] else pc: {

 

var s: [48]u8 = undefined;

while (true) {

crypto.random.bytes(&s);

if (!n.isZero()) {

return n;

}

debug.assert(bits > 0 and bits <= 512 and bits >= Fe.saturated_bits and bits <= Fe.saturated_bits * 3);

 

var s = s_;

for (s_, 0..) |x, i| s[s.len - 1 - i] = x;

}

var t = ScalarDouble{ .x1 = undefined, .x2 = Fe.zero, .x3 = Fe.zero };

var b = [_]u8{0} ** encoded_length;

const len = @min(s.len, 24);

b[0..len].* = s[0..len].*;

}

if (s_.len >= 24) {

var b = [_]u8{0} ** encoded_length;

const len = @min(s.len - 24, 24);

b[0..len].* = s[24..][0..len].*;

}

if (s_.len >= 48) {

var b = [_]u8{0} ** encoded_length;

const len = s.len - 48;

b[0..len].* = s[48..][0..len].*;

}

return t;

}

 

},

2, 3 => {

if (encoded.len != 48) return error.InvalidEncoding;

const y_is_odd = (encoding_type == 3);

const y = try recoverY(x, y_is_odd);

return P384{ .x = x, .y = y };

},

4 => {

if (encoded.len != 96) return error.InvalidEncoding;

return P384.fromAffineCoordinates(.{ .x = x, .y = y });

},

else => return error.InvalidEncoding,

var out: [49]u8 = undefined;

const xy = p.affineCoordinates();

out[0] = if (xy.y.isOdd()) 3 else 2;

return out;

}

 

var out: [97]u8 = undefined;

out[0] = 4;

const xy = p.affineCoordinates();

return out;

}

 

/// Return a random point.

pub fn random() P384 {

}

 

/// Flip the sign of the X coordinate.

/// Multiply an elliptic curve point by a scalar.

/// Return error.IdentityElement if the result is the identity element.

pub fn mul(p: P384, s_: [48]u8, endian: std.builtin.Endian) IdentityElementError!P384 {

if (p.is_base) {

return pcMul16(&basePointPc, s, false);

}

/// Multiply an elliptic curve point by a *PUBLIC* scalar *IN VARIABLE TIME*

/// This can be used for signature verification.

pub fn mulPublic(p: P384, s_: [48]u8, endian: std.builtin.Endian) IdentityElementError!P384 {

if (p.is_base) {

return pcMul16(&basePointPc, s, true);

}

/// Double-base multiplication of public parameters - Compute (p1*s1)+(p2*s2) *IN VARIABLE TIME*

/// This can be used for signature verification.

pub fn mulDoubleBasePublic(p1: P384, s1_: [48]u8, p2: P384, s2_: [48]u8, endian: std.builtin.Endian) IdentityElementError!P384 {

try p1.rejectIdentity();

var pc1_array: [9]P384 = undefined;

const pc1 = if (p1.is_base) basePointPc[0..9] else pc: {

 

var s: [64]u8 = undefined;

while (true) {

crypto.random.bytes(&s);

if (!n.isZero()) {

return n;

}

debug.assert(bits > 0 and bits <= 512 and bits >= Fe.saturated_bits and bits <= Fe.saturated_bits * 2);

 

var s = s_;

for (s_, 0..) |x, i| s[s.len - 1 - i] = x;

}

var t = ScalarDouble{ .x1 = undefined, .x2 = Fe.zero };

var b = [_]u8{0} ** encoded_length;

const len = @min(s.len, 32);

b[0..len].* = s[0..len].*;

}

if (s_.len >= 32) {

var b = [_]u8{0} ** encoded_length;

const len = @min(s.len - 32, 32);

b[0..len].* = s[32..][0..len].*;

}

return t;

}

 

 

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;

 

 

 

 

 

return SplitScalar{ .r1 = r1, .r2 = r2 };

}

},

2, 3 => {

if (encoded.len != 32) return error.InvalidEncoding;

const y_is_odd = (encoding_type == 3);

const y = try recoverY(x, y_is_odd);

return Secp256k1{ .x = x, .y = y };

},

4 => {

if (encoded.len != 64) return error.InvalidEncoding;

return Secp256k1.fromAffineCoordinates(.{ .x = x, .y = y });

},

else => return error.InvalidEncoding,

var out: [33]u8 = undefined;

const xy = p.affineCoordinates();

out[0] = if (xy.y.isOdd()) 3 else 2;

return out;

}

 

var out: [65]u8 = undefined;

out[0] = 4;

const xy = p.affineCoordinates();

return out;

}

 

/// Return a random point.

pub fn random() Secp256k1 {

}

 

/// Flip the sign of the X coordinate.

/// Multiply an elliptic curve point by a scalar.

/// Return error.IdentityElement if the result is the identity element.

pub fn mul(p: Secp256k1, s_: [32]u8, endian: std.builtin.Endian) IdentityElementError!Secp256k1 {

if (p.is_base) {

return pcMul16(&basePointPc, s, false);

}

/// Multiply an elliptic curve point by a *PUBLIC* scalar *IN VARIABLE TIME*

/// This can be used for signature verification.

pub fn mulPublic(p: Secp256k1, s_: [32]u8, endian: std.builtin.Endian) (IdentityElementError || NonCanonicalError)!Secp256k1 {

if (mem.eql(u8, &zero, &s)) {

return error.IdentityElement;

}

const pc = precompute(p, 8);

var lambda_p = try pcMul(&pc, Endormorphism.lambda_s, true);

var px = p;

 

// If a key is negative, flip the sign to keep it half-sized,

// and flip the sign of the Y point coordinate to compensate.

if (split_scalar.r1[split_scalar.r1.len / 2] != 0) {

px = px.neg();

}

if (split_scalar.r2[split_scalar.r2.len / 2] != 0) {

lambda_p = lambda_p.neg();

}

return mulDoubleBasePublicEndo(px, split_scalar.r1, lambda_p, split_scalar.r2);

/// Double-base multiplication of public parameters - Compute (p1*s1)+(p2*s2) *IN VARIABLE TIME*

/// This can be used for signature verification.

pub fn mulDoubleBasePublic(p1: Secp256k1, s1_: [32]u8, p2: Secp256k1, s2_: [32]u8, endian: std.builtin.Endian) IdentityElementError!Secp256k1 {

try p1.rejectIdentity();

var pc1_array: [9]Secp256k1 = undefined;

const pc1 = if (p1.is_base) basePointPc[0..9] else pc: {

 

var s: [48]u8 = undefined;

while (true) {

crypto.random.bytes(&s);

if (!n.isZero()) {

return n;

}

debug.assert(bits > 0 and bits <= 512 and bits >= Fe.saturated_bits and bits <= Fe.saturated_bits * 3);

 

var s = s_;

for (s_, 0..) |x, i| s[s.len - 1 - i] = x;

}

var t = ScalarDouble{ .x1 = undefined, .x2 = Fe.zero, .x3 = Fe.zero };

var b = [_]u8{0} ** encoded_length;

const len = @min(s.len, 24);

b[0..len].* = s[0..len].*;

}

if (s_.len >= 24) {

var b = [_]u8{0} ** encoded_length;

const len = @min(s.len - 24, 24);

b[0..len].* = s[24..][0..len].*;

}

if (s_.len >= 48) {

var b = [_]u8{0} ** encoded_length;

const len = s.len - 48;

b[0..len].* = s[48..][0..len].*;

}

return t;

}

 

const P256 = @import("../p256.zig").P256;

 

test "p256 ECDH key exchange" {

try testing.expect(shareda.equivalent(sharedb));

}

 

_ = try fmt.hexToBytes(&xs, xh);

var ys: [32]u8 = undefined;

_ = try fmt.hexToBytes(&ys, yh);

try testing.expect(p.equivalent(P256.basePoint));

}

 

p = p.add(P256.basePoint);

var xs: [32]u8 = undefined;

_ = try fmt.hexToBytes(&xs, xh);

}

}

 

p = p.dbl();

var xs: [32]u8 = undefined;

_ = try fmt.hexToBytes(&xs, xh);

}

}

 

}

 

test "p256 public key is the neutral element" {

const p = P256.random();

}

 

test "p256 public key is the neutral element (public verification)" {

const p = P256.random();

}

 

test "p256 field element non-canonical encoding" {

const s = [_]u8{0xff} ** 32;

}

 

test "p256 neutral element decoding" {

const p2 = P256.basePoint.dbl();

const s1 = [_]u8{0x01} ** 32;

const s2 = [_]u8{0x02} ** 32;

try testing.expect(pr1.equivalent(pr2));

}

 

const p2 = P256.basePoint.dbl();

const s1 = [_]u8{0xee} ** 32;

const s2 = [_]u8{0xdd} ** 32;

try testing.expect(pr1.equivalent(pr2));

}

 

const scalar = try P256.scalar.Scalar.fromBytes(.{

0x94, 0xa1, 0xbb, 0xb1, 0x4b, 0x90, 0x6a, 0x61, 0xa2, 0x80, 0xf2, 0x45, 0xf9, 0xe9, 0x3c, 0x7f,

0x3b, 0x4a, 0x62, 0x47, 0x82, 0x4f, 0x5d, 0x33, 0xb9, 0x67, 0x07, 0x87, 0x64, 0x2a, 0x68, 0xde,

const inverse = scalar.invert();

}

 

test "p256 scalar parity" {

 

const P384 = @import("../p384.zig").P384;

 

test "p384 ECDH key exchange" {

try testing.expect(shareda.equivalent(sharedb));

}

 

_ = try fmt.hexToBytes(&xs, xh);

var ys: [48]u8 = undefined;

_ = try fmt.hexToBytes(&ys, yh);

try testing.expect(p.equivalent(P384.basePoint));

}

 

p = p.add(P384.basePoint);

var xs: [48]u8 = undefined;

_ = try fmt.hexToBytes(&xs, xh);

}

}

 

p = p.dbl();

var xs: [48]u8 = undefined;

_ = try fmt.hexToBytes(&xs, xh);

}

}

 

}

 

test "p384 public key is the neutral element" {

const p = P384.random();

}

 

test "p384 public key is the neutral element (public verification)" {

const p = P384.random();

}

 

test "p384 field element non-canonical encoding" {

const s = [_]u8{0xff} ** 48;

}

 

test "p384 neutral element decoding" {

const p2 = P384.basePoint.dbl();

const s1 = [_]u8{0x01} ** 48;

const s2 = [_]u8{0x02} ** 48;

try testing.expect(pr1.equivalent(pr2));

}

 

const p2 = P384.basePoint.dbl();

const s1 = [_]u8{0xee} ** 48;

const s2 = [_]u8{0xdd} ** 48;

try testing.expect(pr1.equivalent(pr2));

}

 

0x94, 0xa1, 0xbb, 0xb1, 0x4b, 0x90, 0x6a, 0x61, 0xa2, 0x80, 0xf2, 0x45, 0xf9, 0xe9, 0x3c, 0x7f,

0x3b, 0x4a, 0x62, 0x47, 0x82, 0x4f, 0x5d, 0x33, 0xb9, 0x67, 0x07, 0x87, 0x64, 0x2a, 0x68, 0xde,

0x38, 0x36, 0xe8, 0x0f, 0xa2, 0x84, 0x6b, 0x4e, 0xf3, 0x9a, 0x02, 0x31, 0x24, 0x41, 0x22, 0xca,

const inverse = scalar.invert();

const inverse2 = inverse.invert();

try testing.expect(inverse2.equivalent(scalar));

 

const sq = scalar.sq();

 

const Secp256k1 = @import("../secp256k1.zig").Secp256k1;

 

test "secp256k1 ECDH key exchange" {

try testing.expect(shareda.equivalent(sharedb));

}

 

test "secp256k1 ECDH key exchange including public multiplication" {

try testing.expect(shareda.equivalent(sharedb));

}

 

_ = try fmt.hexToBytes(&xs, xh);

var ys: [32]u8 = undefined;

_ = try fmt.hexToBytes(&ys, yh);

try testing.expect(p.equivalent(Secp256k1.basePoint));

}

 

p = p.add(Secp256k1.basePoint);

var xs: [32]u8 = undefined;

_ = try fmt.hexToBytes(&xs, xh);

}

}

 

p = p.dbl();

var xs: [32]u8 = undefined;

_ = try fmt.hexToBytes(&xs, xh);

}

}

 

}

 

test "secp256k1 public key is the neutral element" {

const p = Secp256k1.random();

}

 

test "secp256k1 public key is the neutral element (public verification)" {

const p = Secp256k1.random();

}

 

test "secp256k1 field element non-canonical encoding" {

const s = [_]u8{0xff} ** 32;

}

 

test "secp256k1 neutral element decoding" {

const p2 = Secp256k1.basePoint.dbl();

const s1 = [_]u8{0x01} ** 32;

const s2 = [_]u8{0x02} ** 32;

try testing.expect(pr1.equivalent(pr2));

}

 

const scalar = try Secp256k1.scalar.Scalar.fromBytes(.{

0x94, 0xa1, 0xbb, 0xb1, 0x4b, 0x90, 0x6a, 0x61, 0xa2, 0x80, 0xf2, 0x45, 0xf9, 0xe9, 0x3c, 0x7f,

0x3b, 0x4a, 0x62, 0x47, 0x82, 0x4f, 0x5d, 0x33, 0xb9, 0x67, 0x07, 0x87, 0x64, 0x2a, 0x68, 0xde,

const inverse = scalar.invert();

}

 

test "secp256k1 scalar parity" {

 

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 pk = PublicKey.fromSec1(server_pub_key) catch {

return error.TlsDecryptFailure;

};

return error.TlsDecryptFailure;

};

},

else => {

return error.TlsIllegalParameter;

}

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)

 

inline fn big(x: anytype) @TypeOf(x) {

return switch (native_endian) {

};

}

 

 

const Cext = std.meta.Int(.unsigned, bits + 1);

var gt: T = 0;

var eq: T = 1;

var i = a.len;

while (i != 0) {

i -= 1;

const len = a.len;

debug.assert(len == b.len and len == result.len);

var carry: u1 = 0;

var i: usize = 0;

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

const ov1 = @addWithOverflow(a[i], b[i]);

const len = a.len;

debug.assert(len == b.len and len == result.len);

var borrow: u1 = 0;

var i: usize = 0;

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

const ov1 = @subWithOverflow(a[i], b[i]);

test "crypto.utils.timingSafeCompare" {

var a = [_]u8{10} ** 32;

var b = [_]u8{10} ** 32;

a[31] = 1;

a[0] = 20;

}

 

test "crypto.utils.timingSafe{Add,Sub}" {

while (iterations != 0) : (iterations -= 1) {

random.bytes(&a);

random.bytes(&b);

_ = timingSafeSub(u8, &a, &b, &c, endian); // a-b

_ = timingSafeAdd(u8, &c, &b, &c, endian); // (a-b)+b

try testing.expectEqualSlices(u8, &c, &a);

 

if (hdr.e_ident[elf.EI_VERSION] != 1) return error.InvalidElfVersion;

 

const endian: std.builtin.Endian = switch (hdr.e_ident[elf.EI_DATA]) {

else => return error.InvalidElfEndian,

};

assert(endian == native_endian); // this is our own debug info

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

if (missing_debug_info) return error.MissingDebugInfo;

 

var di = DW.DwarfInfo{

.sections = sections,

.is_macho = true,

};

 

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

 

if (hdr32.e_ident[EI_VERSION] != 1) return error.InvalidElfVersion;

 

const endian: std.builtin.Endian = switch (hdr32.e_ident[EI_DATA]) {

else => return error.InvalidElfEndian,

};

const need_bswap = endian != native_endian;

 

}

 

pub fn readU64Unchecked(self: FloatStream) u64 {

}

 

pub fn readU64(self: FloatStream) ?u64 {

 

if (!isEightDigits(v)) {

break;

}

d.num_digits += 8;

stream.advance(8);

}

 

 

test "ComponentIterator windows UTF-16" {

// TODO: Fix on big endian architectures

return error.SkipZigTest;

}

 

 

}

 

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

 

var h1: u32 = seed ^ len;

for (@as([*]align(1) const u32, @ptrCast(str.ptr))[0..(len >> 2)]) |v| {

var k1: u32 = v;

k1 = @byteSwap(k1);

k1 *%= m;

k1 ^= k1 >> 24;

var h1: u64 = seed ^ (@as(u64, str.len) *% m);

for (@as([*]align(1) const u64, @ptrCast(str.ptr))[0 .. str.len / 8]) |v| {

var k1: u64 = v;

k1 = @byteSwap(k1);

k1 *%= m;

k1 ^= k1 >> 47;

if (rest > 0) {

var k1: u64 = 0;

@memcpy(@as([*]u8, @ptrCast(&k1))[0..rest], str[offset..]);

k1 = @byteSwap(k1);

h1 ^= k1;

h1 *%= m;

var h1: u32 = seed;

for (@as([*]align(1) const u32, @ptrCast(str.ptr))[0..(len >> 2)]) |v| {

var k1: u32 = v;

k1 = @byteSwap(k1);

k1 *%= c1;

k1 = rotl32(k1, 15);

var v1: u64 = 0x1234567812345678;

var v0le: u32 = v0;

var v1le: u64 = v1;

v0le = @byteSwap(v0le);

v1le = @byteSwap(v1le);

}

var v1: u64 = 0x1234567812345678;

var v0le: u32 = v0;

var v1le: u64 = v1;

v0le = @byteSwap(v0le);

v1le = @byteSwap(v1le);

}

var v1: u64 = 0x1234567812345678;

var v0le: u32 = v0;

var v1le: u64 = v1;

v0le = @byteSwap(v0le);

v1le = @byteSwap(v1le);

}

 

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;

}

 

inline fn swap(x: anytype) @TypeOf(x) {

}

 

inline fn disableAutoVectorization(x: anytype) void {

 

const FreeBlock = struct {

data: []u128,

 

 

fn totalPages(self: FreeBlock) usize {

return self.data.len * 128;

 

 

test {

const native_endian = comptime builtin.cpu.arch.endian();

// https://github.com/ziglang/zig/issues/13782

return error.SkipZigTest;

}

 

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

 

const native_endian = comptime builtin.cpu.arch.endian();

// https://github.com/ziglang/zig/issues/13782

return error.SkipZigTest;

}

 

 

inline fn intShift(comptime T: type, x: anytype) T {

switch (@import("builtin").cpu.arch.endian()) {

}

}

 

 

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

}

 

 

pub fn readStructBig(self: Self, comptime T: type) anyerror!T {

var res = try self.readStruct(T);

mem.byteSwapAllFields(T, &res);

}

return res;

 

const n = if (self.bit_count >= bits) @as(u3, @intCast(bits)) else self.bit_count;

const shift = u7_bit_count - n;

switch (endian) {

out_buffer = @as(Buf, self.bit_buffer >> shift);

if (n >= u7_bit_count)

self.bit_buffer = 0

else

self.bit_buffer <<= n;

},

const value = (self.bit_buffer << shift) >> shift;

out_buffer = @as(Buf, value);

if (n >= u7_bit_count)

};

 

switch (endian) {

if (n >= u8_bit_count) {

out_buffer <<= @as(u3, @intCast(u8_bit_count - 1));

out_buffer <<= 1;

self.bit_buffer = @as(u7, @truncate(next_byte << @as(u3, @intCast(n - 1))));

self.bit_count = shift;

},

if (n >= u8_bit_count) {

out_buffer |= @as(Buf, next_byte) << @as(BufShift, @intCast(out_bits.*));

out_bits.* += u8_bit_count;

const mem_le = [_]u8{ 0b00011101, 0b10010101 };

 

var mem_in_be = io.fixedBufferStream(&mem_be);

 

var out_bits: usize = undefined;

 

try expectError(error.EndOfStream, bit_stream_be.readBitsNoEof(u1, 1));

 

var mem_in_le = io.fixedBufferStream(&mem_le);

 

try expect(1 == try bit_stream_le.readBits(u2, 1, &out_bits));

try expect(out_bits == 1);

 

 

const high_byte_shift = @as(BufShift, @intCast(buf_bit_count - u8_bit_count));

var in_buffer = switch (endian) {

};

var in_bits = bits;

 

const bits_remaining = u8_bit_count - self.bit_count;

const n = @as(u3, @intCast(if (bits_remaining > bits) bits else bits_remaining));

switch (endian) {

const shift = @as(BufShift, @intCast(high_byte_shift + self.bit_count));

const v = @as(u8, @intCast(in_buffer >> shift));

self.bit_buffer |= v;

in_buffer <<= n;

},

const v = @as(u8, @truncate(in_buffer)) << @as(u3, @intCast(self.bit_count));

self.bit_buffer |= v;

in_buffer >>= n;

//copy bytes until we can't fill one anymore, then leave the rest in bit_buffer

while (in_bits >= u8_bit_count) {

switch (endian) {

const v = @as(u8, @intCast(in_buffer >> high_byte_shift));

try self.forward_writer.writeByte(v);

in_buffer <<= @as(u3, @intCast(u8_bit_count - 1));

in_buffer <<= 1;

},

const v = @as(u8, @truncate(in_buffer));

try self.forward_writer.writeByte(v);

in_buffer >>= @as(u3, @intCast(u8_bit_count - 1));

if (in_bits > 0) {

self.bit_count = @as(u4, @intCast(in_bits));

self.bit_buffer = switch (endian) {

};

}

}

var mem_le = [_]u8{0} ** 2;

 

var mem_out_be = io.fixedBufferStream(&mem_be);

 

try bit_stream_be.writeBits(@as(u2, 1), 1);

try bit_stream_be.writeBits(@as(u5, 2), 2);

try bit_stream_be.writeBits(@as(u0, 0), 0);

 

var mem_out_le = io.fixedBufferStream(&mem_le);

 

try bit_stream_le.writeBits(@as(u2, 1), 1);

try bit_stream_le.writeBits(@as(u5, 2), 2);

 

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

try std.testing.expectError(

error.EndOfStream,

);

try std.testing.expectError(

error.EndOfStream,

 

}

}

 

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

return self.writeAll(&bytes);

}

 

const endian_mask: usize = (@sizeOf(Limb) - 1) << 3;

 

var bytes = std.mem.sliceAsBytes(r.limbs);

 

var k: usize = 0;

while (k < ((bit_count + 1) / 2)) : (k += 1) {

 

// This "endian mask" remaps a low (LE) byte to the corresponding high

// (BE) byte in the Limb, without changing which limbs we are indexing

i ^= endian_mask;

rev_i ^= endian_mask;

}

// Calculate signed-magnitude representation for output

if (signedness == .signed) {

const last_bit = switch (native_endian) {

};

if (last_bit == 1) {

r.bitNotWrap(r.toConst(), .unsigned, bit_count); // Bitwise NOT.

 

// This "endian mask" remaps a low (LE) byte to the corresponding high

// (BE) byte in the Limb, without changing which limbs we are indexing

i ^= endian_mask;

rev_i ^= endian_mask;

}

// Calculate signed-magnitude representation for output

if (signedness == .signed) {

const last_byte = switch (native_endian) {

};

 

if (last_byte & (1 << 7) != 0) { // Check sign bit of last byte

if (signedness == .signed) {

const total_bits = bit_offset + bit_count;

var last_byte = switch (endian) {

};

 

const sign_bit = @as(u8, 1) << @as(u3, @intCast((total_bits - 1) % 8));

 

var buffer1 = try testing.allocator.alloc(u8, 64);

defer testing.allocator.free(buffer1);

 

const abi_size = 64;

 

for (endians) |endian| {

// (3) should sign-extend any bits from bit_count to 8 * abi_size

 

var bit_count: usize = 12 * 8 + 1;

try testing.expect(std.mem.eql(u8, buffer1, &[_]u8{ 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1, 0xaa, 0xaa, 0xaa }));

try testing.expect(std.mem.eql(u8, buffer1, &[_]u8{ 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xaa, 0xaa, 0xaa }));

try testing.expect(std.mem.eql(u8, buffer1, &[_]u8{ 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1, 0x0, 0x0, 0x0 }));

try testing.expect(std.mem.eql(u8, buffer1, &[_]u8{ 0x0, 0x0, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd }));

 

@memset(buffer1, 0xaa);

try a.set(-0x01_02030405_06070809_0a0b0c0d);

bit_count = 12 * 8 + 2;

 

try testing.expect(std.mem.eql(u8, buffer1, &[_]u8{ 0xf3, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xaa, 0xaa, 0xaa }));

try testing.expect(std.mem.eql(u8, buffer1, &[_]u8{ 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8, 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf3, 0xaa, 0xaa, 0xaa }));

try testing.expect(std.mem.eql(u8, buffer1, &[_]u8{ 0xf3, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff, 0xff, 0xff }));

try testing.expect(std.mem.eql(u8, buffer1, &[_]u8{ 0xff, 0xff, 0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8, 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf3 }));

}

 

 

// Test zero

 

try testing.expect(std.mem.eql(u8, buffer1, &(([_]u8{0} ** 13) ++ ([_]u8{0xaa} ** 3))));

try testing.expect(std.mem.eql(u8, buffer1, &(([_]u8{0} ** 13) ++ ([_]u8{0xaa} ** 3))));

try testing.expect(std.mem.eql(u8, buffer1, &(([_]u8{0} ** 16))));

try testing.expect(std.mem.eql(u8, buffer1, &(([_]u8{0} ** 16))));

 

@memset(buffer1, 0xaa);

 

// Test negative zero

 

try testing.expect(std.mem.eql(u8, buffer1, &(([_]u8{0} ** 13) ++ ([_]u8{0xaa} ** 3))));

try testing.expect(std.mem.eql(u8, buffer1, &(([_]u8{0} ** 13) ++ ([_]u8{0xaa} ** 3))));

try testing.expect(std.mem.eql(u8, buffer1, &(([_]u8{0} ** 16))));

try testing.expect(std.mem.eql(u8, buffer1, &(([_]u8{0} ** 16))));

}

 

// Test 0x01_02030405_06070809_0a0b0c0d

 

buffer = &[_]u8{ 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0xb };

try testing.expect(m.toConst().orderAgainstScalar(0x01_02030405_06070809_0a0b0c0d) == .eq);

 

buffer = &[_]u8{ 0xb, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd };

try testing.expect(m.toConst().orderAgainstScalar(0x01_02030405_06070809_0a0b0c0d) == .eq);

 

buffer = &[_]u8{ 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0xab, 0xaa, 0xaa, 0xaa };

try testing.expect(m.toConst().orderAgainstScalar(0x01_02030405_06070809_0a0b0c0d) == .eq);

 

buffer = &[_]u8{ 0xaa, 0xaa, 0xaa, 0xab, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd };

try testing.expect(m.toConst().orderAgainstScalar(0x01_02030405_06070809_0a0b0c0d) == .eq);

 

bit_count = @sizeOf(Limb) * 8;

// Test 0x0a0a0a0a_02030405_06070809_0a0b0c0d

 

buffer = &[_]u8{ 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0xaa };

try testing.expect(m.toConst().orderAgainstScalar(@as(Limb, @truncate(0xaa_02030405_06070809_0a0b0c0d))) == .eq);

 

buffer = &[_]u8{ 0xaa, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd };

try testing.expect(m.toConst().orderAgainstScalar(@as(Limb, @truncate(0xaa_02030405_06070809_0a0b0c0d))) == .eq);

 

buffer = &[_]u8{ 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0xaa, 0xaa, 0xaa, 0xaa };

try testing.expect(m.toConst().orderAgainstScalar(@as(Limb, @truncate(0xaaaaaaaa_02030405_06070809_0a0b0c0d))) == .eq);

 

buffer = &[_]u8{ 0xaa, 0xaa, 0xaa, 0xaa, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd };

try testing.expect(m.toConst().orderAgainstScalar(@as(Limb, @truncate(0xaaaaaaaa_02030405_06070809_0a0b0c0d))) == .eq);

 

bit_count = 12 * 8 + 2;

// Test -0x01_02030405_06070809_0a0b0c0d

 

buffer = &[_]u8{ 0xf3, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0x02 };

try testing.expect(m.toConst().orderAgainstScalar(-0x01_02030405_06070809_0a0b0c0d) == .eq);

 

buffer = &[_]u8{ 0x02, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8, 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf3 };

try testing.expect(m.toConst().orderAgainstScalar(-0x01_02030405_06070809_0a0b0c0d) == .eq);

 

buffer = &[_]u8{ 0xf3, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0x02, 0xaa, 0xaa, 0xaa };

try testing.expect(m.toConst().orderAgainstScalar(-0x01_02030405_06070809_0a0b0c0d) == .eq);

 

buffer = &[_]u8{ 0xaa, 0xaa, 0xaa, 0x02, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8, 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf3 };

try testing.expect(m.toConst().orderAgainstScalar(-0x01_02030405_06070809_0a0b0c0d) == .eq);

 

// Test 0

 

buffer = &([_]u8{0} ** 16);

try testing.expect(m.toConst().orderAgainstScalar(0x0) == .eq);

try testing.expect(m.toConst().orderAgainstScalar(0x0) == .eq);

try testing.expect(m.toConst().orderAgainstScalar(0x0) == .eq);

try testing.expect(m.toConst().orderAgainstScalar(0x0) == .eq);

 

bit_count = 0;

buffer = &([_]u8{0xaa} ** 16);

try testing.expect(m.toConst().orderAgainstScalar(0x0) == .eq);

try testing.expect(m.toConst().orderAgainstScalar(0x0) == .eq);

try testing.expect(m.toConst().orderAgainstScalar(0x0) == .eq);

try testing.expect(m.toConst().orderAgainstScalar(0x0) == .eq);

}

 

var buffer: []const u8 = undefined;

 

buffer = &([_]u8{0} ** 13);

try testing.expect(m.toConst().orderAgainstScalar(0x0) == .eq);

try testing.expect(m.toConst().orderAgainstScalar(0x0) == .eq);

 

buffer = &([_]u8{0} ** 16);

try testing.expect(m.toConst().orderAgainstScalar(0x0) == .eq);

try testing.expect(m.toConst().orderAgainstScalar(0x0) == .eq);

}

 

 

pub fn readVarInt(comptime ReturnType: type, bytes: []const u8, endian: Endian) ReturnType {

var result: ReturnType = 0;

switch (endian) {

for (bytes) |b| {

result = (result << 8) | b;

}

},

const ShiftType = math.Log2Int(ReturnType);

for (bytes, 0..) |b, index| {

result = result | (@as(ReturnType, b) << @as(ShiftType, @intCast(index * 8)));

const pad = @as(Log2N, @intCast(@bitSizeOf(T) - bit_count));

 

const lowest_byte = switch (endian) {

};

const read_bytes = bytes[lowest_byte..][0..read_size];

 

const value = if (read_size == 1) b: {

break :b @as(uN, @truncate(read_bytes[0] >> bit_shift));

} else b: {

const head = @as(uN, @truncate(read_bytes[i] >> bit_shift));

const tail_shift = @as(Log2N, @intCast(@as(u4, 8) - bit_shift));

const tail = @as(uN, @truncate(read_bytes[1 - i]));

// Copy the value out (respecting endianness), accounting for bit_shift

var int: uN = 0;

switch (endian) {

for (read_bytes[0 .. read_size - 1]) |elem| {

int = elem | (int << 8);

}

int = (read_bytes[read_size - 1] >> bit_shift) | (int << (@as(u4, 8) - bit_shift));

},

int = read_bytes[0] >> bit_shift;

for (read_bytes[1..], 0..) |elem, i| {

int |= (@as(uN, elem) << @as(Log2N, @intCast((8 * (i + 1) - bit_shift))));

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

}

 

 

 

 

 

 

}

 

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

}

 

pub const readPackedIntNative = switch (native_endian) {

};

 

pub const readPackedIntForeign = switch (native_endian) {

};

 

/// Loads an integer from packed memory.

///

pub fn readPackedInt(comptime T: type, bytes: []const u8, bit_offset: usize, endian: Endian) T {

switch (endian) {

}

}

 

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 {

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

};

 

pub const writePackedIntForeign = switch (native_endian) {

};

 

/// Stores an integer to packed memory.

///

pub fn writePackedInt(comptime T: type, bytes: []u8, bit_offset: usize, value: T, endian: Endian) void {

switch (endian) {

}

}

 

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

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

///

const bit_shift = @as(u3, @intCast(bit_offset % 8));

const write_size = (bit_count + bit_shift + 7) / 8;

const lowest_byte = switch (endian) {

};

const write_bytes = bytes[lowest_byte..][0..write_size];

 

var remaining: T = value;

 

// Iterate bytes forward for Little-endian, backward for Big-endian

 

var i: isize = start; // isize for signed index arithmetic

 

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 {

/// Converts a little-endian integer to host endianness.

pub fn littleToNative(comptime T: type, x: T) T {

return switch (native_endian) {

};

}

 

/// Converts a big-endian integer to host endianness.

pub fn bigToNative(comptime T: type, x: T) T {

return switch (native_endian) {

};

}

 

/// Converts an integer from specified endianness to host endianness.

pub fn toNative(comptime T: type, x: T, endianness_of_x: Endian) T {

return switch (endianness_of_x) {

};

}

 

/// Converts an integer which has host endianness to the desired endianness.

pub fn nativeTo(comptime T: type, x: T, desired_endianness: Endian) T {

return switch (desired_endianness) {

};

}

 

/// Converts an integer which has host endianness to little endian.

pub fn nativeToLittle(comptime T: type, x: T) T {

return switch (native_endian) {

};

}

 

/// Converts an integer which has host endianness to big endian.

pub fn nativeToBig(comptime T: type, x: T) T {

return switch (native_endian) {

};

}

 

test "asBytes" {

const deadbeef = @as(u32, 0xDEADBEEF);

const deadbeef_bytes = switch (native_endian) {

};

 

try testing.expect(eql(u8, asBytes(&deadbeef), deadbeef_bytes));

.d = 0xA1,

};

switch (native_endian) {

try testing.expect(eql(u8, asBytes(&inst), "\xBE\xEF\xDE\xA1"));

},

try testing.expect(eql(u8, asBytes(&inst), "\xA1\xDE\xEF\xBE"));

},

}

test "toBytes" {

var my_bytes = toBytes(@as(u32, 0x12345678));

switch (native_endian) {

}

 

my_bytes[0] = '\x99';

switch (native_endian) {

}

}

 

test "bytesAsValue" {

const deadbeef = @as(u32, 0xDEADBEEF);

const deadbeef_bytes = switch (native_endian) {

};

 

try testing.expect(deadbeef == bytesAsValue(u32, deadbeef_bytes).*);

 

var codeface_bytes: [4]u8 = switch (native_endian) {

}.*;

var codeface = bytesAsValue(u32, &codeface_bytes);

try testing.expect(codeface.* == 0xC0DEFACE);

.d = 0xA1,

};

const inst_bytes = switch (native_endian) {

};

const inst2 = bytesAsValue(S, inst_bytes);

try testing.expect(meta.eql(inst, inst2.*));

}

test "bytesToValue" {

const deadbeef_bytes = switch (native_endian) {

};

 

const deadbeef = bytesToValue(u32, deadbeef_bytes);

const slice = sliceAsBytes(bytes[0..]);

try testing.expect(slice.len == 4);

try testing.expect(eql(u8, slice, switch (native_endian) {

}));

}

 

doNotOptimizeAway(@as(f64, 0.0));

doNotOptimizeAway([_]u8{0} ** 4);

doNotOptimizeAway([_]u8{0} ** 100);

}

 

test "alignForward" {

}

 

test "read/write(Var)PackedInt" {

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

 

switch (builtin.cpu.arch) {

return error.SkipZigTest;

}

 

const expect = std.testing.expect;

var prng = std.rand.DefaultPrng.init(1234);

const random = prng.random();

 

}

const big_endian_parts = @as(*align(1) const [8]u16, @ptrCast(&self.sa.addr));

const native_endian_parts = switch (native_endian) {

var buf: [8]u16 = undefined;

for (big_endian_parts, 0..) |part, i| {

buf[i] = mem.bigToNative(u16, part);

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

 

fn splitValue64(val: i64) [2]u32 {

const u: u64 = @bitCast(val);

switch (native_endian) {

@as(u32, @truncate(u)),

@as(u32, @truncate(u >> 32)),

},

@as(u32, @truncate(u >> 32)),

@as(u32, @truncate(u)),

},

 

fn toAudit(arch: std.Target.Cpu.Arch) u32 {

var res: u32 = @intFromEnum(arch.toElfMachine());

switch (arch) {

.aarch64,

.mips64,

 

fn endian_swap(endian: std.builtin.Endian, comptime size: Size, dst: Reg) Insn {

return Insn{

.code = switch (endian) {

},

.dst = @intFromEnum(dst),

.src = 0,

}

 

pub fn le(comptime size: Size, dst: Reg) Insn {

}

 

pub fn be(comptime size: Size, dst: Reg) Insn {

}

 

pub fn call(helper: Helper) Insn {

 

//! manner to the OpenSSH example:

//!

//! ```zig

//! pub const low = 0;

//! pub const high = @sizeOf(u32);

//! } else struct {

 

 

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

}

}

 

 

Data4: [8]u8,

 

const hex_offsets = switch (builtin.target.cpu.arch.endian()) {

0, 2, 4, 6,

9, 11, 14, 16,

19, 21, 24, 26,

28, 30, 32, 34,

},

6, 4, 2, 0,

11, 9, 16, 14,

19, 21, 24, 26,

 

if (endian != native_endian) value = @byteSwap(value);

 

switch (endian) {

value <<= @as(Shift, @intCast(head_keep_bits));

value >>= @as(Shift, @intCast(head_keep_bits));

value >>= @as(Shift, @intCast(tail_keep_bits));

},

value <<= @as(Shift, @intCast(tail_keep_bits));

value >>= @as(Shift, @intCast(tail_keep_bits));

value >>= @as(Shift, @intCast(head_keep_bits));

const head_keep_bits = bit_index - (start_byte * 8);

const tail_keep_bits = container_bits - (int_bits + head_keep_bits);

const keep_shift = switch (endian) {

};

 

//position the bits where they need to be in the container

 

test "PackedIntIo" {

const bytes = [_]u8{ 0b01101_000, 0b01011_110, 0b00011_101 };

}

 

test "PackedIntArray init" {

var i = @as(usize, 0);

while (i < packed_slice_cast_2.len) : (i += 1) {

const val = switch (native_endian) {

};

try testing.expect(packed_slice_cast_2.get(i) == val);

}

i = 0;

while (i < packed_slice_cast_4.len) : (i += 1) {

const val = switch (native_endian) {

};

try testing.expect(packed_slice_cast_4.get(i) == val);

}

i = 0;

while (i < packed_slice_cast_3.len) : (i += 1) {

const val = switch (native_endian) {

};

try testing.expect(packed_slice_cast_3.get(i) == val);

}

 

test "PackedInt(Array/Slice)Endian" {

{

var packed_array_be = PackedArrayBe.init([_]u4{ 0, 1, 2, 3, 4, 5, 6, 7 });

try testing.expect(packed_array_be.bytes[0] == 0b00000001);

try testing.expect(packed_array_be.bytes[1] == 0b00100011);

try testing.expect(packed_array_be.get(i) == i);

}

 

i = 0;

while (i < packed_slice_le.len) : (i += 1) {

const val = if (i % 2 == 0) i + 1 else i - 1;

try testing.expect(packed_slice_le.get(i) == val);

}

 

i = 0;

while (i < packed_slice_le_shift.len) : (i += 1) {

const val = if (i % 2 == 0) i else i + 2;

}

 

{

var packed_array_be = PackedArrayBe.init([_]u11{ 0, 1, 2, 3, 4, 5, 6, 7 });

try testing.expect(packed_array_be.bytes[0] == 0b00000000);

try testing.expect(packed_array_be.bytes[1] == 0b00000000);

try testing.expect(packed_array_be.get(i) == i);

}

 

try testing.expect(packed_slice_le.get(0) == 0b00000000000);

try testing.expect(packed_slice_le.get(1) == 0b00010000000);

try testing.expect(packed_slice_le.get(2) == 0b00000000100);

try testing.expect(packed_slice_le.get(6) == 0b10000010000);

try testing.expect(packed_slice_le.get(7) == 0b00000111001);

 

try testing.expect(packed_slice_le_shift.get(0) == 0b00010000000);

try testing.expect(packed_slice_le_shift.get(1) == 0b00000000100);

try testing.expect(packed_slice_le_shift.get(2) == 0b00000000000);

 

};

 

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

 

var sect_cont_offset: usize = 0;

if (section_contrib_size != 0) {

error.InvalidValue => return error.InvalidDebugInfo,

else => |e| return e,

};

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

}

 

const Random = std.rand.Random;

const Self = @This();

 

 

state: Ascon,

 

 

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

}

 

.loongarch32,

.loongarch64,

.arc,

 

.armeb,

.aarch64_be,

.tce,

.lanai,

.s390x,

};

}

 

 

if (!std.mem.eql(u8, &legacy_header.magic, "TZif")) return error.BadHeader;

if (legacy_header.version != 0 and legacy_header.version != '2' and legacy_header.version != '3') return error.BadVersion;

 

std.mem.byteSwapAllFields(@TypeOf(legacy_header.counts), &legacy_header.counts);

}

 

var header = try reader.readStruct(Header);

if (!std.mem.eql(u8, &header.magic, "TZif")) return error.BadHeader;

if (header.version != '2' and header.version != '3') return error.BadVersion;

std.mem.byteSwapAllFields(@TypeOf(header.counts), &header.counts);

}

 

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

}

 

const Allocator = std.mem.Allocator;

const assert = std.debug.assert;

const native_endian = builtin.target.cpu.arch.endian();

 

const hdr64 = @as(*elf.Elf64_Ehdr, @ptrCast(&hdr_buf));

if (!mem.eql(u8, hdr32.e_ident[0..4], elf.MAGIC)) return error.InvalidElfMagic;

const elf_endian: std.builtin.Endian = switch (hdr32.e_ident[elf.EI_DATA]) {

else => return error.InvalidElfEndian,

};

const need_bswap = elf_endian != native_endian;

const hdr64 = @as(*elf.Elf64_Ehdr, @ptrCast(&hdr_buf));

if (!mem.eql(u8, hdr32.e_ident[0..4], elf.MAGIC)) return error.InvalidElfMagic;

const elf_endian: std.builtin.Endian = switch (hdr32.e_ident[elf.EI_DATA]) {

else => return error.InvalidElfEndian,

};

const need_bswap = elf_endian != native_endian;

 

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

 

// cause miscompilations; it only means the field pointer uses bit masking when it

// might not be strictly necessary.

if (parent_align != .none and ptr_ty_data.packed_offset.bit_offset % 8 == 0 and

{

const elem_size_bytes = try sema.typeAbiSize(ptr_ty_data.child.toType());

const elem_size_bits = ptr_ty_data.child.toType().bitSize(mod);

try sema.checkComptimeVarStore(block, src, mut_kit.mut_decl);

 

switch (mut_kit.pointee) {

.direct => |val_ptr| {

if (mut_kit.mut_decl.runtime_index == .comptime_field_ptr) {

val_ptr.* = (try val_ptr.intern(operand_ty, mod)).toValue();

const ComptimePtrMutationKit = struct {

mut_decl: InternPool.Key.Ptr.Addr.MutDecl,

pointee: union(enum) {

/// The pointer type matches the actual comptime Value so a direct

/// modification is possible.

direct: *Value,

const eu_ty = mod.intern_pool.typeOf(eu_ptr).toType().childType(mod);

var parent = try sema.beginComptimePtrMutation(block, src, eu_ptr.toValue(), eu_ty);

switch (parent.pointee) {

.direct => |val_ptr| {

const payload_ty = parent.ty.errorUnionPayload(mod);

if (val_ptr.ip_index == .none and val_ptr.tag() == .eu_payload) {

const opt_ty = mod.intern_pool.typeOf(opt_ptr).toType().childType(mod);

var parent = try sema.beginComptimePtrMutation(block, src, opt_ptr.toValue(), opt_ty);

switch (parent.pointee) {

.direct => |val_ptr| {

const payload_ty = parent.ty.optionalChild(mod);

switch (val_ptr.ip_index) {

var parent = try sema.beginComptimePtrMutation(block, src, elem_ptr.base.toValue(), base_elem_ty);

 

switch (parent.pointee) {

.direct => |val_ptr| switch (parent.ty.zigTypeTag(mod)) {

.Array, .Vector => {

const check_len = parent.ty.arrayLenIncludingSentinel(mod);

if (elem_ptr.index >= check_len) {

// TODO have the parent include the decl so we can say "declared here"

return sema.fail(block, src, "comptime store of index {d} out of bounds of array length {d}", .{

elem_ptr.index, check_len,

});

}

 

// We might have a pointer to multiple elements of the array (e.g. a pointer

// to a sub-array). In this case, we just have to reinterpret the relevant

 

var parent = try sema.beginComptimePtrMutation(block, src, field_ptr.base.toValue(), base_child_ty);

switch (parent.pointee) {

.direct => |val_ptr| switch (val_ptr.ip_index) {

.empty_struct => {

const duped = try sema.arena.create(Value);

if (field_size > old_size) {

const min_size = @max(old_size, 1);

switch (endian) {

}

}

 

error.ReinterpretDeclRef => return null,

};

 

},

.Auto => unreachable,

};

 

const abi_size = int_info.bits >> 3;

const abi_align = operand_ty.abiAlignment(mod);

const opposite_endian_asi = switch (self.target.cpu.arch.endian()) {

};

 

switch (operand) {

 

// SPARCv9 instructions are always arranged in BE regardless of the

// endianness mode the CPU is running in (Section 3.1 of the ISA specification).

// This is to ease porting in case someone wants to do a LE SPARCv9 backend.

 

std.mem.writeInt(u32, try emit.code.addManyAsArray(4), instruction.toU32(), endian);

}

 

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 {

 

var creader = std.io.countingReader(stream.reader());

const reader = creader.reader();

const imm = switch (kind) {

else => unreachable,

};

dis.pos += std.math.cast(usize, creader.bytes_read) orelse return error.Overflow;

fn parseOffset(dis: *Disassembler) !u64 {

var stream = std.io.fixedBufferStream(dis.code[dis.pos..]);

const reader = stream.reader();

dis.pos += 8;

return offset;

}

const disp = disp: {

if (sib) |info| {

if (info.base == 0b101 and modrm.mod == 0) {

}

}

if (modrm.rip()) {

}

break :disp switch (modrm.mod) {

0b00 => 0,

0b11 => unreachable,

};

};

 

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 {

}

};

}

 

try writer.writeAll(", &");

try f.writeCValue(writer, operand_lval, .Other);

try writer.writeAll(", sizeof(");

try writer.writeAll("));\n");

 

// Ensure padding bits have the expected value.

try f.writeCValue(writer, local, .Other);

if (dest_cty.castTag(.array)) |pl| {

try writer.print("[{d}]", .{switch (target.cpu.arch.endian()) {

}});

const elem_cty = f.indexToCType(pl.data.elem_type);

wrap_cty = elem_cty.toSignedness(dest_info.signedness);

try f.writeCValue(writer, local, .Other);

if (dest_cty.castTag(.array)) |pl| {

try writer.print("[{d}]", .{switch (target.cpu.arch.endian()) {

}});

}

if (need_bitcasts) try writer.writeByte(')');

else => .{

.cty = CType.initTag(.void),

.count = 1,

.homogeneous = true,

},

.zig_u128, .zig_i128 => .{

.cty = CType.initTag(.uint64_t),

.count = 2,

.homogeneous = false,

},

.array => info: {

const most_significant_limb_i = wrap.len - limbs_per_c_limb;

while (limb_offset < wrap.len) : (limb_offset += limbs_per_c_limb) {

const limb_i = switch (c_limb_info.endian) {

};

var c_limb_mut = BigInt.Mutable{

.limbs = wrap.limbs[limb_i..][0..limbs_per_c_limb],

 

writer: anytype,

) @TypeOf(writer).Error!void {

try writer.writeByte(switch (self.target.cpu.arch.endian()) {

});

switch (self.target.cpu.arch) {

.amdgcn,

else

payload_llvm_ty;

const loaded = try fg.wip.load(access_kind, load_llvm_ty, payload_ptr, payload_alignment, "");

try fg.wip.bin(.lshr, loaded, try o.builder.intValue(

load_llvm_ty,

(payload_ty.abiSize(mod) - (std.math.divCeil(u64, payload_ty.bitSize(mod), 8) catch unreachable)) * 8,

 

 

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,

},

}

 

 

const endian = self.base.options.target.cpu.arch.endian();

hdr_buf[index] = switch (endian) {

};

index += 1;

 

 

 

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