mirror of
https://github.com/ziglang/zig.git
synced 2026-02-13 04:48:20 +00:00
Merge pull request #14745 from jacobly0/bigint
CBE: add support for integers larger than 128 bits (and apparently vectors too)
This commit is contained in:
Andrew Kelley
GitHub
commit
7b01af2bfd
@ -1674,6 +1674,7 @@ pub const Mutable = struct {
|
||||
|
||||
/// If a is positive, this passes through to truncate.
|
||||
/// If a is negative, then r is set to positive with the bit pattern ~(a - 1).
|
||||
/// r may alias a.
|
||||
///
|
||||
/// Asserts `r` has enough storage to store the result.
|
||||
/// The upper bound is `calcTwosCompLimbCount(a.len)`.
|
||||
|
||||
40
src/Sema.zig
40
src/Sema.zig
@ -574,11 +574,13 @@ pub const Block = struct {
|
||||
});
|
||||
}
|
||||
|
||||
fn addCmpVector(block: *Block, lhs: Air.Inst.Ref, rhs: Air.Inst.Ref, cmp_op: std.math.CompareOperator, vector_ty: Air.Inst.Ref) !Air.Inst.Ref {
|
||||
fn addCmpVector(block: *Block, lhs: Air.Inst.Ref, rhs: Air.Inst.Ref, cmp_op: std.math.CompareOperator) !Air.Inst.Ref {
|
||||
return block.addInst(.{
|
||||
.tag = if (block.float_mode == .Optimized) .cmp_vector_optimized else .cmp_vector,
|
||||
.data = .{ .ty_pl = .{
|
||||
.ty = vector_ty,
|
||||
.ty = try block.sema.addType(
|
||||
try Type.vector(block.sema.arena, block.sema.typeOf(lhs).vectorLen(), Type.bool),
|
||||
),
|
||||
.payload = try block.sema.addExtra(Air.VectorCmp{
|
||||
.lhs = lhs,
|
||||
.rhs = rhs,
|
||||
@ -9412,7 +9414,7 @@ fn intCast(
|
||||
const ok = if (is_vector) ok: {
|
||||
const zeros = try Value.Tag.repeated.create(sema.arena, Value.zero);
|
||||
const zero_inst = try sema.addConstant(sema.typeOf(operand), zeros);
|
||||
const is_in_range = try block.addCmpVector(operand, zero_inst, .eq, try sema.addType(operand_ty));
|
||||
const is_in_range = try block.addCmpVector(operand, zero_inst, .eq);
|
||||
const all_in_range = try block.addInst(.{
|
||||
.tag = .reduce,
|
||||
.data = .{ .reduce = .{ .operand = is_in_range, .operation = .And } },
|
||||
@ -9466,7 +9468,7 @@ fn intCast(
|
||||
const dest_range = try sema.addConstant(unsigned_operand_ty, dest_range_val);
|
||||
|
||||
const ok = if (is_vector) ok: {
|
||||
const is_in_range = try block.addCmpVector(diff_unsigned, dest_range, .lte, try sema.addType(operand_ty));
|
||||
const is_in_range = try block.addCmpVector(diff_unsigned, dest_range, .lte);
|
||||
const all_in_range = try block.addInst(.{
|
||||
.tag = if (block.float_mode == .Optimized) .reduce_optimized else .reduce,
|
||||
.data = .{ .reduce = .{
|
||||
@ -9483,7 +9485,7 @@ fn intCast(
|
||||
try sema.addSafetyCheck(block, ok, .cast_truncated_data);
|
||||
} else {
|
||||
const ok = if (is_vector) ok: {
|
||||
const is_in_range = try block.addCmpVector(diff, dest_max, .lte, try sema.addType(operand_ty));
|
||||
const is_in_range = try block.addCmpVector(diff, dest_max, .lte);
|
||||
const all_in_range = try block.addInst(.{
|
||||
.tag = if (block.float_mode == .Optimized) .reduce_optimized else .reduce,
|
||||
.data = .{ .reduce = .{
|
||||
@ -9504,7 +9506,7 @@ fn intCast(
|
||||
const ok = if (is_vector) ok: {
|
||||
const zero_val = try Value.Tag.repeated.create(sema.arena, Value.zero);
|
||||
const zero_inst = try sema.addConstant(operand_ty, zero_val);
|
||||
const is_in_range = try block.addCmpVector(operand, zero_inst, .gte, try sema.addType(operand_ty));
|
||||
const is_in_range = try block.addCmpVector(operand, zero_inst, .gte);
|
||||
const all_in_range = try block.addInst(.{
|
||||
.tag = if (block.float_mode == .Optimized) .reduce_optimized else .reduce,
|
||||
.data = .{ .reduce = .{
|
||||
@ -12016,7 +12018,7 @@ fn zirShl(
|
||||
|
||||
const ok = if (rhs_ty.zigTypeTag() == .Vector) ok: {
|
||||
const bit_count_inst = try sema.addConstant(rhs_ty, try Value.Tag.repeated.create(sema.arena, bit_count_val));
|
||||
const lt = try block.addCmpVector(rhs, bit_count_inst, .lt, try sema.addType(rhs_ty));
|
||||
const lt = try block.addCmpVector(rhs, bit_count_inst, .lt);
|
||||
break :ok try block.addInst(.{
|
||||
.tag = .reduce,
|
||||
.data = .{ .reduce = .{
|
||||
@ -12172,7 +12174,7 @@ fn zirShr(
|
||||
|
||||
const ok = if (rhs_ty.zigTypeTag() == .Vector) ok: {
|
||||
const bit_count_inst = try sema.addConstant(rhs_ty, try Value.Tag.repeated.create(sema.arena, bit_count_val));
|
||||
const lt = try block.addCmpVector(rhs, bit_count_inst, .lt, try sema.addType(rhs_ty));
|
||||
const lt = try block.addCmpVector(rhs, bit_count_inst, .lt);
|
||||
break :ok try block.addInst(.{
|
||||
.tag = .reduce,
|
||||
.data = .{ .reduce = .{
|
||||
@ -12191,7 +12193,7 @@ fn zirShr(
|
||||
const back = try block.addBinOp(.shl, result, rhs);
|
||||
|
||||
const ok = if (rhs_ty.zigTypeTag() == .Vector) ok: {
|
||||
const eql = try block.addCmpVector(lhs, back, .eq, try sema.addType(rhs_ty));
|
||||
const eql = try block.addCmpVector(lhs, back, .eq);
|
||||
break :ok try block.addInst(.{
|
||||
.tag = if (block.float_mode == .Optimized) .reduce_optimized else .reduce,
|
||||
.data = .{ .reduce = .{
|
||||
@ -13192,7 +13194,7 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
|
||||
const floored = try block.addUnOp(.floor, result);
|
||||
|
||||
if (resolved_type.zigTypeTag() == .Vector) {
|
||||
const eql = try block.addCmpVector(result, floored, .eq, try sema.addType(resolved_type));
|
||||
const eql = try block.addCmpVector(result, floored, .eq);
|
||||
break :ok try block.addInst(.{
|
||||
.tag = switch (block.float_mode) {
|
||||
.Strict => .reduce,
|
||||
@ -13216,7 +13218,7 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
|
||||
if (resolved_type.zigTypeTag() == .Vector) {
|
||||
const zero_val = try Value.Tag.repeated.create(sema.arena, Value.zero);
|
||||
const zero = try sema.addConstant(resolved_type, zero_val);
|
||||
const eql = try block.addCmpVector(remainder, zero, .eq, try sema.addType(resolved_type));
|
||||
const eql = try block.addCmpVector(remainder, zero, .eq);
|
||||
break :ok try block.addInst(.{
|
||||
.tag = .reduce,
|
||||
.data = .{ .reduce = .{
|
||||
@ -13514,14 +13516,13 @@ fn addDivIntOverflowSafety(
|
||||
|
||||
var ok: Air.Inst.Ref = .none;
|
||||
if (resolved_type.zigTypeTag() == .Vector) {
|
||||
const vector_ty_ref = try sema.addType(resolved_type);
|
||||
if (maybe_lhs_val == null) {
|
||||
const min_int_ref = try sema.addConstant(resolved_type, min_int);
|
||||
ok = try block.addCmpVector(casted_lhs, min_int_ref, .neq, vector_ty_ref);
|
||||
ok = try block.addCmpVector(casted_lhs, min_int_ref, .neq);
|
||||
}
|
||||
if (maybe_rhs_val == null) {
|
||||
const neg_one_ref = try sema.addConstant(resolved_type, neg_one);
|
||||
const rhs_ok = try block.addCmpVector(casted_rhs, neg_one_ref, .neq, vector_ty_ref);
|
||||
const rhs_ok = try block.addCmpVector(casted_rhs, neg_one_ref, .neq);
|
||||
if (ok == .none) {
|
||||
ok = rhs_ok;
|
||||
} else {
|
||||
@ -13573,7 +13574,7 @@ fn addDivByZeroSafety(
|
||||
const ok = if (resolved_type.zigTypeTag() == .Vector) ok: {
|
||||
const zero_val = try Value.Tag.repeated.create(sema.arena, Value.zero);
|
||||
const zero = try sema.addConstant(resolved_type, zero_val);
|
||||
const ok = try block.addCmpVector(casted_rhs, zero, .neq, try sema.addType(resolved_type));
|
||||
const ok = try block.addCmpVector(casted_rhs, zero, .neq);
|
||||
break :ok try block.addInst(.{
|
||||
.tag = if (is_int) .reduce else .reduce_optimized,
|
||||
.data = .{ .reduce = .{
|
||||
@ -15202,9 +15203,7 @@ fn cmpSelf(
|
||||
};
|
||||
try sema.requireRuntimeBlock(block, src, runtime_src);
|
||||
if (resolved_type.zigTypeTag() == .Vector) {
|
||||
const result_ty = try Type.vector(sema.arena, resolved_type.vectorLen(), Type.bool);
|
||||
const result_ty_ref = try sema.addType(result_ty);
|
||||
return block.addCmpVector(casted_lhs, casted_rhs, op, result_ty_ref);
|
||||
return block.addCmpVector(casted_lhs, casted_rhs, op);
|
||||
}
|
||||
const tag = Air.Inst.Tag.fromCmpOp(op, block.float_mode == .Optimized);
|
||||
return block.addBinOp(tag, casted_lhs, casted_rhs);
|
||||
@ -23035,7 +23034,7 @@ fn panicSentinelMismatch(
|
||||
|
||||
const ok = if (sentinel_ty.zigTypeTag() == .Vector) ok: {
|
||||
const eql =
|
||||
try parent_block.addCmpVector(expected_sentinel, actual_sentinel, .eq, try sema.addType(sentinel_ty));
|
||||
try parent_block.addCmpVector(expected_sentinel, actual_sentinel, .eq);
|
||||
break :ok try parent_block.addInst(.{
|
||||
.tag = .reduce,
|
||||
.data = .{ .reduce = .{
|
||||
@ -29368,8 +29367,7 @@ fn cmpVector(
|
||||
};
|
||||
|
||||
try sema.requireRuntimeBlock(block, src, runtime_src);
|
||||
const result_ty_inst = try sema.addType(result_ty);
|
||||
return block.addCmpVector(lhs, rhs, op, result_ty_inst);
|
||||
return block.addCmpVector(lhs, rhs, op);
|
||||
}
|
||||
|
||||
fn wrapOptional(
|
||||
|
||||
1452
src/codegen/c.zig
1452
src/codegen/c.zig
File diff suppressed because it is too large
Load Diff
@ -496,6 +496,427 @@ pub const CType = extern union {
|
||||
}
|
||||
};
|
||||
|
||||
pub fn isBool(self: CType) bool {
|
||||
return switch (self.tag()) {
|
||||
._Bool,
|
||||
.bool,
|
||||
=> true,
|
||||
else => false,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn isInteger(self: CType) bool {
|
||||
return switch (self.tag()) {
|
||||
.char,
|
||||
.@"signed char",
|
||||
.short,
|
||||
.int,
|
||||
.long,
|
||||
.@"long long",
|
||||
.@"unsigned char",
|
||||
.@"unsigned short",
|
||||
.@"unsigned int",
|
||||
.@"unsigned long",
|
||||
.@"unsigned long long",
|
||||
.size_t,
|
||||
.ptrdiff_t,
|
||||
.uint8_t,
|
||||
.int8_t,
|
||||
.uint16_t,
|
||||
.int16_t,
|
||||
.uint32_t,
|
||||
.int32_t,
|
||||
.uint64_t,
|
||||
.int64_t,
|
||||
.uintptr_t,
|
||||
.intptr_t,
|
||||
.zig_u128,
|
||||
.zig_i128,
|
||||
=> true,
|
||||
else => false,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn signedness(self: CType) ?std.builtin.Signedness {
|
||||
return switch (self.tag()) {
|
||||
.char => null, // unknown signedness
|
||||
.@"signed char",
|
||||
.short,
|
||||
.int,
|
||||
.long,
|
||||
.@"long long",
|
||||
.ptrdiff_t,
|
||||
.int8_t,
|
||||
.int16_t,
|
||||
.int32_t,
|
||||
.int64_t,
|
||||
.intptr_t,
|
||||
.zig_i128,
|
||||
=> .signed,
|
||||
.@"unsigned char",
|
||||
.@"unsigned short",
|
||||
.@"unsigned int",
|
||||
.@"unsigned long",
|
||||
.@"unsigned long long",
|
||||
.size_t,
|
||||
.uint8_t,
|
||||
.uint16_t,
|
||||
.uint32_t,
|
||||
.uint64_t,
|
||||
.uintptr_t,
|
||||
.zig_u128,
|
||||
=> .unsigned,
|
||||
else => unreachable,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn isFloat(self: CType) bool {
|
||||
return switch (self.tag()) {
|
||||
.float,
|
||||
.double,
|
||||
.@"long double",
|
||||
.zig_f16,
|
||||
.zig_f32,
|
||||
.zig_f64,
|
||||
.zig_f80,
|
||||
.zig_f128,
|
||||
.zig_c_longdouble,
|
||||
=> true,
|
||||
else => false,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn isPointer(self: CType) bool {
|
||||
return switch (self.tag()) {
|
||||
.pointer,
|
||||
.pointer_const,
|
||||
.pointer_volatile,
|
||||
.pointer_const_volatile,
|
||||
=> true,
|
||||
else => false,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn isFunction(self: CType) bool {
|
||||
return switch (self.tag()) {
|
||||
.function,
|
||||
.varargs_function,
|
||||
=> true,
|
||||
else => false,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn toSigned(self: CType) CType {
|
||||
return CType.initTag(switch (self.tag()) {
|
||||
.char, .@"signed char", .@"unsigned char" => .@"signed char",
|
||||
.short, .@"unsigned short" => .short,
|
||||
.int, .@"unsigned int" => .int,
|
||||
.long, .@"unsigned long" => .long,
|
||||
.@"long long", .@"unsigned long long" => .@"long long",
|
||||
.size_t, .ptrdiff_t => .ptrdiff_t,
|
||||
.uint8_t, .int8_t => .int8_t,
|
||||
.uint16_t, .int16_t => .int16_t,
|
||||
.uint32_t, .int32_t => .int32_t,
|
||||
.uint64_t, .int64_t => .int64_t,
|
||||
.uintptr_t, .intptr_t => .intptr_t,
|
||||
.zig_u128, .zig_i128 => .zig_i128,
|
||||
.float,
|
||||
.double,
|
||||
.@"long double",
|
||||
.zig_f16,
|
||||
.zig_f32,
|
||||
.zig_f80,
|
||||
.zig_f128,
|
||||
.zig_c_longdouble,
|
||||
=> |t| t,
|
||||
else => unreachable,
|
||||
});
|
||||
}
|
||||
|
||||
pub fn toUnsigned(self: CType) CType {
|
||||
return CType.initTag(switch (self.tag()) {
|
||||
.char, .@"signed char", .@"unsigned char" => .@"unsigned char",
|
||||
.short, .@"unsigned short" => .@"unsigned short",
|
||||
.int, .@"unsigned int" => .@"unsigned int",
|
||||
.long, .@"unsigned long" => .@"unsigned long",
|
||||
.@"long long", .@"unsigned long long" => .@"unsigned long long",
|
||||
.size_t, .ptrdiff_t => .size_t,
|
||||
.uint8_t, .int8_t => .uint8_t,
|
||||
.uint16_t, .int16_t => .uint16_t,
|
||||
.uint32_t, .int32_t => .uint32_t,
|
||||
.uint64_t, .int64_t => .uint64_t,
|
||||
.uintptr_t, .intptr_t => .uintptr_t,
|
||||
.zig_u128, .zig_i128 => .zig_u128,
|
||||
else => unreachable,
|
||||
});
|
||||
}
|
||||
|
||||
pub fn toSignedness(self: CType, s: std.builtin.Signedness) CType {
|
||||
return switch (s) {
|
||||
.unsigned => self.toUnsigned(),
|
||||
.signed => self.toSigned(),
|
||||
};
|
||||
}
|
||||
|
||||
pub fn getStandardDefineAbbrev(self: CType) ?[]const u8 {
|
||||
return switch (self.tag()) {
|
||||
.char => "CHAR",
|
||||
.@"signed char" => "SCHAR",
|
||||
.short => "SHRT",
|
||||
.int => "INT",
|
||||
.long => "LONG",
|
||||
.@"long long" => "LLONG",
|
||||
.@"unsigned char" => "UCHAR",
|
||||
.@"unsigned short" => "USHRT",
|
||||
.@"unsigned int" => "UINT",
|
||||
.@"unsigned long" => "ULONG",
|
||||
.@"unsigned long long" => "ULLONG",
|
||||
.float => "FLT",
|
||||
.double => "DBL",
|
||||
.@"long double" => "LDBL",
|
||||
.size_t => "SIZE",
|
||||
.ptrdiff_t => "PTRDIFF",
|
||||
.uint8_t => "UINT8",
|
||||
.int8_t => "INT8",
|
||||
.uint16_t => "UINT16",
|
||||
.int16_t => "INT16",
|
||||
.uint32_t => "UINT32",
|
||||
.int32_t => "INT32",
|
||||
.uint64_t => "UINT64",
|
||||
.int64_t => "INT64",
|
||||
.uintptr_t => "UINTPTR",
|
||||
.intptr_t => "INTPTR",
|
||||
else => null,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn renderLiteralPrefix(self: CType, writer: anytype, kind: Kind) @TypeOf(writer).Error!void {
|
||||
switch (self.tag()) {
|
||||
.void => unreachable,
|
||||
._Bool,
|
||||
.char,
|
||||
.@"signed char",
|
||||
.short,
|
||||
.@"unsigned short",
|
||||
.bool,
|
||||
.size_t,
|
||||
.ptrdiff_t,
|
||||
.uintptr_t,
|
||||
.intptr_t,
|
||||
=> |t| switch (kind) {
|
||||
else => try writer.print("({s})", .{@tagName(t)}),
|
||||
.global => {},
|
||||
},
|
||||
.int,
|
||||
.long,
|
||||
.@"long long",
|
||||
.@"unsigned char",
|
||||
.@"unsigned int",
|
||||
.@"unsigned long",
|
||||
.@"unsigned long long",
|
||||
.float,
|
||||
.double,
|
||||
.@"long double",
|
||||
=> {},
|
||||
.uint8_t,
|
||||
.int8_t,
|
||||
.uint16_t,
|
||||
.int16_t,
|
||||
.uint32_t,
|
||||
.int32_t,
|
||||
.uint64_t,
|
||||
.int64_t,
|
||||
=> try writer.print("{s}_C(", .{self.getStandardDefineAbbrev().?}),
|
||||
.zig_u128,
|
||||
.zig_i128,
|
||||
.zig_f16,
|
||||
.zig_f32,
|
||||
.zig_f64,
|
||||
.zig_f80,
|
||||
.zig_f128,
|
||||
.zig_c_longdouble,
|
||||
=> |t| try writer.print("zig_{s}_{s}(", .{
|
||||
switch (kind) {
|
||||
else => "make",
|
||||
.global => "init",
|
||||
},
|
||||
@tagName(t)["zig_".len..],
|
||||
}),
|
||||
.pointer,
|
||||
.pointer_const,
|
||||
.pointer_volatile,
|
||||
.pointer_const_volatile,
|
||||
=> unreachable,
|
||||
.array,
|
||||
.vector,
|
||||
=> try writer.writeByte('{'),
|
||||
.fwd_anon_struct,
|
||||
.fwd_anon_union,
|
||||
.fwd_struct,
|
||||
.fwd_union,
|
||||
.unnamed_struct,
|
||||
.unnamed_union,
|
||||
.packed_unnamed_struct,
|
||||
.packed_unnamed_union,
|
||||
.anon_struct,
|
||||
.anon_union,
|
||||
.@"struct",
|
||||
.@"union",
|
||||
.packed_struct,
|
||||
.packed_union,
|
||||
.function,
|
||||
.varargs_function,
|
||||
=> unreachable,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn renderLiteralSuffix(self: CType, writer: anytype) @TypeOf(writer).Error!void {
|
||||
switch (self.tag()) {
|
||||
.void => unreachable,
|
||||
._Bool => {},
|
||||
.char,
|
||||
.@"signed char",
|
||||
.short,
|
||||
.int,
|
||||
=> {},
|
||||
.long => try writer.writeByte('l'),
|
||||
.@"long long" => try writer.writeAll("ll"),
|
||||
.@"unsigned char",
|
||||
.@"unsigned short",
|
||||
.@"unsigned int",
|
||||
=> try writer.writeByte('u'),
|
||||
.@"unsigned long",
|
||||
.size_t,
|
||||
.uintptr_t,
|
||||
=> try writer.writeAll("ul"),
|
||||
.@"unsigned long long" => try writer.writeAll("ull"),
|
||||
.float => try writer.writeByte('f'),
|
||||
.double => {},
|
||||
.@"long double" => try writer.writeByte('l'),
|
||||
.bool,
|
||||
.ptrdiff_t,
|
||||
.intptr_t,
|
||||
=> {},
|
||||
.uint8_t,
|
||||
.int8_t,
|
||||
.uint16_t,
|
||||
.int16_t,
|
||||
.uint32_t,
|
||||
.int32_t,
|
||||
.uint64_t,
|
||||
.int64_t,
|
||||
.zig_u128,
|
||||
.zig_i128,
|
||||
.zig_f16,
|
||||
.zig_f32,
|
||||
.zig_f64,
|
||||
.zig_f80,
|
||||
.zig_f128,
|
||||
.zig_c_longdouble,
|
||||
=> try writer.writeByte(')'),
|
||||
.pointer,
|
||||
.pointer_const,
|
||||
.pointer_volatile,
|
||||
.pointer_const_volatile,
|
||||
=> unreachable,
|
||||
.array,
|
||||
.vector,
|
||||
=> try writer.writeByte('}'),
|
||||
.fwd_anon_struct,
|
||||
.fwd_anon_union,
|
||||
.fwd_struct,
|
||||
.fwd_union,
|
||||
.unnamed_struct,
|
||||
.unnamed_union,
|
||||
.packed_unnamed_struct,
|
||||
.packed_unnamed_union,
|
||||
.anon_struct,
|
||||
.anon_union,
|
||||
.@"struct",
|
||||
.@"union",
|
||||
.packed_struct,
|
||||
.packed_union,
|
||||
.function,
|
||||
.varargs_function,
|
||||
=> unreachable,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn floatActiveBits(self: CType, target: Target) u16 {
|
||||
return switch (self.tag()) {
|
||||
.float => target.c_type_bit_size(.float),
|
||||
.double => target.c_type_bit_size(.double),
|
||||
.@"long double", .zig_c_longdouble => target.c_type_bit_size(.longdouble),
|
||||
.zig_f16 => 16,
|
||||
.zig_f32 => 32,
|
||||
.zig_f64 => 64,
|
||||
.zig_f80 => 80,
|
||||
.zig_f128 => 128,
|
||||
else => unreachable,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn byteSize(self: CType, store: Store.Set, target: Target) u64 {
|
||||
return switch (self.tag()) {
|
||||
.void => 0,
|
||||
.char, .@"signed char", ._Bool, .@"unsigned char", .bool, .uint8_t, .int8_t => 1,
|
||||
.short => target.c_type_byte_size(.short),
|
||||
.int => target.c_type_byte_size(.int),
|
||||
.long => target.c_type_byte_size(.long),
|
||||
.@"long long" => target.c_type_byte_size(.longlong),
|
||||
.@"unsigned short" => target.c_type_byte_size(.ushort),
|
||||
.@"unsigned int" => target.c_type_byte_size(.uint),
|
||||
.@"unsigned long" => target.c_type_byte_size(.ulong),
|
||||
.@"unsigned long long" => target.c_type_byte_size(.ulonglong),
|
||||
.float => target.c_type_byte_size(.float),
|
||||
.double => target.c_type_byte_size(.double),
|
||||
.@"long double" => target.c_type_byte_size(.longdouble),
|
||||
.size_t,
|
||||
.ptrdiff_t,
|
||||
.uintptr_t,
|
||||
.intptr_t,
|
||||
.pointer,
|
||||
.pointer_const,
|
||||
.pointer_volatile,
|
||||
.pointer_const_volatile,
|
||||
=> @divExact(target.cpu.arch.ptrBitWidth(), 8),
|
||||
.uint16_t, .int16_t, .zig_f16 => 2,
|
||||
.uint32_t, .int32_t, .zig_f32 => 4,
|
||||
.uint64_t, .int64_t, .zig_f64 => 8,
|
||||
.zig_u128, .zig_i128, .zig_f128 => 16,
|
||||
.zig_f80 => if (target.c_type_bit_size(.longdouble) == 80)
|
||||
target.c_type_byte_size(.longdouble)
|
||||
else
|
||||
16,
|
||||
.zig_c_longdouble => target.c_type_byte_size(.longdouble),
|
||||
|
||||
.array,
|
||||
.vector,
|
||||
=> {
|
||||
const data = self.cast(Payload.Sequence).?.data;
|
||||
return data.len * store.indexToCType(data.elem_type).byteSize(store, target);
|
||||
},
|
||||
|
||||
.fwd_anon_struct,
|
||||
.fwd_anon_union,
|
||||
.fwd_struct,
|
||||
.fwd_union,
|
||||
.unnamed_struct,
|
||||
.unnamed_union,
|
||||
.packed_unnamed_struct,
|
||||
.packed_unnamed_union,
|
||||
.anon_struct,
|
||||
.anon_union,
|
||||
.@"struct",
|
||||
.@"union",
|
||||
.packed_struct,
|
||||
.packed_union,
|
||||
.function,
|
||||
.varargs_function,
|
||||
=> unreachable,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn isPacked(self: CType) bool {
|
||||
return switch (self.tag()) {
|
||||
else => false,
|
||||
@ -787,26 +1208,26 @@ pub const CType = extern union {
|
||||
};
|
||||
}
|
||||
|
||||
fn tagFromIntInfo(signedness: std.builtin.Signedness, bits: u16) Tag {
|
||||
return switch (bits) {
|
||||
fn tagFromIntInfo(int_info: std.builtin.Type.Int) Tag {
|
||||
return switch (int_info.bits) {
|
||||
0 => .void,
|
||||
1...8 => switch (signedness) {
|
||||
1...8 => switch (int_info.signedness) {
|
||||
.unsigned => .uint8_t,
|
||||
.signed => .int8_t,
|
||||
},
|
||||
9...16 => switch (signedness) {
|
||||
9...16 => switch (int_info.signedness) {
|
||||
.unsigned => .uint16_t,
|
||||
.signed => .int16_t,
|
||||
},
|
||||
17...32 => switch (signedness) {
|
||||
17...32 => switch (int_info.signedness) {
|
||||
.unsigned => .uint32_t,
|
||||
.signed => .int32_t,
|
||||
},
|
||||
33...64 => switch (signedness) {
|
||||
33...64 => switch (int_info.signedness) {
|
||||
.unsigned => .uint64_t,
|
||||
.signed => .int64_t,
|
||||
},
|
||||
65...128 => switch (signedness) {
|
||||
65...128 => switch (int_info.signedness) {
|
||||
.unsigned => .zig_u128,
|
||||
.signed => .zig_i128,
|
||||
},
|
||||
@ -945,31 +1366,27 @@ pub const CType = extern union {
|
||||
.c_ulong => self.init(.@"unsigned long"),
|
||||
.c_longlong => self.init(.@"long long"),
|
||||
.c_ulonglong => self.init(.@"unsigned long long"),
|
||||
else => {
|
||||
const info = ty.intInfo(target);
|
||||
const t = tagFromIntInfo(info.signedness, info.bits);
|
||||
switch (t) {
|
||||
.void => unreachable,
|
||||
else => self.init(t),
|
||||
.array => switch (kind) {
|
||||
.forward, .complete, .global => {
|
||||
const abi_size = ty.abiSize(target);
|
||||
const abi_align = ty.abiAlignment(target);
|
||||
self.storage = .{ .seq = .{ .base = .{ .tag = .array }, .data = .{
|
||||
.len = @divExact(abi_size, abi_align),
|
||||
.elem_type = tagFromIntInfo(
|
||||
.unsigned,
|
||||
@intCast(u16, abi_align * 8),
|
||||
).toIndex(),
|
||||
} } };
|
||||
self.value = .{ .cty = initPayload(&self.storage.seq) };
|
||||
},
|
||||
.forward_parameter,
|
||||
.parameter,
|
||||
=> try self.initArrayParameter(ty, kind, lookup),
|
||||
.payload => unreachable,
|
||||
else => switch (tagFromIntInfo(ty.intInfo(target))) {
|
||||
.void => unreachable,
|
||||
else => |t| self.init(t),
|
||||
.array => switch (kind) {
|
||||
.forward, .complete, .global => {
|
||||
const abi_size = ty.abiSize(target);
|
||||
const abi_align = ty.abiAlignment(target);
|
||||
self.storage = .{ .seq = .{ .base = .{ .tag = .array }, .data = .{
|
||||
.len = @divExact(abi_size, abi_align),
|
||||
.elem_type = tagFromIntInfo(.{
|
||||
.signedness = .unsigned,
|
||||
.bits = @intCast(u16, abi_align * 8),
|
||||
}).toIndex(),
|
||||
} } };
|
||||
self.value = .{ .cty = initPayload(&self.storage.seq) };
|
||||
},
|
||||
}
|
||||
.forward_parameter,
|
||||
.parameter,
|
||||
=> try self.initArrayParameter(ty, kind, lookup),
|
||||
.payload => unreachable,
|
||||
},
|
||||
},
|
||||
} else switch (ty.zigTypeTag()) {
|
||||
.Frame => unreachable,
|
||||
@ -1048,7 +1465,7 @@ pub const CType = extern union {
|
||||
.base = .{ .tag = .int_unsigned },
|
||||
.data = info.host_size * 8,
|
||||
};
|
||||
const pointee_ty = if (info.host_size > 0)
|
||||
const pointee_ty = if (info.host_size > 0 and info.vector_index == .none)
|
||||
Type.initPayload(&host_int_pl.base)
|
||||
else
|
||||
info.pointee_type;
|
||||
|
||||
@ -221,14 +221,19 @@ pub fn flush(self: *C, comp: *Compilation, prog_node: *std.Progress.Node) !void
|
||||
return self.flushModule(comp, prog_node);
|
||||
}
|
||||
|
||||
fn abiDefine(comp: *Compilation) ?[]const u8 {
|
||||
return switch (comp.getTarget().abi) {
|
||||
.msvc => "#define ZIG_TARGET_ABI_MSVC\n",
|
||||
else => null,
|
||||
};
|
||||
fn abiDefines(self: *C, target: std.Target) !std.ArrayList(u8) {
|
||||
var defines = std.ArrayList(u8).init(self.base.allocator);
|
||||
errdefer defines.deinit();
|
||||
const writer = defines.writer();
|
||||
switch (target.abi) {
|
||||
.msvc => try writer.writeAll("#define ZIG_TARGET_ABI_MSVC\n"),
|
||||
else => {},
|
||||
}
|
||||
try writer.print("#define ZIG_TARGET_MAX_INT_ALIGNMENT {d}\n", .{target.maxIntAlignment()});
|
||||
return defines;
|
||||
}
|
||||
|
||||
pub fn flushModule(self: *C, comp: *Compilation, prog_node: *std.Progress.Node) !void {
|
||||
pub fn flushModule(self: *C, _: *Compilation, prog_node: *std.Progress.Node) !void {
|
||||
const tracy = trace(@src());
|
||||
defer tracy.end();
|
||||
|
||||
@ -245,12 +250,13 @@ pub fn flushModule(self: *C, comp: *Compilation, prog_node: *std.Progress.Node)
|
||||
var f: Flush = .{};
|
||||
defer f.deinit(gpa);
|
||||
|
||||
const abi_define = abiDefine(comp);
|
||||
const abi_defines = try self.abiDefines(module.getTarget());
|
||||
defer abi_defines.deinit();
|
||||
|
||||
// Covers defines, zig.h, ctypes, asm, lazy fwd.
|
||||
try f.all_buffers.ensureUnusedCapacity(gpa, 5);
|
||||
|
||||
if (abi_define) |buf| f.appendBufAssumeCapacity(buf);
|
||||
f.appendBufAssumeCapacity(abi_defines.items);
|
||||
f.appendBufAssumeCapacity(zig_h);
|
||||
|
||||
const ctypes_index = f.all_buffers.items.len;
|
||||
|
||||
@ -3319,7 +3319,7 @@ pub const Value = extern union {
|
||||
}
|
||||
}
|
||||
|
||||
fn floatToValue(float: f128, arena: Allocator, dest_ty: Type, target: Target) !Value {
|
||||
pub fn floatToValue(float: f128, arena: Allocator, dest_ty: Type, target: Target) !Value {
|
||||
switch (dest_ty.floatBits(target)) {
|
||||
16 => return Value.Tag.float_16.create(arena, @floatCast(f16, float)),
|
||||
32 => return Value.Tag.float_32.create(arena, @floatCast(f32, float)),
|
||||
|
||||
@ -34,7 +34,6 @@ test "@bitCast iX -> uX (8, 16, 128)" {
|
||||
|
||||
test "@bitCast iX -> uX exotic integers" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
|
||||
@ -81,7 +80,6 @@ fn conv_uN(comptime N: usize, x: std.meta.Int(.unsigned, N)) std.meta.Int(.signe
|
||||
|
||||
test "bitcast uX to bytes" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
|
||||
@ -368,7 +366,6 @@ test "comptime @bitCast packed struct to int and back" {
|
||||
}
|
||||
|
||||
test "comptime bitcast with fields following f80" {
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
|
||||
|
||||
@ -96,7 +96,6 @@ fn vector8() !void {
|
||||
|
||||
test "bitReverse vectors u8" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
|
||||
@ -115,7 +114,6 @@ fn vector16() !void {
|
||||
|
||||
test "bitReverse vectors u16" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
|
||||
@ -134,7 +132,6 @@ fn vector24() !void {
|
||||
|
||||
test "bitReverse vectors u24" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
|
||||
|
||||
@ -6,7 +6,6 @@ test "test calling @clz on both vector and scalar inputs" {
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
||||
|
||||
var x: u32 = 0x1;
|
||||
|
||||
@ -62,7 +62,6 @@ fn vector8() !void {
|
||||
|
||||
test "@byteSwap vectors u8" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
|
||||
@ -81,7 +80,6 @@ fn vector16() !void {
|
||||
|
||||
test "@byteSwap vectors u16" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
|
||||
@ -100,7 +98,6 @@ fn vector24() !void {
|
||||
|
||||
test "@byteSwap vectors u24" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
|
||||
|
||||
@ -598,7 +598,6 @@ test "cast *[1][*]const u8 to [*]const ?[*]const u8" {
|
||||
|
||||
test "vector casts" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
|
||||
@ -141,7 +141,6 @@ fn testSqrt() !void {
|
||||
|
||||
test "@sqrt with vectors" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
@ -234,7 +233,6 @@ fn testSin() !void {
|
||||
|
||||
test "@sin with vectors" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
@ -275,7 +273,6 @@ fn testCos() !void {
|
||||
|
||||
test "@cos with vectors" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
@ -315,7 +312,6 @@ fn testExp() !void {
|
||||
|
||||
test "@exp with vectors" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
@ -355,7 +351,6 @@ fn testExp2() !void {
|
||||
|
||||
test "@exp2" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
@ -409,7 +404,6 @@ test "@log with @vectors" {
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
||||
|
||||
{
|
||||
@ -447,7 +441,6 @@ test "@log2 with vectors" {
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
// https://github.com/ziglang/zig/issues/13681
|
||||
if (builtin.zig_backend == .stage2_llvm and
|
||||
builtin.cpu.arch == .aarch64 and
|
||||
@ -491,7 +484,6 @@ test "@log10 with vectors" {
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
|
||||
comptime try testLog10WithVectors();
|
||||
try testLog10WithVectors();
|
||||
@ -537,7 +529,6 @@ fn testFabs() !void {
|
||||
|
||||
test "@fabs with vectors" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
@ -660,7 +651,6 @@ fn testFloor() !void {
|
||||
|
||||
test "@floor with vectors" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
@ -754,7 +744,6 @@ fn testCeil() !void {
|
||||
|
||||
test "@ceil with vectors" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
@ -848,7 +837,6 @@ fn testTrunc() !void {
|
||||
|
||||
test "@trunc with vectors" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
|
||||
@ -100,7 +100,6 @@ test "@clz vectors" {
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
||||
|
||||
try testClzVectors();
|
||||
@ -163,7 +162,6 @@ test "@ctz vectors" {
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
||||
|
||||
if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
|
||||
@ -1526,7 +1524,6 @@ fn testNanEqNan(comptime F: type) !void {
|
||||
}
|
||||
|
||||
test "vector comparison" {
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
@ -1563,6 +1560,12 @@ test "signed zeros are represented properly" {
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
||||
|
||||
if (builtin.os.tag == .windows and builtin.cpu.arch == .aarch64 and
|
||||
builtin.zig_backend == .stage2_c)
|
||||
{
|
||||
return error.SkipZigTest;
|
||||
}
|
||||
|
||||
const S = struct {
|
||||
fn doTheTest() !void {
|
||||
try testOne(f16);
|
||||
|
||||
@ -25,7 +25,6 @@ test "@max" {
|
||||
test "@max on vectors" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
||||
@ -75,7 +74,6 @@ test "@min for vectors" {
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
||||
|
||||
const S = struct {
|
||||
|
||||
@ -100,7 +100,6 @@ fn vector16() !void {
|
||||
}
|
||||
|
||||
test "vector f16" {
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
@ -124,7 +123,6 @@ fn vector32() !void {
|
||||
}
|
||||
|
||||
test "vector f32" {
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
@ -148,7 +146,6 @@ fn vector64() !void {
|
||||
}
|
||||
|
||||
test "vector f64" {
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
@ -171,7 +168,6 @@ fn vector80() !void {
|
||||
}
|
||||
|
||||
test "vector f80" {
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
@ -195,13 +191,19 @@ fn vector128() !void {
|
||||
}
|
||||
|
||||
test "vector f128" {
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
||||
|
||||
if (builtin.os.tag == .windows and builtin.cpu.arch == .aarch64 and
|
||||
builtin.zig_backend == .stage2_c)
|
||||
{
|
||||
// https://github.com/ziglang/zig/issues/13876
|
||||
return error.SkipZigTest;
|
||||
}
|
||||
|
||||
comptime try vector128();
|
||||
try vector128();
|
||||
}
|
||||
|
||||
@ -67,7 +67,6 @@ fn testPopCountIntegers() !void {
|
||||
}
|
||||
|
||||
test "@popCount vectors" {
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
|
||||
@ -4,7 +4,6 @@ const mem = std.mem;
|
||||
const expect = std.testing.expect;
|
||||
|
||||
test "@select vectors" {
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
@ -33,7 +32,6 @@ fn selectVectors() !void {
|
||||
}
|
||||
|
||||
test "@select arrays" {
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
|
||||
@ -8,7 +8,6 @@ test "@shuffle int" {
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
||||
|
||||
const S = struct {
|
||||
@ -50,7 +49,6 @@ test "@shuffle bool 1" {
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
||||
|
||||
const S = struct {
|
||||
@ -71,7 +69,6 @@ test "@shuffle bool 2" {
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
||||
|
||||
if (builtin.zig_backend == .stage2_llvm) {
|
||||
@ -83,7 +80,7 @@ test "@shuffle bool 2" {
|
||||
fn doTheTest() !void {
|
||||
var x: @Vector(3, bool) = [3]bool{ false, true, false };
|
||||
var v: @Vector(2, bool) = [2]bool{ true, false };
|
||||
const mask: @Vector(4, i32) = [4]i32{ 0, ~@as(i32, 1), 1, 2 };
|
||||
const mask = [4]i32{ 0, ~@as(i32, 1), 1, 2 };
|
||||
var res = @shuffle(bool, x, v, mask);
|
||||
try expect(mem.eql(bool, &@as([4]bool, res), &[4]bool{ false, false, true, false }));
|
||||
}
|
||||
|
||||
@ -60,7 +60,6 @@ test "truncate on comptime integer" {
|
||||
}
|
||||
|
||||
test "truncate on vectors" {
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
|
||||
|
||||
@ -25,7 +25,6 @@ test "implicit cast vector to array - bool" {
|
||||
|
||||
test "vector wrap operators" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
@ -48,7 +47,6 @@ test "vector wrap operators" {
|
||||
|
||||
test "vector bin compares with mem.eql" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
@ -93,12 +91,18 @@ test "vector int operators" {
|
||||
|
||||
test "vector float operators" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
||||
|
||||
if (builtin.os.tag == .windows and builtin.cpu.arch == .aarch64 and
|
||||
builtin.zig_backend == .stage2_c)
|
||||
{
|
||||
// https://github.com/ziglang/zig/issues/13876
|
||||
return error.SkipZigTest;
|
||||
}
|
||||
|
||||
inline for ([_]type{ f16, f32, f64, f80, f128 }) |T| {
|
||||
const S = struct {
|
||||
fn doTheTest() !void {
|
||||
@ -117,7 +121,6 @@ test "vector float operators" {
|
||||
|
||||
test "vector bit operators" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
@ -237,7 +240,6 @@ test "vector casts of sizes not divisible by 8" {
|
||||
}
|
||||
|
||||
test "vector @splat" {
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
@ -403,7 +405,6 @@ test "initialize vector which is a struct field" {
|
||||
|
||||
test "vector comparison operators" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
@ -444,7 +445,6 @@ test "vector comparison operators" {
|
||||
|
||||
test "vector division operators" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
@ -527,7 +527,6 @@ test "vector division operators" {
|
||||
|
||||
test "vector bitwise not operator" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
@ -559,7 +558,6 @@ test "vector bitwise not operator" {
|
||||
|
||||
test "vector shift operators" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
@ -653,7 +651,6 @@ test "vector shift operators" {
|
||||
|
||||
test "vector reduce operation" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
@ -709,7 +706,7 @@ test "vector reduce operation" {
|
||||
|
||||
// LLVM 11 ERROR: Cannot select type
|
||||
// https://github.com/ziglang/zig/issues/7138
|
||||
if (builtin.target.cpu.arch != .aarch64) {
|
||||
if (builtin.zig_backend != .stage2_llvm or builtin.target.cpu.arch != .aarch64) {
|
||||
try testReduce(.Min, [4]i64{ 1234567, -386, 0, 3 }, @as(i64, -386));
|
||||
try testReduce(.Min, [4]u64{ 99, 9999, 9, 99999 }, @as(u64, 9));
|
||||
}
|
||||
@ -727,7 +724,7 @@ test "vector reduce operation" {
|
||||
|
||||
// LLVM 11 ERROR: Cannot select type
|
||||
// https://github.com/ziglang/zig/issues/7138
|
||||
if (builtin.target.cpu.arch != .aarch64) {
|
||||
if (builtin.zig_backend != .stage2_llvm or builtin.target.cpu.arch != .aarch64) {
|
||||
try testReduce(.Max, [4]i64{ 1234567, -386, 0, 3 }, @as(i64, 1234567));
|
||||
try testReduce(.Max, [4]u64{ 99, 9999, 9, 99999 }, @as(u64, 99999));
|
||||
}
|
||||
@ -775,14 +772,14 @@ test "vector reduce operation" {
|
||||
|
||||
// LLVM 11 ERROR: Cannot select type
|
||||
// https://github.com/ziglang/zig/issues/7138
|
||||
if (false) {
|
||||
try testReduce(.Min, [4]f16{ -1.9, 5.1, f16_nan, 100.0 }, f16_nan);
|
||||
try testReduce(.Min, [4]f32{ -1.9, 5.1, f32_nan, 100.0 }, f32_nan);
|
||||
try testReduce(.Min, [4]f64{ -1.9, 5.1, f64_nan, 100.0 }, f64_nan);
|
||||
if (builtin.zig_backend != .stage2_llvm) {
|
||||
try testReduce(.Min, [4]f16{ -1.9, 5.1, f16_nan, 100.0 }, @as(f16, -1.9));
|
||||
try testReduce(.Min, [4]f32{ -1.9, 5.1, f32_nan, 100.0 }, @as(f32, -1.9));
|
||||
try testReduce(.Min, [4]f64{ -1.9, 5.1, f64_nan, 100.0 }, @as(f64, -1.9));
|
||||
|
||||
try testReduce(.Max, [4]f16{ -1.9, 5.1, f16_nan, 100.0 }, f16_nan);
|
||||
try testReduce(.Max, [4]f32{ -1.9, 5.1, f32_nan, 100.0 }, f32_nan);
|
||||
try testReduce(.Max, [4]f64{ -1.9, 5.1, f64_nan, 100.0 }, f64_nan);
|
||||
try testReduce(.Max, [4]f16{ -1.9, 5.1, f16_nan, 100.0 }, @as(f16, 100.0));
|
||||
try testReduce(.Max, [4]f32{ -1.9, 5.1, f32_nan, 100.0 }, @as(f32, 100.0));
|
||||
try testReduce(.Max, [4]f64{ -1.9, 5.1, f64_nan, 100.0 }, @as(f64, 100.0));
|
||||
}
|
||||
|
||||
try testReduce(.Mul, [4]f16{ -1.9, 5.1, f16_nan, 100.0 }, f16_nan);
|
||||
@ -813,7 +810,6 @@ test "vector @reduce comptime" {
|
||||
|
||||
test "mask parameter of @shuffle is comptime scope" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
@ -833,7 +829,6 @@ test "mask parameter of @shuffle is comptime scope" {
|
||||
|
||||
test "saturating add" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
@ -865,7 +860,6 @@ test "saturating add" {
|
||||
|
||||
test "saturating subtraction" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
@ -888,7 +882,6 @@ test "saturating subtraction" {
|
||||
|
||||
test "saturating multiplication" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
@ -915,7 +908,6 @@ test "saturating multiplication" {
|
||||
|
||||
test "saturating shift-left" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
@ -1049,7 +1041,6 @@ test "@mulWithOverflow" {
|
||||
}
|
||||
|
||||
test "@shlWithOverflow" {
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
@ -1131,7 +1122,6 @@ test "byte vector initialized in inline function" {
|
||||
}
|
||||
|
||||
test "byte vector initialized in inline function" {
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
@ -1204,7 +1194,6 @@ test "zero multiplicand" {
|
||||
|
||||
test "@intCast to u0" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
@ -1228,7 +1217,6 @@ test "modRem with zero divisor" {
|
||||
|
||||
test "array operands to shuffle are coerced to vectors" {
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
||||
@ -1247,7 +1235,6 @@ test "load packed vector element" {
|
||||
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
|
||||
var x: @Vector(2, u15) = .{ 1, 4 };
|
||||
try expect((&x[0]).* == 1);
|
||||
@ -1260,7 +1247,6 @@ test "store packed vector element" {
|
||||
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
||||
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
||||
|
||||
var v = @Vector(4, u1){ 1, 1, 1, 1 };
|
||||
try expectEqual(@Vector(4, u1){ 1, 1, 1, 1 }, v);
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user