dawn-cmake/src/transform/first_index_offset.cc

278 lines
10 KiB
C++
Raw Normal View History

// 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 "src/transform/first_index_offset.h"
#include <cassert>
#include <utility>
#include "src/ast/array_accessor_expression.h"
#include "src/ast/assignment_statement.h"
#include "src/ast/binary_expression.h"
#include "src/ast/bitcast_expression.h"
#include "src/ast/break_statement.h"
#include "src/ast/builtin_decoration.h"
#include "src/ast/call_statement.h"
#include "src/ast/case_statement.h"
#include "src/ast/clone_context.h"
#include "src/ast/constructor_expression.h"
#include "src/ast/else_statement.h"
#include "src/ast/expression.h"
#include "src/ast/fallthrough_statement.h"
#include "src/ast/identifier_expression.h"
#include "src/ast/if_statement.h"
#include "src/ast/loop_statement.h"
#include "src/ast/member_accessor_expression.h"
#include "src/ast/return_statement.h"
#include "src/ast/scalar_constructor_expression.h"
#include "src/ast/struct.h"
#include "src/ast/struct_block_decoration.h"
#include "src/ast/struct_decoration.h"
#include "src/ast/struct_member.h"
#include "src/ast/struct_member_offset_decoration.h"
#include "src/ast/switch_statement.h"
#include "src/ast/type/struct_type.h"
#include "src/ast/type/u32_type.h"
#include "src/ast/type_constructor_expression.h"
#include "src/ast/unary_op_expression.h"
#include "src/ast/variable.h"
#include "src/ast/variable_decl_statement.h"
#include "src/ast/variable_decoration.h"
#include "src/type_determiner.h"
namespace tint {
namespace transform {
namespace {
constexpr char kStructName[] = "TintFirstIndexOffsetData";
constexpr char kBufferName[] = "tint_first_index_data";
constexpr char kFirstVertexName[] = "tint_first_vertex_index";
constexpr char kFirstInstanceName[] = "tint_first_instance_index";
constexpr char kIndexOffsetPrefix[] = "tint_first_index_offset_";
ast::Variable* clone_variable_with_new_name(ast::CloneContext* ctx,
ast::Variable* in,
std::string new_name) {
return ctx->mod->create<ast::Variable>(
ctx->Clone(in->source()), // source
new_name, // name
in->storage_class(), // storage_class
ctx->Clone(in->type()), // type
in->is_const(), // is_const
ctx->Clone(in->constructor()), // constructor
ctx->Clone(in->decorations())); // decorations
}
} // namespace
FirstIndexOffset::FirstIndexOffset(uint32_t binding, uint32_t set)
: binding_(binding), set_(set) {}
FirstIndexOffset::~FirstIndexOffset() = default;
Transform::Output FirstIndexOffset::Run(ast::Module* in) {
// First do a quick check to see if the transform has already been applied.
for (ast::Variable* var : in->global_variables()) {
if (auto* dec_var = var->As<ast::Variable>()) {
if (dec_var->name() == kBufferName) {
diag::Diagnostic err;
err.message = "First index offset transform has already been applied.";
err.severity = diag::Severity::Error;
Output out;
out.diagnostics.add(std::move(err));
return out;
}
}
}
// Running TypeDeterminer as we require local_referenced_builtin_variables()
// to be populated. TODO(bclayton) - it should not be necessary to re-run the
// type determiner if semantic information is already generated. Remove.
TypeDeterminer td(in);
if (!td.Determine()) {
diag::Diagnostic err;
err.severity = diag::Severity::Error;
err.message = td.error();
Output out;
out.diagnostics.add(std::move(err));
return out;
}
std::string vertex_index_name;
std::string instance_index_name;
Output out;
// Lazilly construct the UniformBuffer on first call to
// maybe_create_buffer_var()
ast::Variable* buffer_var = nullptr;
auto maybe_create_buffer_var = [&] {
if (buffer_var == nullptr) {
buffer_var = AddUniformBuffer(&out.module);
}
};
// Clone the AST, renaming the kVertexIdx and kInstanceIdx builtins, and add
// a CreateFirstIndexOffset() statement to each function that uses one of
// these builtins.
ast::CloneContext ctx(&out.module);
ctx.ReplaceAll([&](ast::Variable* var) -> ast::Variable* {
for (ast::VariableDecoration* dec : var->decorations()) {
if (auto* blt_dec = dec->As<ast::BuiltinDecoration>()) {
ast::Builtin blt_type = blt_dec->value();
if (blt_type == ast::Builtin::kVertexIdx) {
vertex_index_name = var->name();
has_vertex_index_ = true;
return clone_variable_with_new_name(&ctx, var,
kIndexOffsetPrefix + var->name());
} else if (blt_type == ast::Builtin::kInstanceIdx) {
instance_index_name = var->name();
has_instance_index_ = true;
return clone_variable_with_new_name(&ctx, var,
kIndexOffsetPrefix + var->name());
}
}
}
return nullptr; // Just clone var
});
ctx.ReplaceAll( // Note: This happens in the same pass as the rename above
// which determines the original builtin variable names,
// but this should be fine, as variables are cloned first.
[&](ast::Function* func) -> ast::Function* {
maybe_create_buffer_var();
if (buffer_var == nullptr) {
return nullptr; // no transform need, just clone func
}
auto* body = ctx.mod->create<ast::BlockStatement>(
ctx.Clone(func->body()->source()));
for (const auto& data : func->local_referenced_builtin_variables()) {
if (data.second->value() == ast::Builtin::kVertexIdx) {
body->append(CreateFirstIndexOffset(
vertex_index_name, kFirstVertexName, buffer_var, ctx.mod));
} else if (data.second->value() == ast::Builtin::kInstanceIdx) {
body->append(CreateFirstIndexOffset(
instance_index_name, kFirstInstanceName, buffer_var, ctx.mod));
}
}
for (auto* s : *func->body()) {
body->append(ctx.Clone(s));
}
return ctx.mod->create<ast::Function>(
ctx.Clone(func->source()), func->symbol(), func->name(),
ctx.Clone(func->params()), ctx.Clone(func->return_type()),
ctx.Clone(body), ctx.Clone(func->decorations()));
});
in->Clone(&ctx);
return out;
}
bool FirstIndexOffset::HasVertexIndex() {
return has_vertex_index_;
}
bool FirstIndexOffset::HasInstanceIndex() {
return has_instance_index_;
}
uint32_t FirstIndexOffset::GetFirstVertexOffset() {
assert(has_vertex_index_);
return vertex_index_offset_;
}
uint32_t FirstIndexOffset::GetFirstInstanceOffset() {
assert(has_instance_index_);
return instance_index_offset_;
}
ast::Variable* FirstIndexOffset::AddUniformBuffer(ast::Module* mod) {
auto* u32_type = mod->create<ast::type::U32>();
ast::StructMemberList members;
uint32_t offset = 0;
if (has_vertex_index_) {
ast::StructMemberDecorationList member_dec;
member_dec.push_back(
mod->create<ast::StructMemberOffsetDecoration>(offset, Source{}));
members.push_back(mod->create<ast::StructMember>(
Source{}, kFirstVertexName, u32_type, std::move(member_dec)));
vertex_index_offset_ = offset;
offset += 4;
}
if (has_instance_index_) {
ast::StructMemberDecorationList member_dec;
member_dec.push_back(
mod->create<ast::StructMemberOffsetDecoration>(offset, Source{}));
members.push_back(mod->create<ast::StructMember>(
Source{}, kFirstInstanceName, u32_type, std::move(member_dec)));
instance_index_offset_ = offset;
offset += 4;
}
ast::StructDecorationList decos;
decos.push_back(mod->create<ast::StructBlockDecoration>(Source{}));
auto* struct_type = mod->create<ast::type::Struct>(
mod->RegisterSymbol(kStructName), kStructName,
mod->create<ast::Struct>(Source{}, std::move(members), std::move(decos)));
auto* idx_var = mod->create<ast::Variable>(
Source{}, // source
kBufferName, // name
ast::StorageClass::kUniform, // storage_class
struct_type, // type
false, // is_const
nullptr, // constructor
ast::VariableDecorationList{
mod->create<ast::BindingDecoration>(binding_, Source{}),
mod->create<ast::SetDecoration>(set_, Source{}),
}); // decorations
mod->AddGlobalVariable(idx_var);
mod->AddConstructedType(struct_type);
return idx_var;
}
ast::VariableDeclStatement* FirstIndexOffset::CreateFirstIndexOffset(
const std::string& original_name,
const std::string& field_name,
ast::Variable* buffer_var,
ast::Module* mod) {
auto* buffer = mod->create<ast::IdentifierExpression>(
Source{}, mod->RegisterSymbol(buffer_var->name()), buffer_var->name());
auto* constructor = mod->create<ast::BinaryExpression>(
Source{}, ast::BinaryOp::kAdd,
mod->create<ast::IdentifierExpression>(
Source{}, mod->RegisterSymbol(kIndexOffsetPrefix + original_name),
kIndexOffsetPrefix + original_name),
mod->create<ast::MemberAccessorExpression>(
Source{}, buffer,
mod->create<ast::IdentifierExpression>(
Source{}, mod->RegisterSymbol(field_name), field_name)));
auto* var =
mod->create<ast::Variable>(Source{}, // source
original_name, // name
ast::StorageClass::kNone, // storage_class
mod->create<ast::type::U32>(), // type
true, // is_const
constructor, // constructor
ast::VariableDecorationList{}); // decorations
return mod->create<ast::VariableDeclStatement>(Source{}, var);
}
} // namespace transform
} // namespace tint