encounter/dawn-cmake
1
0
Fork 0
mirror of https://github.com/encounter/dawn-cmake.git synced 2025-07-05 04:36:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

tint/sem: Rename [un]signed Type helper methods

Browse Source 
These only consider integers. Include that fact in their name

Change-Id: I7b54c3fb0a6efd6f8de06fac7734a59eaf7829e5
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/113241
Reviewed-by: Dan Sinclair <dsinclair@chromium.org>
Kokoro: Kokoro <noreply+kokoro@google.com>
Commit-Queue: Ben Clayton <bclayton@google.com>
This commit is contained in:
Ben Clayton 2022-12-07 19:25:17 +00:00 committed by Dawn LUCI CQ
parent 507736a43c
commit 6c337aa18e
11 changed files with 34 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/tint/fuzzers/tint_ast_fuzzer/mutation_finders/change_unary_operators.cc
View File

@ -46,7 +46,7 @@ MutationList MutationFinderChangeUnaryOperators::FindMutations(
type->Is<sem::Reference>() ? type->As<sem::Reference>()->StoreType() : type; type->Is<sem::Reference>() ? type->As<sem::Reference>()->StoreType() : type;
// Only signed integer or vector of signed integer can be mutated. // Only signed integer or vector of signed integer can be mutated.
if (!basic_type->is_signed_scalar_or_vector()) { if (!basic_type->is_signed_integer_scalar_or_vector()) {
continue; continue;
} }

2
src/tint/fuzzers/tint_ast_fuzzer/mutations/change_unary_operator.cc
View File

@ -52,7 +52,7 @@ bool MutationChangeUnaryOperator::IsApplicable(const tint::Program& program,
// Only signed integer or vector of signed integer has more than 1 // Only signed integer or vector of signed integer has more than 1
// unary operators to change between. // unary operators to change between.
if (!basic_type->is_signed_scalar_or_vector()) { if (!basic_type->is_signed_integer_scalar_or_vector()) {
return false; return false;
} }

4
src/tint/fuzzers/tint_ast_fuzzer/mutations/wrap_unary_operator.cc
View File

@ -100,12 +100,12 @@ std::vector<ast::UnaryOp> MutationWrapUnaryOperator::GetValidUnaryWrapper(
return {ast::UnaryOp::kNot}; return {ast::UnaryOp::kNot};
} }
if (expr_type->is_signed_scalar_or_vector() || if (expr_type->is_signed_integer_scalar_or_vector() ||
expr_type->is_abstract_integer_scalar_or_vector()) { expr_type->is_abstract_integer_scalar_or_vector()) {
return {ast::UnaryOp::kNegation, ast::UnaryOp::kComplement}; return {ast::UnaryOp::kNegation, ast::UnaryOp::kComplement};
} }
if (expr_type->is_unsigned_scalar_or_vector()) { if (expr_type->is_unsigned_integer_scalar_or_vector()) {
return {ast::UnaryOp::kComplement}; return {ast::UnaryOp::kComplement};
} }

6
src/tint/sem/type.cc
View File

@ -121,16 +121,16 @@ bool Type::is_unsigned_integer_vector() const {
return Is([](const Vector* v) { return v->type()->Is<U32>(); }); return Is([](const Vector* v) { return v->type()->Is<U32>(); });
} }
bool Type::is_unsigned_scalar_or_vector() const { bool Type::is_unsigned_integer_scalar_or_vector() const {
return Is<U32>() || is_unsigned_integer_vector(); return Is<U32>() || is_unsigned_integer_vector();
} }
bool Type::is_signed_scalar_or_vector() const { bool Type::is_signed_integer_scalar_or_vector() const {
return IsAnyOf<I32, AbstractInt>() || is_signed_integer_vector(); return IsAnyOf<I32, AbstractInt>() || is_signed_integer_vector();
} }
bool Type::is_integer_scalar_or_vector() const { bool Type::is_integer_scalar_or_vector() const {
return is_unsigned_scalar_or_vector() || is_signed_scalar_or_vector(); return is_unsigned_integer_scalar_or_vector() || is_signed_integer_scalar_or_vector();
} }
bool Type::is_abstract_integer_vector() const { bool Type::is_abstract_integer_vector() const {

4
src/tint/sem/type.h
View File

@ -126,9 +126,9 @@ class Type : public Castable<Type, Node> {
/// @returns true if this type is an unsigned vector /// @returns true if this type is an unsigned vector
bool is_unsigned_integer_vector() const; bool is_unsigned_integer_vector() const;
/// @returns true if this type is an unsigned scalar or vector /// @returns true if this type is an unsigned scalar or vector
bool is_unsigned_scalar_or_vector() const; bool is_unsigned_integer_scalar_or_vector() const;
/// @returns true if this type is a signed scalar or vector /// @returns true if this type is a signed scalar or vector
bool is_signed_scalar_or_vector() const; bool is_signed_integer_scalar_or_vector() const;
/// @returns true if this type is an integer scalar or vector /// @returns true if this type is an integer scalar or vector
bool is_integer_scalar_or_vector() const; bool is_integer_scalar_or_vector() const;
/// @returns true if this type is an abstract integer vector /// @returns true if this type is an abstract integer vector

6
src/tint/transform/builtin_polyfill.cc
View File

@ -359,7 +359,7 @@ struct BuiltinPolyfill::State {
}; };
const ast::Expression* x = nullptr; const ast::Expression* x = nullptr;
if (ty->is_unsigned_scalar_or_vector()) { if (ty->is_unsigned_integer_scalar_or_vector()) {
x = b.Expr("v"); x = b.Expr("v");
} else { } else {
// If ty is signed, then the value is inverted if the sign is negative // If ty is signed, then the value is inverted if the sign is negative
@ -484,7 +484,7 @@ struct BuiltinPolyfill::State {
auto V = [&](auto value) -> const ast::Expression* { auto V = [&](auto value) -> const ast::Expression* {
const ast::Expression* expr = b.Expr(value); const ast::Expression* expr = b.Expr(value);
if (!ty->is_unsigned_scalar_or_vector()) { if (!ty->is_unsigned_integer_scalar_or_vector()) {
expr = b.Construct<i32>(expr); expr = b.Construct<i32>(expr);
} }
if (ty->Is<sem::Vector>()) { if (ty->Is<sem::Vector>()) {
@ -691,7 +691,7 @@ struct BuiltinPolyfill::State {
auto name = b.Symbols().New(is_div ? "tint_div" : "tint_mod"); auto name = b.Symbols().New(is_div ? "tint_div" : "tint_mod");
auto* use_one = b.Equal(rhs, ScalarOrVector(width, 0_a)); auto* use_one = b.Equal(rhs, ScalarOrVector(width, 0_a));
if (lhs_ty->is_signed_scalar_or_vector()) { if (lhs_ty->is_signed_integer_scalar_or_vector()) {
const auto bits = lhs_el_ty->Size() * 8; const auto bits = lhs_el_ty->Size() * 8;
auto min_int = AInt(AInt::kLowestValue >> (AInt::kNumBits - bits)); auto min_int = AInt(AInt::kLowestValue >> (AInt::kNumBits - bits));
const ast::Expression* lhs_is_min = b.Equal(lhs, ScalarOrVector(width, min_int)); const ast::Expression* lhs_is_min = b.Equal(lhs, ScalarOrVector(width, min_int));

2
src/tint/transform/robustness.cc
View File

@ -241,7 +241,7 @@ struct Robustness::State {
// texture_dims is u32 or vecN<u32> // texture_dims is u32 or vecN<u32>
const auto* unsigned_max = b.Sub(texture_dims, scalar_or_vec(b.Expr(1_a), width)); const auto* unsigned_max = b.Sub(texture_dims, scalar_or_vec(b.Expr(1_a), width));
if (target_ty->is_signed_scalar_or_vector()) { if (target_ty->is_signed_integer_scalar_or_vector()) {
const auto* zero = scalar_or_vec(b.Expr(0_a), width); const auto* zero = scalar_or_vec(b.Expr(0_a), width);
const auto* signed_max = cast_to_signed(unsigned_max, width); const auto* signed_max = cast_to_signed(unsigned_max, width);
ctx.Replace(coords_arg, b.Call("clamp", ctx.Clone(coords_arg), zero, signed_max)); ctx.Replace(coords_arg, b.Call("clamp", ctx.Clone(coords_arg), zero, signed_max));

15
src/tint/writer/glsl/generator_impl.cc
View File

@ -396,13 +396,16 @@ bool GeneratorImpl::EmitBitcast(std::ostream& out, const ast::BitcastExpression*
return EmitExpression(out, expr->expr); return EmitExpression(out, expr->expr);
} }
if (src_type->is_float_scalar_or_vector() && dst_type->is_signed_scalar_or_vector()) { if (src_type->is_float_scalar_or_vector() && dst_type->is_signed_integer_scalar_or_vector()) {
out << "floatBitsToInt"; out << "floatBitsToInt";
} else if (src_type->is_float_scalar_or_vector() && dst_type->is_unsigned_scalar_or_vector()) { } else if (src_type->is_float_scalar_or_vector() &&
dst_type->is_unsigned_integer_scalar_or_vector()) {
out << "floatBitsToUint"; out << "floatBitsToUint";
} else if (src_type->is_signed_scalar_or_vector() && dst_type->is_float_scalar_or_vector()) { } else if (src_type->is_signed_integer_scalar_or_vector() &&
dst_type->is_float_scalar_or_vector()) {
out << "intBitsToFloat"; out << "intBitsToFloat";
} else if (src_type->is_unsigned_scalar_or_vector() && dst_type->is_float_scalar_or_vector()) { } else if (src_type->is_unsigned_integer_scalar_or_vector() &&
dst_type->is_float_scalar_or_vector()) {
out << "uintBitsToFloat"; out << "uintBitsToFloat";
} else { } else {
if (!EmitType(out, dst_type, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) { if (!EmitType(out, dst_type, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) {
@ -823,7 +826,7 @@ bool GeneratorImpl::EmitBuiltinCall(std::ostream& out,
return EmitEmulatedFMA(out, expr); return EmitEmulatedFMA(out, expr);
} }
if (builtin->Type() == sem::BuiltinType::kAbs && if (builtin->Type() == sem::BuiltinType::kAbs &&
TypeOf(expr->args[0])->UnwrapRef()->is_unsigned_scalar_or_vector()) { TypeOf(expr->args[0])->UnwrapRef()->is_unsigned_integer_scalar_or_vector()) {
// GLSL does not support abs() on unsigned arguments. However, it's a no-op. // GLSL does not support abs() on unsigned arguments. However, it's a no-op.
return EmitExpression(out, expr->args[0]); return EmitExpression(out, expr->args[0]);
} }
@ -1401,7 +1404,7 @@ bool GeneratorImpl::EmitTextureCall(std::ostream& out,
auto emit_expr_as_signed = [&](const ast::Expression* e) { auto emit_expr_as_signed = [&](const ast::Expression* e) {
auto* ty = TypeOf(e)->UnwrapRef(); auto* ty = TypeOf(e)->UnwrapRef();
if (!ty->is_unsigned_scalar_or_vector()) { if (!ty->is_unsigned_integer_scalar_or_vector()) {
return EmitExpression(out, e); return EmitExpression(out, e);
} }
emit_signed_int_type(ty); emit_signed_int_type(ty);

2
src/tint/writer/hlsl/generator_impl.cc
View File

@ -987,7 +987,7 @@ bool GeneratorImpl::EmitBuiltinCall(std::ostream& out,
// crbug.com/tint/1550 // crbug.com/tint/1550
if (type == sem::BuiltinType::kCountOneBits || type == sem::BuiltinType::kReverseBits) { if (type == sem::BuiltinType::kCountOneBits || type == sem::BuiltinType::kReverseBits) {
auto* arg = call->Arguments()[0]; auto* arg = call->Arguments()[0];
if (arg->Type()->UnwrapRef()->is_signed_scalar_or_vector()) { if (arg->Type()->UnwrapRef()->is_signed_integer_scalar_or_vector()) {
out << "asint(" << name << "(asuint("; out << "asint(" << name << "(asuint(";
if (!EmitExpression(out, arg->Declaration())) { if (!EmitExpression(out, arg->Declaration())) {
return false; return false;

7
src/tint/writer/msl/generator_impl.cc
View File

@ -528,7 +528,8 @@ bool GeneratorImpl::EmitBinary(std::ostream& out, const ast::BinaryExpression* e
// Handle +/-/* of signed values // Handle +/-/* of signed values
if ((expr->IsAdd() || expr->IsSubtract() || expr->IsMultiply()) && if ((expr->IsAdd() || expr->IsSubtract() || expr->IsMultiply()) &&
lhs_type->is_signed_scalar_or_vector() && rhs_type->is_signed_scalar_or_vector()) { lhs_type->is_signed_integer_scalar_or_vector() &&
rhs_type->is_signed_integer_scalar_or_vector()) {
// If lhs or rhs is a vector, use that type (support implicit scalar to // If lhs or rhs is a vector, use that type (support implicit scalar to
// vector promotion) // vector promotion)
auto* target_type = lhs_type->Is<sem::Vector>() auto* target_type = lhs_type->Is<sem::Vector>()
@ -561,7 +562,7 @@ bool GeneratorImpl::EmitBinary(std::ostream& out, const ast::BinaryExpression* e
// TODO(crbug.com/tint/1077): This may not be necessary. The MSL spec // TODO(crbug.com/tint/1077): This may not be necessary. The MSL spec
// seems to imply that left shifting a signed value is treated the same as // seems to imply that left shifting a signed value is treated the same as
// left shifting an unsigned value, but we need to make sure. // left shifting an unsigned value, but we need to make sure.
if (expr->IsShiftLeft() && lhs_type->is_signed_scalar_or_vector()) { if (expr->IsShiftLeft() && lhs_type->is_signed_integer_scalar_or_vector()) {
// Shift left: discards top bits, so convert first operand to unsigned // Shift left: discards top bits, so convert first operand to unsigned
// first, then convert result back to signed // first, then convert result back to signed
ScopedBitCast outer_int_cast(this, out, lhs_type, signed_type_of(lhs_type)); ScopedBitCast outer_int_cast(this, out, lhs_type, signed_type_of(lhs_type));
@ -2918,7 +2919,7 @@ bool GeneratorImpl::EmitUnaryOp(std::ostream& out, const ast::UnaryOpExpression*
// Handle `-e` when `e` is signed, so that we ensure that if `e` is the // Handle `-e` when `e` is signed, so that we ensure that if `e` is the
// largest negative value, it returns `e`. // largest negative value, it returns `e`.
auto* expr_type = TypeOf(expr->expr)->UnwrapRef(); auto* expr_type = TypeOf(expr->expr)->UnwrapRef();
if (expr->op == ast::UnaryOp::kNegation && expr_type->is_signed_scalar_or_vector()) { if (expr->op == ast::UnaryOp::kNegation && expr_type->is_signed_integer_scalar_or_vector()) {
auto fn = utils::GetOrCreate(unary_minus_funcs_, expr_type, [&]() -> std::string { auto fn = utils::GetOrCreate(unary_minus_funcs_, expr_type, [&]() -> std::string {
// e.g.: // e.g.:
// int tint_unary_minus(const int v) { // int tint_unary_minus(const int v) {

14
src/tint/writer/spirv/builder.cc
View File

@ -117,7 +117,7 @@ uint32_t builtin_to_glsl_method(const sem::Builtin* builtin) {
case BuiltinType::kClamp: case BuiltinType::kClamp:
if (builtin->ReturnType()->is_float_scalar_or_vector()) { if (builtin->ReturnType()->is_float_scalar_or_vector()) {
return GLSLstd450NClamp; return GLSLstd450NClamp;
} else if (builtin->ReturnType()->is_unsigned_scalar_or_vector()) { } else if (builtin->ReturnType()->is_unsigned_integer_scalar_or_vector()) {
return GLSLstd450UClamp; return GLSLstd450UClamp;
} else { } else {
return GLSLstd450SClamp; return GLSLstd450SClamp;
@ -161,7 +161,7 @@ uint32_t builtin_to_glsl_method(const sem::Builtin* builtin) {
case BuiltinType::kMax: case BuiltinType::kMax:
if (builtin->ReturnType()->is_float_scalar_or_vector()) { if (builtin->ReturnType()->is_float_scalar_or_vector()) {
return GLSLstd450NMax; return GLSLstd450NMax;
} else if (builtin->ReturnType()->is_unsigned_scalar_or_vector()) { } else if (builtin->ReturnType()->is_unsigned_integer_scalar_or_vector()) {
return GLSLstd450UMax; return GLSLstd450UMax;
} else { } else {
return GLSLstd450SMax; return GLSLstd450SMax;
@ -169,7 +169,7 @@ uint32_t builtin_to_glsl_method(const sem::Builtin* builtin) {
case BuiltinType::kMin: case BuiltinType::kMin:
if (builtin->ReturnType()->is_float_scalar_or_vector()) { if (builtin->ReturnType()->is_float_scalar_or_vector()) {
return GLSLstd450NMin; return GLSLstd450NMin;
} else if (builtin->ReturnType()->is_unsigned_scalar_or_vector()) { } else if (builtin->ReturnType()->is_unsigned_integer_scalar_or_vector()) {
return GLSLstd450UMin; return GLSLstd450UMin;
} else { } else {
return GLSLstd450SMin; return GLSLstd450SMin;
@ -2052,7 +2052,7 @@ uint32_t Builder::GenerateBinaryExpression(const ast::BinaryExpression* expr) {
bool lhs_is_float_or_vec = lhs_type->is_float_scalar_or_vector(); bool lhs_is_float_or_vec = lhs_type->is_float_scalar_or_vector();
bool lhs_is_bool_or_vec = lhs_type->is_bool_scalar_or_vector(); bool lhs_is_bool_or_vec = lhs_type->is_bool_scalar_or_vector();
bool lhs_is_integer_or_vec = lhs_type->is_integer_scalar_or_vector(); bool lhs_is_integer_or_vec = lhs_type->is_integer_scalar_or_vector();
bool lhs_is_unsigned = lhs_type->is_unsigned_scalar_or_vector(); bool lhs_is_unsigned = lhs_type->is_unsigned_integer_scalar_or_vector();
spv::Op op = spv::Op::OpNop; spv::Op op = spv::Op::OpNop;
if (expr->IsAnd()) { if (expr->IsAnd()) {
@ -2187,7 +2187,7 @@ uint32_t Builder::GenerateBinaryExpression(const ast::BinaryExpression* expr) {
} }
} else if (expr->IsShiftLeft()) { } else if (expr->IsShiftLeft()) {
op = spv::Op::OpShiftLeftLogical; op = spv::Op::OpShiftLeftLogical;
} else if (expr->IsShiftRight() && lhs_type->is_signed_scalar_or_vector()) { } else if (expr->IsShiftRight() && lhs_type->is_signed_integer_scalar_or_vector()) {
// A shift right with a signed LHS is an arithmetic shift. // A shift right with a signed LHS is an arithmetic shift.
op = spv::Op::OpShiftRightArithmetic; op = spv::Op::OpShiftRightArithmetic;
} else if (expr->IsShiftRight()) { } else if (expr->IsShiftRight()) {
@ -2458,7 +2458,7 @@ uint32_t Builder::GenerateBuiltinCall(const sem::Call* call, const sem::Builtin*
op = spv::Op::OpDPdyFine; op = spv::Op::OpDPdyFine;
break; break;
case BuiltinType::kExtractBits: case BuiltinType::kExtractBits:
op = builtin->Parameters()[0]->Type()->is_unsigned_scalar_or_vector() op = builtin->Parameters()[0]->Type()->is_unsigned_integer_scalar_or_vector()
? spv::Op::OpBitFieldUExtract ? spv::Op::OpBitFieldUExtract
: spv::Op::OpBitFieldSExtract; : spv::Op::OpBitFieldSExtract;
break; break;
@ -2543,7 +2543,7 @@ uint32_t Builder::GenerateBuiltinCall(const sem::Call* call, const sem::Builtin*
op = spv::Op::OpTranspose; op = spv::Op::OpTranspose;
break; break;
case BuiltinType::kAbs: case BuiltinType::kAbs:
if (builtin->ReturnType()->is_unsigned_scalar_or_vector()) { if (builtin->ReturnType()->is_unsigned_integer_scalar_or_vector()) {
// abs() only operates on *signed* integers. // abs() only operates on *signed* integers.
// This is a no-op for unsigned integers. // This is a no-op for unsigned integers.
return get_arg_as_value_id(0); return get_arg_as_value_id(0);