mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2025-12-27 16:43:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #11105 from Luukdegram/wasm-misc

Browse Source 
stage2: wasm - miscellaneous improvements
This commit is contained in:
Andrew Kelley 2022-03-09 16:03:20 -05:00 committed by GitHub
commit 2aa4a32097
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
29 changed files with 347 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -212,7 +212,8 @@ fn buildOpcode(args: OpcodeBuildArguments) wasm.Opcode {
16 => switch (args.valtype1.?) {
.i32 => if (args.signedness.? == .signed) return .i32_load16_s else return .i32_load16_u,
.i64 => if (args.signedness.? == .signed) return .i64_load16_s else return .i64_load16_u,
.f32, .f64 => unreachable,
.f32 => return .f32_load,
.f64 => unreachable,
},
32 => switch (args.valtype1.?) {
.i64 => if (args.signedness.? == .signed) return .i64_load32_s else return .i64_load32_u,
@ -242,7 +243,8 @@ fn buildOpcode(args: OpcodeBuildArguments) wasm.Opcode {
16 => switch (args.valtype1.?) {
.i32 => return .i32_store16,
.i64 => return .i64_store16,
.f32, .f64 => unreachable,
.f32 => return .f32_store,
.f64 => unreachable,
},
32 => switch (args.valtype1.?) {
.i64 => return .i64_store32,
@ -1064,7 +1066,7 @@ fn allocStackPtr(self: *Self, inst: Air.Inst.Index) !WValue {
}
/// From given zig bitsize, returns the wasm bitsize
fn toWasmIntBits(bits: u16) ?u16 {
fn toWasmBits(bits: u16) ?u16 {
return for ([_]u16{ 32, 64 }) |wasm_bits| {
if (bits <= wasm_bits) return wasm_bits;
} else null;
@ -1120,11 +1122,11 @@ fn isByRef(ty: Type, target: std.Target) bool {
.ErrorSet,
.Fn,
.Enum,
.Vector,
.AnyFrame,
=> return false,
.Array,
.Vector,
.Struct,
.Frame,
.Union,
@ -1155,22 +1157,24 @@ fn isByRef(ty: Type, target: std.Target) bool {
/// local value to store the pointer. This allows for local re-use and improves binary size.
fn buildPointerOffset(self: *Self, ptr_value: WValue, offset: u64, action: enum { modify, new }) InnerError!WValue {
// do not perform arithmetic when offset is 0.
if (offset == 0 and ptr_value.offset() == 0) return ptr_value;
if (offset == 0 and ptr_value.offset() == 0 and action == .modify) return ptr_value;
const result_ptr: WValue = switch (action) {
.new => try self.allocLocal(Type.usize),
.modify => ptr_value,
};
try self.emitWValue(ptr_value);
switch (self.arch()) {
.wasm32 => {
try self.addImm32(@bitCast(i32, @intCast(u32, offset + ptr_value.offset())));
try self.addTag(.i32_add);
},
.wasm64 => {
try self.addImm64(offset + ptr_value.offset());
try self.addTag(.i64_add);
},
else => unreachable,
if (offset + ptr_value.offset() > 0) {
switch (self.arch()) {
.wasm32 => {
try self.addImm32(@bitCast(i32, @intCast(u32, offset + ptr_value.offset())));
try self.addTag(.i32_add);
},
.wasm64 => {
try self.addImm64(offset + ptr_value.offset());
try self.addTag(.i64_add);
},
else => unreachable,
}
}
try self.addLabel(.local_set, result_ptr.local);
return result_ptr;
@ -1218,6 +1222,8 @@ fn genInst(self: *Self, inst: Air.Inst.Index) !WValue {
.cond_br => self.airCondBr(inst),
.dbg_stmt => WValue.none,
.intcast => self.airIntcast(inst),
.fptrunc => self.airFptrunc(inst),
.fpext => self.airFpext(inst),
.float_to_int => self.airFloatToInt(inst),
.get_union_tag => self.airGetUnionTag(inst),
@ -1263,6 +1269,7 @@ fn genInst(self: *Self, inst: Air.Inst.Index) !WValue {
.struct_field_ptr_index_2 => self.airStructFieldPtrIndex(inst, 2),
.struct_field_ptr_index_3 => self.airStructFieldPtrIndex(inst, 3),
.struct_field_val => self.airStructFieldVal(inst),
.field_parent_ptr => self.airFieldParentPtr(inst),
.switch_br => self.airSwitchBr(inst),
.trunc => self.airTrunc(inst),
@ -1273,6 +1280,7 @@ fn genInst(self: *Self, inst: Air.Inst.Index) !WValue {
.unwrap_errunion_err => self.airUnwrapErrUnionError(inst),
.wrap_errunion_payload => self.airWrapErrUnionPayload(inst),
.wrap_errunion_err => self.airWrapErrUnionErr(inst),
.errunion_payload_ptr_set => self.airErrUnionPayloadPtrSet(inst),
.wasm_memory_size => self.airWasmMemorySize(inst),
.wasm_memory_grow => self.airWasmMemoryGrow(inst),
@ -1297,8 +1305,6 @@ fn genInst(self: *Self, inst: Air.Inst.Index) !WValue {
.bit_reverse,
.is_err_ptr,
.is_non_err_ptr,
.fptrunc,
.fpext,
.unwrap_errunion_payload_ptr,
.unwrap_errunion_err_ptr,
@ -1331,8 +1337,6 @@ fn genInst(self: *Self, inst: Air.Inst.Index) !WValue {
.atomic_rmw,
.tag_name,
.error_name,
.errunion_payload_ptr_set,
.field_parent_ptr,
.mul_add,
// For these 4, probably best to wait until https://github.com/ziglang/zig/issues/10248
@ -1370,7 +1374,10 @@ fn airRet(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
fn airRetPtr(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
const child_type = self.air.typeOfIndex(inst).childType();
if (child_type.abiSize(self.target) == 0) return WValue{ .none = {} };
if (!child_type.isFnOrHasRuntimeBits()) {
return self.allocStack(Type.usize); // create pointer to void
}
if (isByRef(child_type, self.target)) {
return self.return_value;
@ -1513,7 +1520,7 @@ fn store(self: *Self, lhs: WValue, rhs: WValue, ty: Type, offset: u32) InnerErro
return self.memCopy(ty, lhs, rhs);
},
.Struct, .Array, .Union => {
.Struct, .Array, .Union, .Vector => {
return self.memCopy(ty, lhs, rhs);
},
.Pointer => {
@ -1886,6 +1893,8 @@ fn valueAsI32(self: Self, val: Value, ty: Type) i32 {
const kv = self.bin_file.base.options.module.?.getErrorValue(val.getError().?) catch unreachable; // passed invalid `Value` to function
return @bitCast(i32, kv.value);
},
.Bool => return @intCast(i32, val.toSignedInt()),
.Pointer => return @intCast(i32, val.toSignedInt()),
else => unreachable, // Programmer called this function for an illegal type
}
}
@ -2164,8 +2173,8 @@ fn airSwitchBr(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
self.gpa.free(case.values);
} else case_list.deinit();
var lowest: i32 = 0;
var highest: i32 = 0;
var lowest_maybe: ?i32 = null;
var highest_maybe: ?i32 = null;
while (case_i < switch_br.data.cases_len) : (case_i += 1) {
const case = self.air.extraData(Air.SwitchBr.Case, extra_index);
const items = @bitCast([]const Air.Inst.Ref, self.air.extra[case.end..][0..case.data.items_len]);
@ -2177,11 +2186,11 @@ fn airSwitchBr(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
for (items) |ref, i| {
const item_val = self.air.value(ref).?;
const int_val = self.valueAsI32(item_val, target_ty);
if (int_val < lowest) {
lowest = int_val;
if (lowest_maybe == null or int_val < lowest_maybe.?) {
lowest_maybe = int_val;
}
if (int_val > highest) {
highest = int_val;
if (highest_maybe == null or int_val > highest_maybe.?) {
highest_maybe = int_val;
}
values[i] = .{ .integer = int_val, .value = item_val };
}
@ -2190,6 +2199,9 @@ fn airSwitchBr(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
try self.startBlock(.block, blocktype);
}
// When highest and lowest are null, we have no cases and can use a jump table
const lowest = lowest_maybe orelse 0;
const highest = highest_maybe orelse 0;
// When the highest and lowest values are seperated by '50',
// we define it as sparse and use an if/else-chain, rather than a jump table.
// When the target is an integer size larger than u32, we have no way to use the value
@ -2215,6 +2227,10 @@ fn airSwitchBr(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
// we put inside, are atleast 0.
try self.addImm32(lowest * -1);
try self.addTag(.i32_add);
} else if (lowest > 0) {
// make the index start from 0 by substracting the lowest value
try self.addImm32(lowest);
try self.addTag(.i32_sub);
}
// Account for default branch so always add '1'
@ -2223,12 +2239,13 @@ fn airSwitchBr(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
const table_extra_index = try self.addExtra(jump_table);
try self.addInst(.{ .tag = .br_table, .data = .{ .payload = table_extra_index } });
try self.mir_extra.ensureUnusedCapacity(self.gpa, depth);
while (lowest <= highest) : (lowest += 1) {
var value = lowest;
while (value <= highest) : (value += 1) {
// idx represents the branch we jump to
const idx = blk: {
for (case_list.items) |case, idx| {
for (case.values) |case_value| {
if (case_value.integer == lowest) break :blk @intCast(u32, idx);
if (case_value.integer == value) break :blk @intCast(u32, idx);
}
}
break :blk if (has_else_body) case_i else unreachable;
@ -2398,9 +2415,9 @@ fn airIntcast(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
const ref_info = ref_ty.intInfo(self.target);
const wanted_info = ty.intInfo(self.target);
const op_bits = toWasmIntBits(ref_info.bits) orelse
const op_bits = toWasmBits(ref_info.bits) orelse
return self.fail("TODO: Wasm intcast integer types of bitsize: {d}", .{ref_info.bits});
const wanted_bits = toWasmIntBits(wanted_info.bits) orelse
const wanted_bits = toWasmBits(wanted_info.bits) orelse
return self.fail("TODO: Wasm intcast integer types of bitsize: {d}", .{wanted_info.bits});
// hot path
@ -2641,7 +2658,7 @@ fn airTrunc(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
const result = try self.allocLocal(self.air.getRefType(ty_op.ty));
const op_bits = op_ty.intInfo(self.target).bits;
const wasm_bits = toWasmIntBits(wanted_bits) orelse
const wasm_bits = toWasmBits(wanted_bits) orelse
return self.fail("TODO: Implement wasm integer truncation for integer bitsize: {d}", .{wanted_bits});
// Use wasm's instruction to wrap from 64bit to 32bit integer when possible
@ -3172,3 +3189,90 @@ fn airGetUnionTag(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
} else @as(u32, 0);
return self.load(operand, tag_ty, offset);
}
fn airFpext(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
if (self.liveness.isUnused(inst)) return WValue{ .none = {} };
const ty_op = self.air.instructions.items(.data)[inst].ty_op;
const dest_ty = self.air.typeOfIndex(inst);
const dest_bits = dest_ty.floatBits(self.target);
const src_bits = self.air.typeOf(ty_op.operand).floatBits(self.target);
const operand = try self.resolveInst(ty_op.operand);
if (dest_bits == 64 and src_bits == 32) {
const result = try self.allocLocal(dest_ty);
try self.emitWValue(operand);
try self.addTag(.f64_promote_f32);
try self.addLabel(.local_set, result.local);
return result;
} else {
// TODO: Emit a call to compiler-rt to extend the float. e.g. __extendhfsf2
return self.fail("TODO: Implement 'fpext' for floats with bitsize: {d}", .{dest_bits});
}
}
fn airFptrunc(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
if (self.liveness.isUnused(inst)) return WValue{ .none = {} };
const ty_op = self.air.instructions.items(.data)[inst].ty_op;
const dest_ty = self.air.typeOfIndex(inst);
const dest_bits = dest_ty.floatBits(self.target);
const src_bits = self.air.typeOf(ty_op.operand).floatBits(self.target);
const operand = try self.resolveInst(ty_op.operand);
if (dest_bits == 32 and src_bits == 64) {
const result = try self.allocLocal(dest_ty);
try self.emitWValue(operand);
try self.addTag(.f32_demote_f64);
try self.addLabel(.local_set, result.local);
return result;
} else {
// TODO: Emit a call to compiler-rt to trunc the float. e.g. __truncdfhf2
return self.fail("TODO: Implement 'fptrunc' for floats with bitsize: {d}", .{dest_bits});
}
}
fn airErrUnionPayloadPtrSet(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
const ty_op = self.air.instructions.items(.data)[inst].ty_op;
const err_set_ty = self.air.typeOf(ty_op.operand).childType();
const err_ty = err_set_ty.errorUnionSet();
const payload_ty = err_set_ty.errorUnionPayload();
const operand = try self.resolveInst(ty_op.operand);
// set error-tag to '0' to annotate error union is non-error
try self.store(operand, .{ .imm32 = 0 }, err_ty, 0);
if (self.liveness.isUnused(inst)) return WValue{ .none = {} };
if (!payload_ty.hasRuntimeBits()) {
return operand;
}
const err_align = err_set_ty.abiAlignment(self.target);
const set_size = err_ty.abiSize(self.target);
const offset = mem.alignForwardGeneric(u64, set_size, err_align);
return self.buildPointerOffset(operand, @intCast(u32, offset), .new);
}
fn airFieldParentPtr(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
if (self.liveness.isUnused(inst)) return WValue{ .none = {} };
const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
const extra = self.air.extraData(Air.FieldParentPtr, ty_pl.payload).data;
const field_ptr = try self.resolveInst(extra.field_ptr);
const struct_ty = self.air.getRefType(ty_pl.ty).childType();
const field_offset = struct_ty.structFieldOffset(extra.field_index, self.target);
if (field_offset == 0) {
return field_ptr;
}
const base = try self.buildPointerOffset(field_ptr, 0, .new);
try self.addLabel(.local_get, base.local);
try self.addImm32(@bitCast(i32, @intCast(u32, field_offset)));
try self.addTag(.i32_sub);
try self.addLabel(.local_set, base.local);
return base;
}

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

@ -153,6 +153,34 @@ pub fn emitMir(emit: *Emit) InnerError!void {
.i64_shl => try emit.emitTag(tag),
.i64_shr_s => try emit.emitTag(tag),
.i64_shr_u => try emit.emitTag(tag),
.f32_abs => try emit.emitTag(tag),
.f32_neg => try emit.emitTag(tag),
.f32_ceil => try emit.emitTag(tag),
.f32_floor => try emit.emitTag(tag),
.f32_trunc => try emit.emitTag(tag),
.f32_nearest => try emit.emitTag(tag),
.f32_sqrt => try emit.emitTag(tag),
.f32_add => try emit.emitTag(tag),
.f32_sub => try emit.emitTag(tag),
.f32_mul => try emit.emitTag(tag),
.f32_div => try emit.emitTag(tag),
.f32_min => try emit.emitTag(tag),
.f32_max => try emit.emitTag(tag),
.f32_copysign => try emit.emitTag(tag),
.f64_abs => try emit.emitTag(tag),
.f64_neg => try emit.emitTag(tag),
.f64_ceil => try emit.emitTag(tag),
.f64_floor => try emit.emitTag(tag),
.f64_trunc => try emit.emitTag(tag),
.f64_nearest => try emit.emitTag(tag),
.f64_sqrt => try emit.emitTag(tag),
.f64_add => try emit.emitTag(tag),
.f64_sub => try emit.emitTag(tag),
.f64_mul => try emit.emitTag(tag),
.f64_div => try emit.emitTag(tag),
.f64_min => try emit.emitTag(tag),
.f64_max => try emit.emitTag(tag),
.f64_copysign => try emit.emitTag(tag),
.i32_wrap_i64 => try emit.emitTag(tag),
.i64_extend_i32_s => try emit.emitTag(tag),
.i64_extend_i32_u => try emit.emitTag(tag),
@ -161,6 +189,8 @@ pub fn emitMir(emit: *Emit) InnerError!void {
.i64_extend8_s => try emit.emitTag(tag),
.i64_extend16_s => try emit.emitTag(tag),
.i64_extend32_s => try emit.emitTag(tag),
.f32_demote_f64 => try emit.emitTag(tag),
.f64_promote_f32 => try emit.emitTag(tag),
.i32_reinterpret_f32 => try emit.emitTag(tag),
.i64_reinterpret_f64 => try emit.emitTag(tag),
.f32_reinterpret_i32 => try emit.emitTag(tag),

60
src/arch/wasm/Mir.zig
View File

@ -369,6 +369,62 @@ pub const Inst = struct {
/// Uses `tag`
i64_shr_u = 0x88,
/// Uses `tag`
f32_abs = 0x8B,
/// Uses `tag`
f32_neg = 0x8C,
/// Uses `tag`
f32_ceil = 0x8D,
/// Uses `tag`
f32_floor = 0x8E,
/// Uses `tag`
f32_trunc = 0x8F,
/// Uses `tag`
f32_nearest = 0x90,
/// Uses `tag`
f32_sqrt = 0x91,
/// Uses `tag`
f32_add = 0x92,
/// Uses `tag`
f32_sub = 0x93,
/// Uses `tag`
f32_mul = 0x94,
/// Uses `tag`
f32_div = 0x95,
/// Uses `tag`
f32_min = 0x96,
/// Uses `tag`
f32_max = 0x97,
/// Uses `tag`
f32_copysign = 0x98,
/// Uses `tag`
f64_abs = 0x99,
/// Uses `tag`
f64_neg = 0x9A,
/// Uses `tag`
f64_ceil = 0x9B,
/// Uses `tag`
f64_floor = 0x9C,
/// Uses `tag`
f64_trunc = 0x9D,
/// Uses `tag`
f64_nearest = 0x9E,
/// Uses `tag`
f64_sqrt = 0x9F,
/// Uses `tag`
f64_add = 0xA0,
/// Uses `tag`
f64_sub = 0xA1,
/// Uses `tag`
f64_mul = 0xA2,
/// Uses `tag`
f64_div = 0xA3,
/// Uses `tag`
f64_min = 0xA4,
/// Uses `tag`
f64_max = 0xA5,
/// Uses `tag`
f64_copysign = 0xA6,
/// Uses `tag`
i32_wrap_i64 = 0xA7,
/// Uses `tag`
i32_trunc_f32_s = 0xA8,
@ -391,6 +447,10 @@ pub const Inst = struct {
/// Uses `tag`
i64_trunc_f64_u = 0xB1,
/// Uses `tag`
f32_demote_f64 = 0xB6,
/// Uses `tag`
f64_promote_f32 = 0xBB,
/// Uses `tag`
i32_reinterpret_f32 = 0xBC,
/// Uses `tag`
i64_reinterpret_f64 = 0xBD,

42
test/behavior.zig
View File

@ -18,14 +18,19 @@ test {
_ = @import("behavior/bugs/679.zig");
_ = @import("behavior/bugs/704.zig");
_ = @import("behavior/bugs/718.zig");
_ = @import("behavior/bugs/726.zig");
_ = @import("behavior/bugs/828.zig");
_ = @import("behavior/bugs/1025.zig");
_ = @import("behavior/bugs/1076.zig");
_ = @import("behavior/bugs/1111.zig");
_ = @import("behavior/bugs/1277.zig");
_ = @import("behavior/bugs/1310.zig");
_ = @import("behavior/bugs/1381.zig");
_ = @import("behavior/bugs/1421.zig");
_ = @import("behavior/bugs/1442.zig");
_ = @import("behavior/bugs/1486.zig");
_ = @import("behavior/bugs/1500.zig");
_ = @import("behavior/bugs/1607.zig");
_ = @import("behavior/bugs/1735.zig");
_ = @import("behavior/bugs/1741.zig");
_ = @import("behavior/bugs/1914.zig");
@ -38,25 +43,34 @@ test {
_ = @import("behavior/bugs/3046.zig");
_ = @import("behavior/bugs/3112.zig");
_ = @import("behavior/bugs/3367.zig");
_ = @import("behavior/bugs/3384.zig");
_ = @import("behavior/bugs/3586.zig");
_ = @import("behavior/bugs/3742.zig");
_ = @import("behavior/bugs/4328.zig");
_ = @import("behavior/bugs/4560.zig");
_ = @import("behavior/bugs/4769_a.zig");
_ = @import("behavior/bugs/4769_b.zig");
_ = @import("behavior/bugs/4954.zig");
_ = @import("behavior/bugs/5398.zig");
_ = @import("behavior/bugs/5413.zig");
_ = @import("behavior/bugs/5474.zig");
_ = @import("behavior/bugs/5487.zig");
_ = @import("behavior/bugs/6850.zig");
_ = @import("behavior/bugs/7003.zig");
_ = @import("behavior/bugs/7250.zig");
_ = @import("behavior/bugs/11100.zig");
_ = @import("behavior/bugs/10970.zig");
_ = @import("behavior/call.zig");
_ = @import("behavior/cast.zig");
_ = @import("behavior/comptime_memory.zig");
_ = @import("behavior/defer.zig");
_ = @import("behavior/enum.zig");
_ = @import("behavior/error.zig");
_ = @import("behavior/field_parent_ptr.zig");
_ = @import("behavior/floatop.zig");
_ = @import("behavior/fn.zig");
_ = @import("behavior/fn_delegation.zig");
_ = @import("behavior/fn_in_struct_in_comptime.zig");
_ = @import("behavior/fn.zig");
_ = @import("behavior/for.zig");
_ = @import("behavior/generics.zig");
_ = @import("behavior/hasdecl.zig");
@ -69,6 +83,7 @@ test {
_ = @import("behavior/ir_block_deps.zig");
_ = @import("behavior/math.zig");
_ = @import("behavior/member_func.zig");
_ = @import("behavior/merge_error_sets.zig");
_ = @import("behavior/muladd.zig");
_ = @import("behavior/namespace_depends_on_compile_var.zig");
_ = @import("behavior/null.zig");
@ -79,10 +94,14 @@ test {
_ = @import("behavior/pub_enum.zig");
_ = @import("behavior/ref_var_in_if_after_if_2nd_switch_prong.zig");
_ = @import("behavior/reflection.zig");
_ = @import("behavior/slice.zig");
_ = @import("behavior/sizeof_and_typeof.zig");
_ = @import("behavior/slice_sentinel_comptime.zig");
_ = @import("behavior/slice.zig");
_ = @import("behavior/src.zig");
_ = @import("behavior/struct_contains_null_ptr_itself.zig");
_ = @import("behavior/struct.zig");
_ = @import("behavior/switch_prong_err_enum.zig");
_ = @import("behavior/switch_prong_implicit_cast.zig");
_ = @import("behavior/switch.zig");
_ = @import("behavior/this.zig");
_ = @import("behavior/truncate.zig");
@ -113,22 +132,11 @@ test {
{
// Tests that pass for stage1, llvm backend, C backend
_ = @import("behavior/bugs/421.zig");
_ = @import("behavior/bugs/726.zig");
_ = @import("behavior/bugs/828.zig");
_ = @import("behavior/bugs/1421.zig");
_ = @import("behavior/bugs/1607.zig");
_ = @import("behavior/bugs/3384.zig");
_ = @import("behavior/bugs/5398.zig");
_ = @import("behavior/bugs/5413.zig");
_ = @import("behavior/bugs/5474.zig");
_ = @import("behavior/bugs/7003.zig");
_ = @import("behavior/bugs/9584.zig");
_ = @import("behavior/bugs/10970.zig");
_ = @import("behavior/cast_int.zig");
_ = @import("behavior/eval.zig");
_ = @import("behavior/export_self_referential_type_info.zig");
_ = @import("behavior/int128.zig");
_ = @import("behavior/merge_error_sets.zig");
_ = @import("behavior/translate_c_macros.zig");
if (builtin.zig_backend != .stage2_c) {
@ -137,17 +145,9 @@ test {
_ = @import("behavior/maximum_minimum.zig");
_ = @import("behavior/popcount.zig");
_ = @import("behavior/saturating_arithmetic.zig");
_ = @import("behavior/sizeof_and_typeof.zig");
_ = @import("behavior/widening.zig");
_ = @import("behavior/bugs/1442.zig");
_ = @import("behavior/bugs/2114.zig");
_ = @import("behavior/bugs/3742.zig");
_ = @import("behavior/bugs/5487.zig");
_ = @import("behavior/struct_contains_null_ptr_itself.zig");
_ = @import("behavior/switch_prong_err_enum.zig");
_ = @import("behavior/switch_prong_implicit_cast.zig");
_ = @import("behavior/union_with_members.zig");
_ = @import("behavior/field_parent_ptr.zig");
if (builtin.zig_backend == .stage1) {
// Tests that only pass for the stage1 backend.

3
test/behavior/align.zig
View File

@ -158,7 +158,6 @@ fn give() anyerror!u128 {
test "page aligned array on stack" {
if (builtin.zig_backend == .stage2_aarch64) 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_arm) return error.SkipZigTest;
@ -359,7 +358,6 @@ test "read 128-bit field from default aligned struct in global memory" {
test "struct field explicit alignment" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
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;
@ -411,7 +409,6 @@ test "align(N) on functions" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
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;

4
test/behavior/bugs/10970.zig
View File

@ -4,6 +4,10 @@ fn retOpt() ?u32 {
return null;
}
test {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
var cond = true;
const opt = while (cond) {
if (retOpt()) |opt| {

5
test/behavior/bugs/1421.zig
View File

@ -1,5 +1,6 @@
const std = @import("std");
const expect = std.testing.expect;
const builtin = @import("builtin");
const S = struct {
fn method() std.builtin.Type {
@ -8,6 +9,10 @@ const S = struct {
};
test "functions with return type required to be comptime are generic" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
const ti = S.method();
try expect(@as(std.builtin.TypeId, ti) == std.builtin.TypeId.Struct);
}

4
test/behavior/bugs/1442.zig
View File

@ -7,6 +7,10 @@ const Union = union(enum) {
};
test "const error union field alignment" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
var union_or_err: anyerror!Union = Union{ .Color = 1234 };
try std.testing.expect((union_or_err catch unreachable).Color == 1234);
}

5
test/behavior/bugs/1607.zig
View File

@ -1,5 +1,6 @@
const std = @import("std");
const testing = std.testing;
const builtin = @import("builtin");
const a = [_]u8{ 1, 2, 3 };
@ -10,6 +11,10 @@ fn checkAddress(s: []const u8) !void {
}
test "slices pointing at the same address as global array." {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
try checkAddress(&a);
comptime try checkAddress(&a);
}

5
test/behavior/bugs/3742.zig
View File

@ -1,4 +1,5 @@
const std = @import("std");
const builtin = @import("builtin");
pub const GET = struct {
key: []const u8,
@ -34,5 +35,9 @@ pub const ArgSerializer = struct {
};
test "fixed" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
ArgSerializer.serializeCommand(GET.init("banana"));
}

5
test/behavior/bugs/5398.zig
View File

@ -1,5 +1,6 @@
const std = @import("std");
const testing = std.testing;
const builtin = @import("builtin");
pub const Mesh = struct {
id: u32,
@ -18,6 +19,10 @@ pub const Renderable = struct {
var renderable: Renderable = undefined;
test "assignment of field with padding" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
renderable = Renderable{
.mesh = Mesh{ .id = 0 },
.material = Material{

8
test/behavior/bugs/5474.zig
View File

@ -49,11 +49,19 @@ fn constant() !void {
}
test "pointer-to-array constness for zero-size elements, var" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
try mutable();
comptime try mutable();
}
test "pointer-to-array constness for zero-size elements, const" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
try constant();
comptime try constant();
}

5
test/behavior/bugs/5487.zig
View File

@ -1,4 +1,5 @@
const io = @import("std").io;
const builtin = @import("builtin");
pub fn write(_: void, bytes: []const u8) !usize {
_ = bytes;
@ -9,5 +10,9 @@ pub fn writer() io.Writer(void, @typeInfo(@typeInfo(@TypeOf(write)).Fn.return_ty
}
test "crash" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
_ = io.multiWriter(.{writer()});
}

11
test/behavior/bugs/726.zig
View File

@ -1,12 +1,23 @@
const expect = @import("std").testing.expect;
const builtin = @import("builtin");
test "@ptrCast from const to nullable" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
const c: u8 = 4;
var x: ?*const u8 = @ptrCast(?*const u8, &c);
try expect(x.?.* == 4);
}
test "@ptrCast from var in empty struct to nullable" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
const container = struct {
var c: u8 = 4;
};

5
test/behavior/bugs/828.zig
View File

@ -1,3 +1,5 @@
const builtin = @import("builtin");
const CountBy = struct {
a: usize,
@ -28,6 +30,9 @@ fn constCount(comptime cb: *const CountBy, comptime unused: u32) void {
}
test "comptime struct return should not return the same instance" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
//the first parameter must be passed by reference to trigger the bug
//a second parameter is required to trigger the bug
const ValA = constCount(&CountBy.One, 12);

1
test/behavior/enum.zig
View File

@ -938,7 +938,6 @@ test "constant enum initialization with differing sizes" {
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;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
try test3_1(test3_foo);
try test3_2(test3_bar);

3
test/behavior/error.zig
View File

@ -156,7 +156,6 @@ fn bar2() (error{}!void) {}
test "error union type " {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
try testErrorUnionType();
comptime try testErrorUnionType();
@ -199,7 +198,6 @@ fn testErrorSetType() !void {
test "explicit error set cast" {
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_wasm) return error.SkipZigTest; // TODO
try testExplicitErrorSetCast(Set1.A);
comptime try testExplicitErrorSetCast(Set1.A);
@ -296,7 +294,6 @@ test "error: Infer error set from literals" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
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_wasm) return error.SkipZigTest; // TODO
_ = nullLiteral("n") catch |err| handleErrors(err);
_ = floatLiteral("n") catch |err| handleErrors(err);

9
test/behavior/field_parent_ptr.zig
View File

@ -1,11 +1,20 @@
const expect = @import("std").testing.expect;
const builtin = @import("builtin");
test "@fieldParentPtr non-first field" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
try testParentFieldPtr(&foo.c);
comptime try testParentFieldPtr(&foo.c);
}
test "@fieldParentPtr first field" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
try testParentFieldPtrFirst(&foo.a);
comptime try testParentFieldPtrFirst(&foo.a);
}

1
test/behavior/math.zig
View File

@ -191,7 +191,6 @@ test "const number literal" {
const ten = 10;
test "float equality" {
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
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO

5
test/behavior/merge_error_sets.zig
View File

@ -1,3 +1,4 @@
const builtin = @import("builtin");
const A = error{
FileNotFound,
NotDir,
@ -11,6 +12,10 @@ fn foo() C!void {
}
test "merge error sets" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
if (foo()) {
@panic("unexpected");
} else |err| switch (err) {

1
test/behavior/null.zig
View File

@ -182,7 +182,6 @@ const here_is_a_null_literal = SillyStruct{ .context = null };
test "unwrap optional which is field of global var" {
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;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;

1
test/behavior/ptrcast.zig
View File

@ -43,7 +43,6 @@ fn testReinterpretBytesAsExternStruct() !void {
}
test "reinterpret struct field at comptime" {
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_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO

14
test/behavior/sizeof_and_typeof.zig
View File

@ -18,6 +18,10 @@ test "@sizeOf on compile-time types" {
}
test "@TypeOf() with multiple arguments" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
{
var var_1: u32 = undefined;
var var_2: u8 = undefined;
@ -74,6 +78,8 @@ const P = packed struct {
};
test "@offsetOf" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
// Packed structs have fixed memory layout
try expect(@offsetOf(P, "a") == 0);
@ -180,6 +186,10 @@ test "@sizeOf(T) == 0 doesn't force resolving struct size" {
}
test "@TypeOf() has no runtime side effects" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
const S = struct {
fn foo(comptime T: type, ptr: *T) T {
ptr.* += 1;
@ -193,6 +203,10 @@ test "@TypeOf() has no runtime side effects" {
}
test "branching logic inside @TypeOf" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
const S = struct {
var data: i32 = 0;
fn foo() anyerror!i32 {

5
test/behavior/struct_contains_null_ptr_itself.zig
View File

@ -1,7 +1,12 @@
const std = @import("std");
const expect = std.testing.expect;
const builtin = @import("builtin");
test "struct contains null pointer which contains original struct" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
var x: ?*NodeLineComment = null;
try expect(x == null);
}

1
test/behavior/switch.zig
View File

@ -122,7 +122,6 @@ fn trueIfBoolFalseOtherwise(comptime T: type) bool {
}
test "switching on booleans" {
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

5
test/behavior/switch_prong_err_enum.zig
View File

@ -1,4 +1,5 @@
const expect = @import("std").testing.expect;
const builtin = @import("builtin");
var read_count: u64 = 0;
@ -20,6 +21,10 @@ fn doThing(form_id: u64) anyerror!FormValue {
}
test "switch prong returns error enum" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
switch (doThing(17) catch unreachable) {
FormValue.Address => |payload| {
try expect(payload == 1);

5
test/behavior/switch_prong_implicit_cast.zig
View File

@ -1,4 +1,5 @@
const expect = @import("std").testing.expect;
const builtin = @import("builtin");
const FormValue = union(enum) {
One: void,
@ -14,6 +15,10 @@ fn foo(id: u64) !FormValue {
}
test "switch prong implicit cast" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
const result = switch (foo(2) catch unreachable) {
FormValue.One => false,
FormValue.Two => |x| x,

1
test/behavior/union.zig
View File

@ -457,7 +457,6 @@ test "initialize global array of union" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
glbl_array[1] = FooUnion{ .U1 = 2 };

3
test/behavior/var_args.zig
View File

@ -28,7 +28,6 @@ fn readFirstVarArg(args: anytype) void {
test "send void arg to var args" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
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_arm) return error.SkipZigTest; // TODO
@ -92,7 +91,6 @@ fn foo2(args: anytype) bool {
test "array of var args functions" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
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_arm) return error.SkipZigTest; // TODO
@ -102,7 +100,6 @@ test "array of var args functions" {
test "pass zero length array to var args param" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
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_arm) return error.SkipZigTest; // TODO