authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-05-17 16:51:35-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-05-17 23:50:38-07:00
log9031cc54f27b4483c62ab904dd94063a9499c842
tree0c771125a45adab3a9d80cbc6b101cad2bed0fd1
parent691fba38d8cf28a32e6d4a4cd2111c401e763d08

Sema: implement `@intCast` for vectors

2 files changed, 75 insertions(+), 26 deletions(-)

src/Sema.zig+70-25
......@@ -7020,22 +7020,25 @@ fn intCast(
70207020 operand_src: LazySrcLoc,
70217021 runtime_safety: bool,
70227022) CompileError!Air.Inst.Ref {
7023 // TODO: Add support for vectors
7024 const dest_is_comptime_int = try sema.checkIntType(block, dest_ty_src, dest_ty);
7025 _ = try sema.checkIntType(block, operand_src, sema.typeOf(operand));
7023 const operand_ty = sema.typeOf(operand);
7024 const dest_scalar_ty = try sema.checkIntOrVectorAllowComptime(block, dest_ty, dest_ty_src);
7025 const operand_scalar_ty = try sema.checkIntOrVectorAllowComptime(block, operand_ty, operand_src);
70267026
70277027 if (try sema.isComptimeKnown(block, operand_src, operand)) {
70287028 return sema.coerce(block, dest_ty, operand, operand_src);
7029 } else if (dest_is_comptime_int) {
7029 } else if (dest_scalar_ty.zigTypeTag() == .ComptimeInt) {
70307030 return sema.fail(block, operand_src, "unable to cast runtime value to 'comptime_int'", .{});
70317031 }
70327032
7033 try sema.checkVectorizableBinaryOperands(block, operand_src, dest_ty, operand_ty, dest_ty_src, operand_src);
7034 const is_vector = dest_ty.zigTypeTag() == .Vector;
7035
70337036 if ((try sema.typeHasOnePossibleValue(block, dest_ty_src, dest_ty))) |opv| {
70347037 // requirement: intCast(u0, input) iff input == 0
70357038 if (runtime_safety and block.wantSafety()) {
70367039 try sema.requireRuntimeBlock(block, operand_src);
70377040 const target = sema.mod.getTarget();
7038 const wanted_info = dest_ty.intInfo(target);
7041 const wanted_info = dest_scalar_ty.intInfo(target);
70397042 const wanted_bits = wanted_info.bits;
70407043
70417044 if (wanted_bits == 0) {
......@@ -7051,9 +7054,8 @@ fn intCast(
70517054 try sema.requireRuntimeBlock(block, operand_src);
70527055 if (runtime_safety and block.wantSafety()) {
70537056 const target = sema.mod.getTarget();
7054 const operand_ty = sema.typeOf(operand);
7055 const actual_info = operand_ty.intInfo(target);
7056 const wanted_info = dest_ty.intInfo(target);
7057 const actual_info = operand_scalar_ty.intInfo(target);
7058 const wanted_info = dest_scalar_ty.intInfo(target);
70577059 const actual_bits = actual_info.bits;
70587060 const wanted_bits = wanted_info.bits;
70597061 const actual_value_bits = actual_bits - @boolToInt(actual_info.signedness == .signed);
......@@ -7062,7 +7064,11 @@ fn intCast(
70627064 // range shrinkage
70637065 // requirement: int value fits into target type
70647066 if (wanted_value_bits < actual_value_bits) {
7065 const dest_max_val = try dest_ty.maxInt(sema.arena, target);
7067 const dest_max_val_scalar = try dest_scalar_ty.maxInt(sema.arena, target);
7068 const dest_max_val = if (is_vector)
7069 try Value.Tag.repeated.create(sema.arena, dest_max_val_scalar)
7070 else
7071 dest_max_val_scalar;
70667072 const dest_max = try sema.addConstant(operand_ty, dest_max_val);
70677073 const diff = try block.addBinOp(.subwrap, dest_max, operand);
70687074
......@@ -7080,19 +7086,59 @@ fn intCast(
70807086 } else dest_max_val;
70817087 const dest_range = try sema.addConstant(unsigned_operand_ty, dest_range_val);
70827088
7083 const is_in_range = try block.addBinOp(.cmp_lte, diff_unsigned, dest_range);
7084 try sema.addSafetyCheck(block, is_in_range, .cast_truncated_data);
7089 const ok = if (is_vector) ok: {
7090 const is_in_range = try block.addCmpVector(diff_unsigned, dest_range, .lte, try sema.addType(operand_ty));
7091 const all_in_range = try block.addInst(.{
7092 .tag = .reduce,
7093 .data = .{ .reduce = .{
7094 .operand = is_in_range,
7095 .operation = .And,
7096 } },
7097 });
7098 break :ok all_in_range;
7099 } else ok: {
7100 const is_in_range = try block.addBinOp(.cmp_lte, diff_unsigned, dest_range);
7101 break :ok is_in_range;
7102 };
7103 try sema.addSafetyCheck(block, ok, .cast_truncated_data);
70857104 } else {
7086 const is_in_range = try block.addBinOp(.cmp_lte, diff, dest_max);
7087 try sema.addSafetyCheck(block, is_in_range, .cast_truncated_data);
7105 const ok = if (is_vector) ok: {
7106 const is_in_range = try block.addCmpVector(diff, dest_max, .lte, try sema.addType(operand_ty));
7107 const all_in_range = try block.addInst(.{
7108 .tag = .reduce,
7109 .data = .{ .reduce = .{
7110 .operand = is_in_range,
7111 .operation = .And,
7112 } },
7113 });
7114 break :ok all_in_range;
7115 } else ok: {
7116 const is_in_range = try block.addBinOp(.cmp_lte, diff, dest_max);
7117 break :ok is_in_range;
7118 };
7119 try sema.addSafetyCheck(block, ok, .cast_truncated_data);
70887120 }
7089 }
7090 // no shrinkage, yes sign loss
7091 // requirement: signed to unsigned >= 0
7092 else if (actual_info.signedness == .signed and wanted_info.signedness == .unsigned) {
7093 const zero_inst = try sema.addConstant(operand_ty, Value.zero);
7094 const is_in_range = try block.addBinOp(.cmp_gte, operand, zero_inst);
7095 try sema.addSafetyCheck(block, is_in_range, .cast_truncated_data);
7121 } else if (actual_info.signedness == .signed and wanted_info.signedness == .unsigned) {
7122 // no shrinkage, yes sign loss
7123 // requirement: signed to unsigned >= 0
7124 const ok = if (is_vector) ok: {
7125 const zero_val = try Value.Tag.repeated.create(sema.arena, Value.zero);
7126 const zero_inst = try sema.addConstant(operand_ty, zero_val);
7127 const is_in_range = try block.addCmpVector(operand, zero_inst, .lte, try sema.addType(operand_ty));
7128 const all_in_range = try block.addInst(.{
7129 .tag = .reduce,
7130 .data = .{ .reduce = .{
7131 .operand = is_in_range,
7132 .operation = .And,
7133 } },
7134 });
7135 break :ok all_in_range;
7136 } else ok: {
7137 const zero_inst = try sema.addConstant(operand_ty, Value.zero);
7138 const is_in_range = try block.addBinOp(.cmp_gte, operand, zero_inst);
7139 break :ok is_in_range;
7140 };
7141 try sema.addSafetyCheck(block, ok, .cast_truncated_data);
70967142 }
70977143 }
70987144 return block.addTyOp(.intcast, dest_ty, operand);
......@@ -14517,8 +14563,8 @@ fn zirTruncate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1451714563 const dest_scalar_ty = try sema.resolveType(block, dest_ty_src, extra.lhs);
1451814564 const operand = sema.resolveInst(extra.rhs);
1451914565 const dest_is_comptime_int = try sema.checkIntType(block, dest_ty_src, dest_scalar_ty);
14520 const operand_scalar_ty = try sema.checkIntOrVectorAllowComptime(block, operand, operand_src);
1452114566 const operand_ty = sema.typeOf(operand);
14567 const operand_scalar_ty = try sema.checkIntOrVectorAllowComptime(block, operand_ty, operand_src);
1452214568 const is_vector = operand_ty.zigTypeTag() == .Vector;
1452314569 const dest_ty = if (is_vector)
1452414570 try Type.vector(sema.arena, operand_ty.vectorLen(), dest_scalar_ty)
......@@ -14686,7 +14732,7 @@ fn zirByteSwap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1468614732 const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg1 = inst_data.src_node };
1468714733 const operand = sema.resolveInst(inst_data.operand);
1468814734 const operand_ty = sema.typeOf(operand);
14689 const scalar_ty = try sema.checkIntOrVectorAllowComptime(block, operand, operand_src);
14735 const scalar_ty = try sema.checkIntOrVectorAllowComptime(block, operand_ty, operand_src);
1469014736 const target = sema.mod.getTarget();
1469114737 const bits = scalar_ty.intInfo(target).bits;
1469214738 if (bits % 8 != 0) {
......@@ -14743,7 +14789,7 @@ fn zirBitReverse(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
1474314789 const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg1 = inst_data.src_node };
1474414790 const operand = sema.resolveInst(inst_data.operand);
1474514791 const operand_ty = sema.typeOf(operand);
14746 _ = try sema.checkIntOrVectorAllowComptime(block, operand, operand_src);
14792 _ = try sema.checkIntOrVectorAllowComptime(block, operand_ty, operand_src);
1474714793
1474814794 if (try sema.typeHasOnePossibleValue(block, operand_src, operand_ty)) |val| {
1474914795 return sema.addConstant(operand_ty, val);
......@@ -15095,10 +15141,9 @@ fn checkIntOrVector(
1509515141fn checkIntOrVectorAllowComptime(
1509615142 sema: *Sema,
1509715143 block: *Block,
15098 operand: Air.Inst.Ref,
15144 operand_ty: Type,
1509915145 operand_src: LazySrcLoc,
1510015146) CompileError!Type {
15101 const operand_ty = sema.typeOf(operand);
1510215147 switch (try operand_ty.zigTypeTagOrPoison()) {
1510315148 .Int, .ComptimeInt => return operand_ty,
1510415149 .Vector => {
test/behavior/cast.zig+5-1
......@@ -587,7 +587,11 @@ test "cast *[1][*]const u8 to [*]const ?[*]const u8" {
587587}
588588
589589test "vector casts" {
590 if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
590 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
591 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
592 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
593 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
594 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
591595
592596 const S = struct {
593597 fn doTheTest() !void {