| // Copyright 2022 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 "src/tint/transform/expand_compound_assignment.h" | |
| #include <utility> | |
| #include "src/tint/ast/compound_assignment_statement.h" | |
| #include "src/tint/ast/increment_decrement_statement.h" | |
| #include "src/tint/program_builder.h" | |
| #include "src/tint/sem/block_statement.h" | |
| #include "src/tint/sem/expression.h" | |
| #include "src/tint/sem/for_loop_statement.h" | |
| #include "src/tint/sem/statement.h" | |
| #include "src/tint/transform/utils/hoist_to_decl_before.h" | |
| TINT_INSTANTIATE_TYPEINFO(tint::transform::ExpandCompoundAssignment); | |
| namespace tint::transform { | |
| ExpandCompoundAssignment::ExpandCompoundAssignment() = default; | |
| ExpandCompoundAssignment::~ExpandCompoundAssignment() = default; | |
| bool ExpandCompoundAssignment::ShouldRun(const Program* program, | |
| const DataMap&) const { | |
| for (auto* node : program->ASTNodes().Objects()) { | |
| if (node->IsAnyOf<ast::CompoundAssignmentStatement, | |
| ast::IncrementDecrementStatement>()) { | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| /// Internal class used to collect statement expansions during the transform. | |
| class State { | |
| private: | |
| /// The clone context. | |
| CloneContext& ctx; | |
| /// The program builder. | |
| ProgramBuilder& b; | |
| /// The HoistToDeclBefore helper instance. | |
| HoistToDeclBefore hoist_to_decl_before; | |
| public: | |
| /// Constructor | |
| /// @param context the clone context | |
| explicit State(CloneContext& context) | |
| : ctx(context), b(*ctx.dst), hoist_to_decl_before(ctx) {} | |
| /// Replace `stmt` with a regular assignment statement of the form: | |
| /// lhs = lhs op rhs | |
| /// The LHS expression will only be evaluated once, and any side effects will | |
| /// be hoisted to `let` declarations above the assignment statement. | |
| /// @param stmt the statement to replace | |
| /// @param lhs the lhs expression from the source statement | |
| /// @param rhs the rhs expression in the destination module | |
| /// @param op the binary operator | |
| void Expand(const ast::Statement* stmt, | |
| const ast::Expression* lhs, | |
| const ast::Expression* rhs, | |
| ast::BinaryOp op) { | |
| // Helper function to create the new LHS expression. This will be called | |
| // twice when building the non-compound assignment statement, so must | |
| // not produce expressions that cause side effects. | |
| std::function<const ast::Expression*()> new_lhs; | |
| // Helper function to create a variable that is a pointer to `expr`. | |
| auto hoist_pointer_to = [&](const ast::Expression* expr) { | |
| auto name = b.Sym(); | |
| auto* ptr = b.AddressOf(ctx.Clone(expr)); | |
| auto* decl = b.Decl(b.Let(name, nullptr, ptr)); | |
| hoist_to_decl_before.InsertBefore(ctx.src->Sem().Get(stmt), decl); | |
| return name; | |
| }; | |
| // Helper function to hoist `expr` to a let declaration. | |
| auto hoist_expr_to_let = [&](const ast::Expression* expr) { | |
| auto name = b.Sym(); | |
| auto* decl = b.Decl(b.Let(name, nullptr, ctx.Clone(expr))); | |
| hoist_to_decl_before.InsertBefore(ctx.src->Sem().Get(stmt), decl); | |
| return name; | |
| }; | |
| // Helper function that returns `true` if the type of `expr` is a vector. | |
| auto is_vec = [&](const ast::Expression* expr) { | |
| return ctx.src->Sem().Get(expr)->Type()->UnwrapRef()->Is<sem::Vector>(); | |
| }; | |
| // Hoist the LHS expression subtree into local constants to produce a new | |
| // LHS that we can evaluate twice. | |
| // We need to special case compound assignments to vector components since | |
| // we cannot take the address of a vector component. | |
| auto* index_accessor = lhs->As<ast::IndexAccessorExpression>(); | |
| auto* member_accessor = lhs->As<ast::MemberAccessorExpression>(); | |
| if (lhs->Is<ast::IdentifierExpression>() || | |
| (member_accessor && | |
| member_accessor->structure->Is<ast::IdentifierExpression>())) { | |
| // This is the simple case with no side effects, so we can just use the | |
| // original LHS expression directly. | |
| // Before: | |
| // foo.bar += rhs; | |
| // After: | |
| // foo.bar = foo.bar + rhs; | |
| new_lhs = [&]() { return ctx.Clone(lhs); }; | |
| } else if (index_accessor && is_vec(index_accessor->object)) { | |
| // This is the case for vector component via an array accessor. We need | |
| // to capture a pointer to the vector and also the index value. | |
| // Before: | |
| // v[idx()] += rhs; | |
| // After: | |
| // let vec_ptr = &v; | |
| // let index = idx(); | |
| // (*vec_ptr)[index] = (*vec_ptr)[index] + rhs; | |
| auto lhs_ptr = hoist_pointer_to(index_accessor->object); | |
| auto index = hoist_expr_to_let(index_accessor->index); | |
| new_lhs = [&, lhs_ptr, index]() { | |
| return b.IndexAccessor(b.Deref(lhs_ptr), index); | |
| }; | |
| } else if (member_accessor && is_vec(member_accessor->structure)) { | |
| // This is the case for vector component via a member accessor. We just | |
| // need to capture a pointer to the vector. | |
| // Before: | |
| // a[idx()].y += rhs; | |
| // After: | |
| // let vec_ptr = &a[idx()]; | |
| // (*vec_ptr).y = (*vec_ptr).y + rhs; | |
| auto lhs_ptr = hoist_pointer_to(member_accessor->structure); | |
| new_lhs = [&, lhs_ptr]() { | |
| return b.MemberAccessor(b.Deref(lhs_ptr), | |
| ctx.Clone(member_accessor->member)); | |
| }; | |
| } else { | |
| // For all other statements that may have side-effecting expressions, we | |
| // just need to capture a pointer to the whole LHS. | |
| // Before: | |
| // a[idx()] += rhs; | |
| // After: | |
| // let lhs_ptr = &a[idx()]; | |
| // (*lhs_ptr) = (*lhs_ptr) + rhs; | |
| auto lhs_ptr = hoist_pointer_to(lhs); | |
| new_lhs = [&, lhs_ptr]() { return b.Deref(lhs_ptr); }; | |
| } | |
| // Replace the statement with a regular assignment statement. | |
| auto* value = b.create<ast::BinaryExpression>(op, new_lhs(), rhs); | |
| ctx.Replace(stmt, b.Assign(new_lhs(), value)); | |
| } | |
| /// Finalize the transformation and clone the module. | |
| void Finalize() { | |
| hoist_to_decl_before.Apply(); | |
| ctx.Clone(); | |
| } | |
| }; | |
| void ExpandCompoundAssignment::Run(CloneContext& ctx, | |
| const DataMap&, | |
| DataMap&) const { | |
| State state(ctx); | |
| for (auto* node : ctx.src->ASTNodes().Objects()) { | |
| if (auto* assign = node->As<ast::CompoundAssignmentStatement>()) { | |
| state.Expand(assign, assign->lhs, ctx.Clone(assign->rhs), assign->op); | |
| } else if (auto* inc_dec = node->As<ast::IncrementDecrementStatement>()) { | |
| // For increment/decrement statements, `i++` becomes `i = i + 1`. | |
| // TODO(jrprice): Simplify this when we have untyped literals. | |
| auto* sem_lhs = ctx.src->Sem().Get(inc_dec->lhs); | |
| const ast::IntLiteralExpression* one = | |
| sem_lhs->Type()->UnwrapRef()->is_signed_integer_scalar() | |
| ? ctx.dst->Expr(1)->As<ast::IntLiteralExpression>() | |
| : ctx.dst->Expr(1u)->As<ast::IntLiteralExpression>(); | |
| auto op = | |
| inc_dec->increment ? ast::BinaryOp::kAdd : ast::BinaryOp::kSubtract; | |
| state.Expand(inc_dec, inc_dec->lhs, one, op); | |
| } | |
| } | |
| state.Finalize(); | |
| } | |
| } // namespace tint::transform |