Move type methods to type class
This CL moves the checks for different types into the type class so it
can be used in both the type determinater and the SPIR-V builder.
Change-Id: I9142adaf5fc1d6048792645d7892f8d8900fcf59
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/19921
Reviewed-by: David Neto <dneto@google.com>
diff --git a/src/ast/type/type.cc b/src/ast/type/type.cc
index fc5ce2d..17ee534 100644
--- a/src/ast/type/type.cc
+++ b/src/ast/type/type.cc
@@ -80,6 +80,34 @@
return false;
}
+bool Type::is_float_scalar() {
+ return IsF32();
+}
+
+bool Type::is_float_matrix() {
+ return IsMatrix() && AsMatrix()->type()->is_float_scalar();
+}
+
+bool Type::is_float_vector() {
+ return IsVector() && AsVector()->type()->is_float_scalar();
+}
+
+bool Type::is_float_scalar_or_vector() {
+ return is_float_scalar() || is_float_vector();
+}
+
+bool Type::is_unsigned_scalar_or_vector() {
+ return IsU32() || (IsVector() && AsVector()->type()->IsU32());
+}
+
+bool Type::is_signed_scalar_or_vector() {
+ return IsI32() || (IsVector() && AsVector()->type()->IsI32());
+}
+
+bool Type::is_integer_scalar_or_vector() {
+ return is_unsigned_scalar_or_vector() || is_signed_scalar_or_vector();
+}
+
AliasType* Type::AsAlias() {
assert(IsAlias());
return static_cast<AliasType*>(this);
diff --git a/src/ast/type/type.h b/src/ast/type/type.h
index 05e29dd..4fa44ab 100644
--- a/src/ast/type/type.h
+++ b/src/ast/type/type.h
@@ -66,6 +66,21 @@
/// @returns the name for this type. The |type_name| is unique over all types.
virtual std::string type_name() const = 0;
+ /// @returns true if this type is a float scalar
+ bool is_float_scalar();
+ /// @returns true if this type is a float matrix
+ bool is_float_matrix();
+ /// @returns true if this type is a float vector
+ bool is_float_vector();
+ /// @returns true if this type is a float scalar or vector
+ bool is_float_scalar_or_vector();
+ /// @returns true if this type is an unsigned scalar or vector
+ bool is_unsigned_scalar_or_vector();
+ /// @returns true if this type is a signed scalar or vector
+ bool is_signed_scalar_or_vector();
+ /// @returns true if this type is an integer scalar or vector
+ bool is_integer_scalar_or_vector();
+
/// @returns the type as an alias type
AliasType* AsAlias();
/// @returns the type as an array type
diff --git a/src/writer/spirv/builder.cc b/src/writer/spirv/builder.cc
index 0e1a76f..ed435dc 100644
--- a/src/writer/spirv/builder.cc
+++ b/src/writer/spirv/builder.cc
@@ -80,36 +80,6 @@
return model;
}
-bool is_float_scalar(ast::type::Type* type) {
- return type->IsF32();
-}
-
-bool is_float_matrix(ast::type::Type* type) {
- return type->IsMatrix() && type->AsMatrix()->type()->IsF32();
-}
-
-bool is_float_vector(ast::type::Type* type) {
- return type->IsVector() && type->AsVector()->type()->IsF32();
-}
-
-bool is_float_scalar_or_vector(ast::type::Type* type) {
- return is_float_scalar(type) || is_float_vector(type);
-}
-
-bool is_unsigned_scalar_or_vector(ast::type::Type* type) {
- return type->IsU32() ||
- (type->IsVector() && type->AsVector()->type()->IsU32());
-}
-
-bool is_signed_scalar_or_vector(ast::type::Type* type) {
- return type->IsI32() ||
- (type->IsVector() && type->AsVector()->type()->IsI32());
-}
-
-bool is_integer_scalar_or_vector(ast::type::Type* type) {
- return is_unsigned_scalar_or_vector(type) || is_signed_scalar_or_vector(type);
-}
-
} // namespace
Builder::Builder() : scope_stack_({}) {}
@@ -601,8 +571,8 @@
// should have been rejected by validation.
auto* lhs_type = expr->lhs()->result_type();
auto* rhs_type = expr->rhs()->result_type();
- bool lhs_is_float_or_vec = is_float_scalar_or_vector(lhs_type);
- bool lhs_is_unsigned = is_unsigned_scalar_or_vector(lhs_type);
+ bool lhs_is_float_or_vec = lhs_type->is_float_scalar_or_vector();
+ bool lhs_is_unsigned = lhs_type->is_unsigned_scalar_or_vector();
spv::Op op = spv::Op::OpNop;
if (expr->IsAnd()) {
@@ -660,39 +630,39 @@
op = spv::Op::OpSMod;
}
} else if (expr->IsMultiply()) {
- if (is_integer_scalar_or_vector(lhs_type)) {
+ if (lhs_type->is_integer_scalar_or_vector()) {
// If the left hand side is an integer then this _has_ to be OpIMul as
// there there is no other integer multiplication.
op = spv::Op::OpIMul;
- } else if (is_float_scalar(lhs_type) && is_float_scalar(rhs_type)) {
+ } else if (lhs_type->is_float_scalar() && rhs_type->is_float_scalar()) {
// Float scalars multiply with OpFMul
op = spv::Op::OpFMul;
- } else if (is_float_vector(lhs_type) && is_float_vector(rhs_type)) {
+ } else if (lhs_type->is_float_vector() && rhs_type->is_float_vector()) {
// Float vectors must be validated to be the same size and then use OpFMul
op = spv::Op::OpFMul;
- } else if (is_float_scalar(lhs_type) && is_float_vector(rhs_type)) {
+ } else if (lhs_type->is_float_scalar() && rhs_type->is_float_vector()) {
// Scalar * Vector we need to flip lhs and rhs types
// because OpVectorTimesScalar expects <vector>, <scalar>
std::swap(lhs_id, rhs_id);
op = spv::Op::OpVectorTimesScalar;
- } else if (is_float_vector(lhs_type) && is_float_scalar(rhs_type)) {
+ } else if (lhs_type->is_float_vector() && rhs_type->is_float_scalar()) {
// float vector * scalar
op = spv::Op::OpVectorTimesScalar;
- } else if (is_float_scalar(lhs_type) && is_float_matrix(rhs_type)) {
+ } else if (lhs_type->is_float_scalar() && rhs_type->is_float_matrix()) {
// Scalar * Matrix we need to flip lhs and rhs types because
// OpMatrixTimesScalar expects <matrix>, <scalar>
std::swap(lhs_id, rhs_id);
op = spv::Op::OpMatrixTimesScalar;
- } else if (is_float_matrix(lhs_type) && is_float_scalar(rhs_type)) {
+ } else if (lhs_type->is_float_matrix() && rhs_type->is_float_scalar()) {
// float matrix * scalar
op = spv::Op::OpMatrixTimesScalar;
- } else if (is_float_vector(lhs_type) && is_float_matrix(rhs_type)) {
+ } else if (lhs_type->is_float_vector() && rhs_type->is_float_matrix()) {
// float vector * matrix
op = spv::Op::OpVectorTimesMatrix;
- } else if (is_float_matrix(lhs_type) && is_float_vector(rhs_type)) {
+ } else if (lhs_type->is_float_matrix() && rhs_type->is_float_vector()) {
// float matrix * vector
op = spv::Op::OpMatrixTimesVector;
- } else if (is_float_matrix(lhs_type) && is_float_matrix(rhs_type)) {
+ } else if (lhs_type->is_float_matrix() && rhs_type->is_float_matrix()) {
// float matrix * matrix
op = spv::Op::OpMatrixTimesMatrix;
} else {
