[spirv-writer] Add relational add

This CL adds the relational add expression to the spirv writer.

Bug: tint:5
Change-Id: Ideed225c63e60f53a019b79803809f8e973299c6
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/18605
Reviewed-by: David Neto <dneto@google.com>

src/CMakeLists.txt

@@ -423,6 +423,7 @@ if(${TINT_BUILD_SPV_WRITER})
   list(APPEND TINT_TEST_SRCS
     writer/spirv/binary_writer_test.cc
     writer/spirv/builder_assign_test.cc
+    writer/spirv/builder_binary_expression_test.cc
     writer/spirv/builder_constructor_expression_test.cc
     writer/spirv/builder_entry_point_test.cc
     writer/spirv/builder_function_test.cc

src/reader/spirv/function_decl_test.cc

@@ -12,12 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "src/reader/spirv/function.h"
-
 #include <string>
 #include <vector>
 
 #include "gmock/gmock.h"
+#include "src/reader/spirv/function.h"
 #include "src/reader/spirv/parser_impl.h"
 #include "src/reader/spirv/parser_impl_test_helper.h"
 #include "src/reader/spirv/spirv_tools_helpers_test.h"

src/writer/spirv/builder.cc

@@ -18,6 +18,7 @@
 
 #include "spirv/unified1/spirv.h"
 #include "src/ast/assignment_statement.h"
+#include "src/ast/binary_expression.h"
 #include "src/ast/binding_decoration.h"
 #include "src/ast/bool_literal.h"
 #include "src/ast/builtin_decoration.h"
@@ -163,8 +164,7 @@ bool Builder::GenerateAssignStatement(ast::AssignmentStatement* assign) {
     return false;
   }
 
-  push_function_inst(spv::Op::OpStore,
-                     {Operand::Int(lhs_id), Operand::Int(rhs_id)});
+  GenerateStore(lhs_id, rhs_id);
   return true;
 }
 
@@ -193,12 +193,15 @@ bool Builder::GenerateEntryPoint(ast::EntryPoint* ep) {
 }
 
 uint32_t Builder::GenerateExpression(ast::Expression* expr) {
-  if (expr->IsIdentifier()) {
-    return GenerateIdentifierExpression(expr->AsIdentifier());
+  if (expr->IsBinary()) {
+    return GenerateBinaryExpression(expr->AsBinary());
   }
   if (expr->IsConstructor()) {
     return GenerateConstructorExpression(expr->AsConstructor(), false);
   }
+  if (expr->IsIdentifier()) {
+    return GenerateIdentifierExpression(expr->AsIdentifier());
+  }
 
   error_ = "unknown expression type";
   return 0;
@@ -301,8 +304,7 @@ bool Builder::GenerateFunctionVariable(ast::Variable* var) {
   push_function_var(
       {Operand::Int(type_id), result, Operand::Int(ConvertStorageClass(sc))});
   if (var->has_constructor()) {
-    push_function_inst(spv::Op::OpStore,
-                       {Operand::Int(var_id), Operand::Int(init_id)});
+    GenerateStore(var_id, init_id);
   }
 
   scope_stack_.set(var->name(), var_id);
@@ -310,6 +312,10 @@ bool Builder::GenerateFunctionVariable(ast::Variable* var) {
   return true;
 }
 
+void Builder::GenerateStore(uint32_t to, uint32_t from) {
+  push_function_inst(spv::Op::OpStore, {Operand::Int(to), Operand::Int(from)});
+}
+
 bool Builder::GenerateGlobalVariable(ast::Variable* var) {
   uint32_t init_id = 0;
   if (var->has_constructor()) {
@@ -508,6 +514,41 @@ uint32_t Builder::GenerateLiteralIfNeeded(ast::Literal* lit) {
   return result_id;
 }
 
+uint32_t Builder::GenerateBinaryExpression(ast::BinaryExpression* expr) {
+  if (expr->IsAdd()) {
+    auto lhs_id = GenerateExpression(expr->lhs());
+    if (lhs_id == 0) {
+      return 0;
+    }
+    auto rhs_id = GenerateExpression(expr->rhs());
+    if (rhs_id == 0) {
+      return 0;
+    }
+
+    auto result = result_op();
+    auto result_id = result.to_i();
+
+    auto expr_type = expr->result_type();
+    auto type_id = GenerateTypeIfNeeded(expr_type);
+    if (type_id == 0) {
+      return 0;
+    }
+
+    // This handles int and float and the vectors of those types. Other types
+    // should have been rejected by validation.
+    spv::Op op = spv::Op::OpIAdd;
+    if (expr_type->IsF32() ||
+        (expr_type->IsVector() && expr_type->AsVector()->type()->IsF32())) {
+      op = spv::Op::OpFAdd;
+    }
+    push_function_inst(op, {Operand::Int(type_id), result, Operand::Int(lhs_id),
+                            Operand::Int(rhs_id)});
+
+    return result_id;
+  }
+  return 0;
+}
+
 bool Builder::GenerateReturnStatement(ast::ReturnStatement* stmt) {
   if (stmt->has_value()) {
     auto val_id = GenerateExpression(stmt->value());
@@ -542,6 +583,11 @@ bool Builder::GenerateVariableDeclStatement(ast::VariableDeclStatement* stmt) {
 }
 
 uint32_t Builder::GenerateTypeIfNeeded(ast::type::Type* type) {
+  if (type == nullptr) {
+    error_ = "attempting to generate type from null type";
+    return 0;
+  }
+
   if (type->IsAlias()) {
     return GenerateTypeIfNeeded(type->AsAlias()->type());
   }

src/writer/spirv/builder.h

@@ -189,6 +189,10 @@ class Builder {
   /// @param lit the literal to generate
   /// @returns the ID on success or 0 on failure
   uint32_t GenerateLiteralIfNeeded(ast::Literal* lit);
+  /// Generates a binary expression
+  /// @param expr the expression to generate
+  /// @returns the expression ID on success or 0 otherwise
+  uint32_t GenerateBinaryExpression(ast::BinaryExpression* expr);
   /// Generates a return statement
   /// @param stmt the statement to generate
   /// @returns true on success, false otherwise
@@ -197,6 +201,10 @@ class Builder {
   /// @param stmt the statement to generate
   /// @returns true if the statement was generated
   bool GenerateStatement(ast::Statement* stmt);
+  /// Geneates an OpStore
+  /// @param to the ID to store too
+  /// @param from the ID to store from
+  void GenerateStore(uint32_t to, uint32_t from);
   /// Generates a type if not already created
   /// @param type the type to create
   /// @returns the ID to use for the given type. Returns 0 on unknown type.

src/writer/spirv/builder_binary_expression_test.cc

@@ -0,0 +1,183 @@
+// Copyright 2020 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <memory>
+
+#include "gtest/gtest.h"
+#include "src/ast/binary_expression.h"
+#include "src/ast/type_constructor_expression.h"
+#include "src/ast/float_literal.h"
+#include "src/ast/int_literal.h"
+#include "src/ast/scalar_constructor_expression.h"
+#include "src/ast/type/f32_type.h"
+#include "src/ast/type/i32_type.h"
+#include "src/ast/type/vector_type.h"
+#include "src/context.h"
+#include "src/type_determiner.h"
+#include "src/writer/spirv/builder.h"
+#include "src/writer/spirv/spv_dump.h"
+
+namespace tint {
+namespace writer {
+namespace spirv {
+namespace {
+
+using BuilderTest = testing::Test;
+
+TEST_F(BuilderTest, Binary_Add_Integer) {
+  ast::type::I32Type i32;
+
+  auto lhs = std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::IntLiteral>(&i32, 3));
+  auto rhs = std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::IntLiteral>(&i32, 4));
+
+  ast::BinaryExpression expr(ast::BinaryOp::kAdd, std::move(lhs),
+                             std::move(rhs));
+
+  Context ctx;
+  TypeDeterminer td(&ctx);
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  Builder b;
+  b.push_function(Function{});
+
+  ASSERT_EQ(b.GenerateBinaryExpression(&expr), 4) << b.error();
+  EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeInt 32 1
+%2 = OpConstant %1 3
+%3 = OpConstant %1 4
+)");
+  EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()),
+            R"(%4 = OpIAdd %1 %2 %3
+)");
+}
+
+TEST_F(BuilderTest, Binary_Add_Integer_Vectors) {
+  ast::type::I32Type i32;
+  ast::type::VectorType vec3(&i32, 3);
+
+  ast::ExpressionList vals;
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+        std::make_unique<ast::IntLiteral>(&i32, 1)));
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+        std::make_unique<ast::IntLiteral>(&i32, 1)));
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+        std::make_unique<ast::IntLiteral>(&i32, 1)));
+  auto lhs = std::make_unique<ast::TypeConstructorExpression>(&vec3, std::move(vals));
+
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+        std::make_unique<ast::IntLiteral>(&i32, 1)));
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+        std::make_unique<ast::IntLiteral>(&i32, 1)));
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+        std::make_unique<ast::IntLiteral>(&i32, 1)));
+  auto rhs = std::make_unique<ast::TypeConstructorExpression>(&vec3, std::move(vals));
+
+  Context ctx;
+  TypeDeterminer td(&ctx);
+
+  ast::BinaryExpression expr(
+      ast::BinaryOp::kAdd, std::move(lhs), std::move(rhs));
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  Builder b;
+  b.push_function(Function{});
+
+  ASSERT_EQ(b.GenerateBinaryExpression(&expr), 5) << b.error();
+  EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 1
+%1 = OpTypeVector %2 3
+%3 = OpConstant %2 1
+%4 = OpConstantComposite %1 %3 %3 %3
+)");
+  EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()),
+            R"(%5 = OpIAdd %1 %4 %4
+)");
+}
+
+TEST_F(BuilderTest, Binary_Add_Float) {
+  ast::type::F32Type f32;
+
+  auto lhs = std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 3.2f));
+  auto rhs = std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 4.5f));
+
+  ast::BinaryExpression expr(ast::BinaryOp::kAdd, std::move(lhs),
+                             std::move(rhs));
+
+  Context ctx;
+  TypeDeterminer td(&ctx);
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  Builder b;
+  b.push_function(Function{});
+
+  ASSERT_EQ(b.GenerateBinaryExpression(&expr), 4) << b.error();
+  EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 32
+%2 = OpConstant %1 3.20000005
+%3 = OpConstant %1 4.5
+)");
+  EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()),
+            R"(%4 = OpFAdd %1 %2 %3
+)");
+}
+
+TEST_F(BuilderTest, Binary_Add_Float_Vectors) {
+  ast::type::F32Type f32;
+  ast::type::VectorType vec3(&f32, 3);
+
+  ast::ExpressionList vals;
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+        std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+        std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+        std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+  auto lhs = std::make_unique<ast::TypeConstructorExpression>(&vec3, std::move(vals));
+
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+        std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+        std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+        std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+  auto rhs = std::make_unique<ast::TypeConstructorExpression>(&vec3, std::move(vals));
+
+  Context ctx;
+  TypeDeterminer td(&ctx);
+
+  ast::BinaryExpression expr(
+      ast::BinaryOp::kAdd, std::move(lhs), std::move(rhs));
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  Builder b;
+  b.push_function(Function{});
+
+  ASSERT_EQ(b.GenerateBinaryExpression(&expr), 5) << b.error();
+  EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32
+%1 = OpTypeVector %2 3
+%3 = OpConstant %2 1
+%4 = OpConstantComposite %1 %3 %3 %3
+)");
+  EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()),
+            R"(%5 = OpFAdd %1 %4 %4
+)");
+}
+
+}  // namespace
+}  // namespace spirv
+}  // namespace writer
+}  // namespace tint