From c954788b5953b44d6df62b976d2efb1ab815f62e Mon Sep 17 00:00:00 2001 From: dan sinclair Date: Mon, 20 Apr 2020 14:07:43 +0000 Subject: [PATCH] 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 --- src/ast/type/type.cc | 28 +++++++++++++++++++ src/ast/type/type.h | 15 +++++++++++ src/writer/spirv/builder.cc | 54 +++++++++---------------------------- 3 files changed, 55 insertions(+), 42 deletions(-) diff --git a/src/ast/type/type.cc b/src/ast/type/type.cc index fc5ce2dc0d..17ee534094 100644 --- a/src/ast/type/type.cc +++ b/src/ast/type/type.cc @@ -80,6 +80,34 @@ bool Type::IsVoid() const { 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(this); diff --git a/src/ast/type/type.h b/src/ast/type/type.h index 05e29ddf64..4fa44ab1d9 100644 --- a/src/ast/type/type.h +++ b/src/ast/type/type.h @@ -66,6 +66,21 @@ class Type { /// @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 0e1a76f92a..ed435dc3ff 100644 --- a/src/writer/spirv/builder.cc +++ b/src/writer/spirv/builder.cc @@ -80,36 +80,6 @@ uint32_t pipeline_stage_to_execution_model(ast::PipelineStage stage) { 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 @@ uint32_t Builder::GenerateBinaryExpression(ast::BinaryExpression* expr) { // 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 @@ uint32_t Builder::GenerateBinaryExpression(ast::BinaryExpression* expr) { 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 , 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 , 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 {