srctree

},

);

 

 

try w.print("#define {s}DENORM_MIN__ {s}{s}\n", .{ prefix_slice, denormMin, ext });

try w.print("#define {s}HAS_DENORM__\n", .{prefix_slice});

ty = if (unsigned) comp.types.int64.makeIntegerUnsigned() else comp.types.int64;

}

 

 

 

}

 

pub fn hasFloat128(comp: *const Compilation) bool {

ty = if (unsigned) comp.types.int64.makeIntegerUnsigned() else comp.types.int64;

}

 

 

}

 

fn generateIntWidth(comp: *Compilation, w: anytype, name: []const u8, ty: Type) !void {

 

}, .program);

}

 

const sysroot = tc.getSysroot();

const target = tc.getTarget();

if (sysroot.len == 0 and target.os.tag == .linux and tc.filesystem.exists("/opt/rh")) {

}

}

 

fn collectLibDirsAndTriples(

tc: *Toolchain,

) !void {

const AArch64LibDirs: [2][]const u8 = .{ "/lib64", "/lib" };

const AArch64Triples: [4][]const u8 = .{ "aarch64-none-linux-gnu", "aarch64-linux-gnu", "aarch64-redhat-linux", "aarch64-suse-linux" };

else

target_util.get32BitArchVariant(target);

 

try collectLibDirsAndTriples(

tc,

&candidate_lib_dirs,

}

}

 

const gcc_toolchain_dir = gccToolchainDir(tc);

if (gcc_toolchain_dir.len != 0) {

const adjusted = if (gcc_toolchain_dir[gcc_toolchain_dir.len - 1] == '/')

}

 

const v0 = GCCVersion.parse("0.0.0");

if (!tc.filesystem.exists(prefix)) continue;

 

defer fib.reset();

const lib_dir = std.fs.path.join(fib.allocator(), &.{ prefix, suffix }) catch continue;

if (!tc.filesystem.exists(lib_dir)) continue;

const gcc_cross_dir_exists = tc.filesystem.joinedExists(&.{ lib_dir, "/gcc-cross" });

 

try self.scanLibDirForGCCTriple(tc, target, lib_dir, triple_str, false, gcc_dir_exists, gcc_cross_dir_exists);

try self.scanLibDirForGCCTriple(tc, target, lib_dir, candidate, false, gcc_dir_exists, gcc_cross_dir_exists);

}

}

const lib_dir = std.fs.path.join(fib.allocator(), &.{ prefix, suffix }) catch continue;

if (!tc.filesystem.exists(lib_dir)) continue;

 

const gcc_dir_exists = tc.filesystem.joinedExists(&.{ lib_dir, "/gcc" });

const gcc_cross_dir_exists = tc.filesystem.joinedExists(&.{ lib_dir, "/gcc-cross" });

try self.scanLibDirForGCCTriple(tc, target, lib_dir, candidate, true, gcc_dir_exists, gcc_cross_dir_exists);

}

}

 

}

},

};

try p.errExtra(item.tag, p.tok_i, item.extra);

}

}

char_literal_parser.err(.char_lit_too_wide, .{ .none = {} });

}

 

try p.errExtra(item.tag, p.tok_i, item.extra);

}

}

 

max_codepoint: u21,

/// We only want to issue a max of 1 error per char literal

errored: bool = false,

comp: *const Compilation,

 

pub fn init(literal: []const u8, kind: Kind, max_codepoint: u21, comp: *const Compilation) Parser {

.comp = comp,

.kind = kind,

.max_codepoint = max_codepoint,

};

}

 

};

}

 

pub fn err(self: *Parser, tag: Diagnostics.Tag, extra: Diagnostics.Message.Extra) void {

if (self.errored) return;

self.errored = true;

const diagnostic = .{ .tag = tag, .extra = extra };

}

 

pub fn warn(self: *Parser, tag: Diagnostics.Tag, extra: Diagnostics.Message.Extra) void {

if (self.errored) return;

}

 

pub fn next(self: *Parser) ?Item {

 

return self;

}

 

/// Release all allocated memory.

pub fn deinit(self: *Self, allocator: Allocator) void {

allocator.free(self.allocatedSlice());

 

const mem = std.mem;

const meta = std.meta;

const testing = std.testing;

const assert = std.debug.assert;

const Endian = std.builtin.Endian;

 

 

return struct {

const Self = @This();

const max_limbs_count = math.divCeil(usize, max_bits, t_bits) catch unreachable;

 

/// Number of bytes required to serialize an integer.

pub const encoded_bytes = math.divCeil(usize, max_bits, 8) catch unreachable;

 

}

 

// Removes limbs whose value is zero from the active limbs.

fn normalize(self: Self) Self {

var res = self;

return res;

}

return res;

}

 

/// The zero integer.

};

 

/// Creates a new big integer from a primitive type.

/// This function may not run in constant time.

x = math.shr(T, x, t_bits);

}

if (x != 0) {

/// This function may not run in constant time.

pub fn toPrimitive(self: Self, comptime T: type) OverflowError!T {

var x: T = 0;

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

if (@bitSizeOf(T) >= t_bits and math.shr(T, x, @bitSizeOf(T) - t_bits) != 0) {

return error.Overflow;

}

x = math.shl(T, x, t_bits);

x |= v;

if (i == 0) break;

}

.big => bytes.len - 1,

.little => 0,

};

var remaining_bits = t_bits;

while (remaining_bits >= 8) {

bytes[out_i] |= math.shl(u8, @as(u8, @truncate(limb)), shift);

const consumed = 8 - shift;

switch (endian) {

.big => {

if (out_i == 0) {

return error.Overflow;

}

return;

.little => {

out_i += 1;

if (out_i == bytes.len) {

return error.Overflow;

}

return;

};

while (true) {

const bi = bytes[i];

shift += 8;

if (shift >= t_bits) {

shift -= t_bits;

const overflow = math.shr(Limb, bi, 8 - shift);

out_i += 1;

if (overflow != 0 or i != 0) {

return error.Overflow;

}

break;

}

}

switch (endian) {

.big => {

 

/// Returns `true` if both integers are equal.

pub fn eql(x: Self, y: Self) bool {

}

 

/// Compares two integers.

pub fn compare(x: Self, y: Self) math.Order {

return crypto.utils.timingSafeCompare(

Limb,

.little,

);

}

 

/// Returns `true` if the integer is zero.

pub fn isZero(x: Self) bool {

var t: Limb = 0;

}

return ct.eql(t, 0);

}

 

/// Returns `true` if the integer is odd.

pub fn isOdd(x: Self) bool {

}

 

/// Adds `y` to `x`, and returns `true` if the operation overflowed.

 

// Replaces the limbs of `x` with the limbs of `y` if `on` is `true`.

fn cmov(x: *Self, on: bool, y: Self) void {

}

}

 

fn conditionalAddWithOverflow(x: *Self, on: bool, y: Self) u1 {

var carry: u1 = 0;

}

return carry;

}

 

fn conditionalSubWithOverflow(x: *Self, on: bool, y: Self) u1 {

var borrow: u1 = 0;

}

return borrow;

}

 

// The number of active limbs to represent the field element.

fn limbs_count(self: Self) usize {

}

 

/// Creates a field element from a primitive.

 

// Number of active limbs in the modulus.

fn limbs_count(self: Self) usize {

}

 

/// Actual size of the modulus, in bits.

/// Returns the element `1`.

pub fn one(self: Self) Fe {

var fe = self.zero;

return fe;

}

 

if (!v_.isOdd()) return error.EvenModulus;

 

var v = v_.normalize();

 

return error.ModulusTooSmall;

}

 

const new_len = self.limbs_count();

if (fe.limbs_count() < new_len) return error.Overflow;

var acc: Limb = 0;

acc |= limb;

}

if (acc != 0) return error.Overflow;

}

 

// Computes R^2 for the Montgomery representation.

fn computeRR(self: *Self) void {

self.rr = self.zero;

const n = self.rr.limbs_count();

for ((n - 1)..(2 * n)) |_| {

self.shiftIn(&self.rr, 0);

}

/// Computes x << t_bits + y (mod m)

fn shiftIn(self: Self, x: *Fe, y: Limb) void {

var d = self.zero;

 

var need_sub = false;

var i: usize = t_bits - 1;

/// Reduces an arbitrary `Uint`, converting it to a field element.

pub fn reduce(self: Self, x: anytype) Fe {

var out = self.zero;

if (self.limbs_count() >= 2) {

const start = @min(i, self.limbs_count() - 2);

var j = start;

while (true) : (j -= 1) {

i -= 1;

if (j == 0) break;

}

}

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

if (i == 0) break;

}

return out;

assert(d.limbs_count() == y.limbs_count());

assert(d.limbs_count() == self.limbs_count());

 

 

var overflow: u1 = 0;

for (0..self.limbs_count()) |i| {

const k: u1 = @truncate(b >> j);

if (k != 0) {

const t = self.montgomeryMul(out, x_m);

}

if (j == 0) break;

}

}

const t1 = self.montgomeryMul(out, t0);

if (public) {

} else {

out.v.cmov(!ct.eql(k, 0), t1.v);

}

pub fn powPublic(self: Self, x: Fe, e: Fe) NullExponentError!Fe {

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

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

e_normalized.toBytes(buf, .little) catch unreachable;

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

return self.powWithEncodedPublicExponent(x, buf, .little);

}

 

// Compares two big integers in constant time, returning true if x < y.

fn limbsCmpLt(x: anytype, y: @TypeOf(x)) bool {

var c: u1 = 0;

}

}

 

// Compares two big integers in constant time, returning true if x >= y.

fn limbsCmpGeq(x: anytype, y: @TypeOf(x)) bool {

}

 

// Multiplies two limbs and returns the result as a wide limb.

 

name: []const u8,

parent_dir: Dir,

iter: IterableDir.Iterator,

};

 

 

.name = sub_path,

.parent_dir = self,

.iter = initial_iterable_dir.iterateAssumeFirstIteration(),

});

 

while (try top.iter.next()) |entry| {

var treat_as_dir = entry.kind == .directory;

handle_entry: while (true) {

if (treat_as_dir) {

var iterable_dir = top.iter.dir.openIterableDir(entry.name, .{ .no_follow = true }) catch |err| switch (err) {

error.NotDir => {

treat_as_dir = false;

error.DeviceBusy,

=> |e| return e,

};

.name = entry.name,

.parent_dir = top.iter.dir,

.iter = iterable_dir.iterateAssumeFirstIteration(),

});

continue :process_stack;

try top.iter.dir.deleteTreeMinStackSizeWithKindHint(entry.name, entry.kind);

break :handle_entry;

}

// pop the value from the stack.

const parent_dir = top.parent_dir;

const name = top.name;

 

var need_to_retry: bool = false;

parent_dir.deleteDir(name) catch |err| switch (err) {

};

// We know there is room on the stack since we are just re-adding

// the StackItem that we previously popped.

.name = name,

.parent_dir = parent_dir,

.iter = iterable_dir.iterateAssumeFirstIteration(),

 

self.nextToken(.normal) catch unreachable;

switch (statement_type) {

.file_version, .product_version => {

 

const value = try self.parseExpression(.{ .allowed_types = .{ .number = true } });

parts.addOneAssumeCapacity().* = value;

 

break;

}

}

const node = try self.state.arena.create(Node.VersionStatement);

node.* = .{

.type = type_token,

};

return &node.base;

},

 

const operand = operands[field_index];

 

// Should be enough for all names - adjust as needed.

 

derive_from_kind: {

// Operand names are often in the json encoded as "'Name'" (with two sets of quotes).

// Use the same loop to transform to snake-case.

for (name) |c| {

switch (c) {

else => break :derive_from_kind,

}

}

 

// Assume there are no duplicate 'name' fields.

return;

}

 

// Translate to snake case.

for (operand.kind, 0..) |c, i| {

switch (c) {

'A'...'Z' => if (i > 0 and std.ascii.isLower(operand.kind[i - 1])) {

} else {

},

else => unreachable, // Assume that the name is valid C-syntax (and contains no underscores).

}

}

 

 

// For fields derived from type name, there could be any amount.

// Simply check against all other fields, and if another similar one exists, add a number.