blob: 9435162a3a66bb230df2676186d2ab9c42eecbf3 [file] [log] [blame]
// 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/tint/lang/wgsl/resolver/resolver.h"
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <limits>
#include <utility>
#include "src/tint/lang/core/builtin.h"
#include "src/tint/lang/core/constant/scalar.h"
#include "src/tint/lang/core/fluent_types.h"
#include "src/tint/lang/core/intrinsic/data/data.h"
#include "src/tint/lang/core/type/abstract_float.h"
#include "src/tint/lang/core/type/abstract_int.h"
#include "src/tint/lang/core/type/array.h"
#include "src/tint/lang/core/type/atomic.h"
#include "src/tint/lang/core/type/builtin_structs.h"
#include "src/tint/lang/core/type/depth_multisampled_texture.h"
#include "src/tint/lang/core/type/depth_texture.h"
#include "src/tint/lang/core/type/external_texture.h"
#include "src/tint/lang/core/type/multisampled_texture.h"
#include "src/tint/lang/core/type/pointer.h"
#include "src/tint/lang/core/type/reference.h"
#include "src/tint/lang/core/type/sampled_texture.h"
#include "src/tint/lang/core/type/sampler.h"
#include "src/tint/lang/core/type/storage_texture.h"
#include "src/tint/lang/wgsl/ast/alias.h"
#include "src/tint/lang/wgsl/ast/assignment_statement.h"
#include "src/tint/lang/wgsl/ast/attribute.h"
#include "src/tint/lang/wgsl/ast/bitcast_expression.h"
#include "src/tint/lang/wgsl/ast/break_statement.h"
#include "src/tint/lang/wgsl/ast/call_statement.h"
#include "src/tint/lang/wgsl/ast/continue_statement.h"
#include "src/tint/lang/wgsl/ast/disable_validation_attribute.h"
#include "src/tint/lang/wgsl/ast/discard_statement.h"
#include "src/tint/lang/wgsl/ast/for_loop_statement.h"
#include "src/tint/lang/wgsl/ast/id_attribute.h"
#include "src/tint/lang/wgsl/ast/if_statement.h"
#include "src/tint/lang/wgsl/ast/internal_attribute.h"
#include "src/tint/lang/wgsl/ast/interpolate_attribute.h"
#include "src/tint/lang/wgsl/ast/loop_statement.h"
#include "src/tint/lang/wgsl/ast/return_statement.h"
#include "src/tint/lang/wgsl/ast/switch_statement.h"
#include "src/tint/lang/wgsl/ast/traverse_expressions.h"
#include "src/tint/lang/wgsl/ast/unary_op_expression.h"
#include "src/tint/lang/wgsl/ast/variable_decl_statement.h"
#include "src/tint/lang/wgsl/ast/while_statement.h"
#include "src/tint/lang/wgsl/ast/workgroup_attribute.h"
#include "src/tint/lang/wgsl/resolver/uniformity.h"
#include "src/tint/lang/wgsl/sem/break_if_statement.h"
#include "src/tint/lang/wgsl/sem/builtin_enum_expression.h"
#include "src/tint/lang/wgsl/sem/call.h"
#include "src/tint/lang/wgsl/sem/for_loop_statement.h"
#include "src/tint/lang/wgsl/sem/function.h"
#include "src/tint/lang/wgsl/sem/function_expression.h"
#include "src/tint/lang/wgsl/sem/if_statement.h"
#include "src/tint/lang/wgsl/sem/index_accessor_expression.h"
#include "src/tint/lang/wgsl/sem/load.h"
#include "src/tint/lang/wgsl/sem/loop_statement.h"
#include "src/tint/lang/wgsl/sem/materialize.h"
#include "src/tint/lang/wgsl/sem/member_accessor_expression.h"
#include "src/tint/lang/wgsl/sem/module.h"
#include "src/tint/lang/wgsl/sem/statement.h"
#include "src/tint/lang/wgsl/sem/struct.h"
#include "src/tint/lang/wgsl/sem/switch_statement.h"
#include "src/tint/lang/wgsl/sem/type_expression.h"
#include "src/tint/lang/wgsl/sem/value_constructor.h"
#include "src/tint/lang/wgsl/sem/value_conversion.h"
#include "src/tint/lang/wgsl/sem/variable.h"
#include "src/tint/lang/wgsl/sem/while_statement.h"
#include "src/tint/utils/containers/reverse.h"
#include "src/tint/utils/containers/transform.h"
#include "src/tint/utils/containers/vector.h"
#include "src/tint/utils/macros/compiler.h"
#include "src/tint/utils/macros/defer.h"
#include "src/tint/utils/macros/scoped_assignment.h"
#include "src/tint/utils/math/math.h"
#include "src/tint/utils/text/string.h"
#include "src/tint/utils/text/string_stream.h"
using namespace tint::core::fluent_types; // NOLINT
TINT_INSTANTIATE_TYPEINFO(tint::sem::BuiltinEnumExpression<tint::core::Access>);
TINT_INSTANTIATE_TYPEINFO(tint::sem::BuiltinEnumExpression<tint::core::AddressSpace>);
TINT_INSTANTIATE_TYPEINFO(tint::sem::BuiltinEnumExpression<tint::core::BuiltinValue>);
TINT_INSTANTIATE_TYPEINFO(tint::sem::BuiltinEnumExpression<tint::core::InterpolationSampling>);
TINT_INSTANTIATE_TYPEINFO(tint::sem::BuiltinEnumExpression<tint::core::InterpolationType>);
TINT_INSTANTIATE_TYPEINFO(tint::sem::BuiltinEnumExpression<tint::core::TexelFormat>);
namespace tint::resolver {
namespace {
using CtorConvIntrinsic = core::intrinsic::CtorConv;
using OverloadFlag = core::intrinsic::OverloadFlag;
constexpr int64_t kMaxArrayElementCount = 65536;
constexpr uint32_t kMaxStatementDepth = 127;
constexpr size_t kMaxNestDepthOfCompositeType = 255;
} // namespace
Resolver::Resolver(ProgramBuilder* builder)
: builder_(builder),
diagnostics_(builder->Diagnostics()),
const_eval_(builder->constants, diagnostics_),
intrinsic_context_{core::intrinsic::data::kData, builder->Types(), builder->Symbols(),
builder->Diagnostics()},
sem_(builder),
validator_(builder,
sem_,
enabled_extensions_,
atomic_composite_info_,
valid_type_storage_layouts_) {}
Resolver::~Resolver() = default;
bool Resolver::Resolve() {
if (diagnostics_.contains_errors()) {
return false;
}
builder_->Sem().Reserve(builder_->LastAllocatedNodeID());
// Pre-allocate the marked bitset with the total number of AST nodes.
marked_.Resize(builder_->ASTNodes().Count());
if (!DependencyGraph::Build(builder_->AST(), diagnostics_, dependencies_)) {
return false;
}
bool result = ResolveInternal();
if (TINT_UNLIKELY(!result && !diagnostics_.contains_errors())) {
AddICE("resolving failed, but no error was raised", {});
return false;
}
// Create the semantic module. Don't be tempted to std::move() these, they're used below.
auto* mod = builder_->create<sem::Module>(dependencies_.ordered_globals, enabled_extensions_);
ApplyDiagnosticSeverities(mod);
builder_->Sem().SetModule(mod);
const bool disable_uniformity_analysis =
enabled_extensions_.Contains(wgsl::Extension::kChromiumDisableUniformityAnalysis);
if (result && !disable_uniformity_analysis) {
// Run the uniformity analysis, which requires a complete semantic module.
if (!AnalyzeUniformity(builder_, dependencies_)) {
return false;
}
}
return result;
}
bool Resolver::ResolveInternal() {
Mark(&builder_->AST());
// Process all module-scope declarations in dependency order.
Vector<const ast::DiagnosticControl*, 4> diagnostic_controls;
for (auto* decl : dependencies_.ordered_globals) {
Mark(decl);
if (!Switch<bool>(
decl, //
[&](const ast::DiagnosticDirective* d) {
diagnostic_controls.Push(&d->control);
return DiagnosticControl(d->control);
},
[&](const ast::Enable* e) { return Enable(e); },
[&](const ast::TypeDecl* td) { return TypeDecl(td); },
[&](const ast::Function* func) { return Function(func); },
[&](const ast::Variable* var) { return GlobalVariable(var); },
[&](const ast::ConstAssert* ca) { return ConstAssert(ca); },
[&](Default) {
TINT_UNREACHABLE() << "unhandled global declaration: " << decl->TypeInfo().name;
return false;
})) {
return false;
}
}
if (!AllocateOverridableConstantIds()) {
return false;
}
SetShadows();
if (!validator_.DiagnosticControls(diagnostic_controls, "directive")) {
return false;
}
if (!validator_.PipelineStages(entry_points_)) {
return false;
}
if (!validator_.ModuleScopeVarUsages(entry_points_)) {
return false;
}
bool result = true;
for (auto* node : builder_->ASTNodes().Objects()) {
if (TINT_UNLIKELY(!marked_[node->node_id.value])) {
StringStream err;
err << "AST node '" << node->TypeInfo().name << "' was not reached by the resolver\n"
<< "Pointer: " << node;
AddICE(err.str(), node->source);
result = false;
}
}
return result;
}
sem::Variable* Resolver::Variable(const ast::Variable* v, bool is_global) {
Mark(v->name);
return Switch(
v, //
[&](const ast::Var* var) { return Var(var, is_global); },
[&](const ast::Let* let) { return Let(let, is_global); },
[&](const ast::Override* override) { return Override(override); },
[&](const ast::Const* const_) { return Const(const_, is_global); },
[&](Default) {
StringStream err;
err << "Resolver::GlobalVariable() called with a unknown variable type: "
<< v->TypeInfo().name;
AddICE(err.str(), v->source);
return nullptr;
});
}
sem::Variable* Resolver::Let(const ast::Let* v, bool is_global) {
const core::type::Type* ty = nullptr;
// If the variable has a declared type, resolve it.
if (v->type) {
ty = Type(v->type);
if (!ty) {
return nullptr;
}
}
for (auto* attribute : v->attributes) {
Mark(attribute);
bool ok = Switch(
attribute, //
[&](const ast::InternalAttribute* attr) -> bool { return InternalAttribute(attr); },
[&](Default) {
ErrorInvalidAttribute(attribute, "'let' declaration");
return false;
});
if (!ok) {
return nullptr;
}
}
if (!v->initializer) {
AddError("'let' declaration must have an initializer", v->source);
return nullptr;
}
auto* rhs = Load(Materialize(ValueExpression(v->initializer), ty));
if (!rhs) {
return nullptr;
}
// If the variable has no declared type, infer it from the RHS
if (!ty) {
ty = rhs->Type()->UnwrapRef(); // Implicit load of RHS
}
if (rhs && !validator_.VariableInitializer(v, ty, rhs)) {
return nullptr;
}
if (!ApplyAddressSpaceUsageToType(core::AddressSpace::kUndefined,
const_cast<core::type::Type*>(ty), v->source)) {
AddNote("while instantiating 'let' " + v->name->symbol.Name(), v->source);
return nullptr;
}
sem::Variable* sem = nullptr;
if (is_global) {
sem = builder_->create<sem::GlobalVariable>(
v, ty, core::EvaluationStage::kRuntime, core::AddressSpace::kUndefined,
core::Access::kUndefined,
/* constant_value */ nullptr, std::nullopt, std::nullopt);
} else {
sem = builder_->create<sem::LocalVariable>(v, ty, core::EvaluationStage::kRuntime,
core::AddressSpace::kUndefined,
core::Access::kUndefined, current_statement_,
/* constant_value */ nullptr);
}
sem->SetInitializer(rhs);
builder_->Sem().Add(v, sem);
return sem;
}
sem::Variable* Resolver::Override(const ast::Override* v) {
const core::type::Type* ty = nullptr;
// If the variable has a declared type, resolve it.
if (v->type) {
ty = Type(v->type);
if (!ty) {
return nullptr;
}
}
const sem::ValueExpression* rhs = nullptr;
// Does the variable have an initializer?
if (v->initializer) {
// Note: RHS must be a const or override expression, which excludes references.
// So there's no need to load or unwrap references here.
ExprEvalStageConstraint constraint{core::EvaluationStage::kOverride,
"override initializer"};
TINT_SCOPED_ASSIGNMENT(expr_eval_stage_constraint_, constraint);
rhs = Materialize(ValueExpression(v->initializer), ty);
if (!rhs) {
return nullptr;
}
// If the variable has no declared type, infer it from the RHS
if (!ty) {
ty = rhs->Type();
}
} else if (!ty) {
AddError("override declaration requires a type or initializer", v->source);
return nullptr;
}
if (rhs && !validator_.VariableInitializer(v, ty, rhs)) {
return nullptr;
}
if (!ApplyAddressSpaceUsageToType(core::AddressSpace::kUndefined,
const_cast<core::type::Type*>(ty), v->source)) {
AddNote("while instantiating 'override' " + v->name->symbol.Name(), v->source);
return nullptr;
}
auto* sem = builder_->create<sem::GlobalVariable>(
v, ty, core::EvaluationStage::kOverride, core::AddressSpace::kUndefined,
core::Access::kUndefined,
/* constant_value */ nullptr, std::nullopt, std::nullopt);
sem->SetInitializer(rhs);
for (auto* attribute : v->attributes) {
Mark(attribute);
bool ok = Switch(
attribute, //
[&](const ast::IdAttribute* attr) {
ExprEvalStageConstraint constraint{core::EvaluationStage::kConstant, "@id"};
TINT_SCOPED_ASSIGNMENT(expr_eval_stage_constraint_, constraint);
auto* materialized = Materialize(ValueExpression(attr->expr));
if (!materialized) {
return false;
}
if (!materialized->Type()->IsAnyOf<core::type::I32, core::type::U32>()) {
AddError("@id must be an i32 or u32 value", attr->source);
return false;
}
auto const_value = materialized->ConstantValue();
auto value = const_value->ValueAs<AInt>();
if (value < 0) {
AddError("@id value must be non-negative", attr->source);
return false;
}
if (value > std::numeric_limits<decltype(OverrideId::value)>::max()) {
AddError(
"@id value must be between 0 and " +
std::to_string(std::numeric_limits<decltype(OverrideId::value)>::max()),
attr->source);
return false;
}
auto o = OverrideId{static_cast<decltype(OverrideId::value)>(value)};
sem->SetOverrideId(o);
// Track the constant IDs that are specified in the shader.
override_ids_.Add(o, sem);
return true;
},
[&](Default) {
ErrorInvalidAttribute(attribute, "'override' declaration");
return false;
});
if (!ok) {
return nullptr;
}
}
builder_->Sem().Add(v, sem);
return sem;
}
sem::Variable* Resolver::Const(const ast::Const* c, bool is_global) {
const core::type::Type* ty = nullptr;
// If the variable has a declared type, resolve it.
if (c->type) {
ty = Type(c->type);
if (!ty) {
return nullptr;
}
}
if (!c->initializer) {
AddError("'const' declaration must have an initializer", c->source);
return nullptr;
}
for (auto* attribute : c->attributes) {
Mark(attribute);
bool ok = Switch(attribute, //
[&](Default) {
ErrorInvalidAttribute(attribute, "'const' declaration");
return false;
});
if (!ok) {
return nullptr;
}
}
const sem::ValueExpression* rhs = nullptr;
{
ExprEvalStageConstraint constraint{core::EvaluationStage::kConstant, "const initializer"};
TINT_SCOPED_ASSIGNMENT(expr_eval_stage_constraint_, constraint);
rhs = ValueExpression(c->initializer);
if (!rhs) {
return nullptr;
}
}
// Note: RHS must be a const expression, which excludes references.
// So there's no need to load or unwrap references here.
if (ty) {
// If an explicit type was specified, materialize to that type
rhs = Materialize(rhs, ty);
if (!rhs) {
return nullptr;
}
} else {
// If no type was specified, infer it from the RHS
ty = rhs->Type();
}
if (!validator_.VariableInitializer(c, ty, rhs)) {
return nullptr;
}
if (!ApplyAddressSpaceUsageToType(core::AddressSpace::kUndefined,
const_cast<core::type::Type*>(ty), c->source)) {
AddNote("while instantiating 'const' " + c->name->symbol.Name(), c->source);
return nullptr;
}
const auto value = rhs->ConstantValue();
auto* sem = is_global
? static_cast<sem::Variable*>(builder_->create<sem::GlobalVariable>(
c, ty, core::EvaluationStage::kConstant, core::AddressSpace::kUndefined,
core::Access::kUndefined, value, std::nullopt, std::nullopt))
: static_cast<sem::Variable*>(builder_->create<sem::LocalVariable>(
c, ty, core::EvaluationStage::kConstant, core::AddressSpace::kUndefined,
core::Access::kUndefined, current_statement_, value));
sem->SetInitializer(rhs);
builder_->Sem().Add(c, sem);
return sem;
}
sem::Variable* Resolver::Var(const ast::Var* var, bool is_global) {
const core::type::Type* storage_ty = nullptr;
// If the variable has a declared type, resolve it.
if (auto ty = var->type) {
storage_ty = Type(ty);
if (!storage_ty) {
return nullptr;
}
}
const sem::ValueExpression* rhs = nullptr;
// Does the variable have a initializer?
if (var->initializer) {
ExprEvalStageConstraint constraint{
is_global ? core::EvaluationStage::kOverride : core::EvaluationStage::kRuntime,
"var initializer",
};
TINT_SCOPED_ASSIGNMENT(expr_eval_stage_constraint_, constraint);
rhs = Load(Materialize(ValueExpression(var->initializer), storage_ty));
if (!rhs) {
return nullptr;
}
// If the variable has no declared type, infer it from the RHS
if (!storage_ty) {
storage_ty = rhs->Type();
}
}
if (!storage_ty) {
AddError("var declaration requires a type or initializer", var->source);
return nullptr;
}
auto address_space = core::AddressSpace::kUndefined;
if (var->declared_address_space) {
auto expr = AddressSpaceExpression(var->declared_address_space);
if (TINT_UNLIKELY(!expr)) {
return nullptr;
}
address_space = expr->Value();
} else {
// No declared address space. Infer from usage / type.
if (!is_global) {
address_space = core::AddressSpace::kFunction;
} else if (storage_ty->UnwrapRef()->is_handle()) {
// https://gpuweb.github.io/gpuweb/wgsl/#module-scope-variables
// If the store type is a texture type or a sampler type, then the
// variable declaration must not have a address space attribute. The
// address space will always be handle.
address_space = core::AddressSpace::kHandle;
}
}
if (!is_global && address_space != core::AddressSpace::kFunction &&
validator_.IsValidationEnabled(var->attributes,
ast::DisabledValidation::kIgnoreAddressSpace)) {
AddError("function-scope 'var' declaration must use 'function' address space", var->source);
return nullptr;
}
auto access = core::Access::kUndefined;
if (var->declared_access) {
auto expr = AccessExpression(var->declared_access);
if (!expr) {
return nullptr;
}
access = expr->Value();
} else {
access = DefaultAccessForAddressSpace(address_space);
}
if (rhs && !validator_.VariableInitializer(var, storage_ty, rhs)) {
return nullptr;
}
auto* var_ty = builder_->create<core::type::Reference>(address_space, storage_ty, access);
if (!ApplyAddressSpaceUsageToType(address_space, var_ty,
var->type ? var->type->source : var->source)) {
AddNote("while instantiating 'var' " + var->name->symbol.Name(), var->source);
return nullptr;
}
sem::Variable* sem = nullptr;
if (is_global) {
bool has_io_address_space =
address_space == core::AddressSpace::kIn || address_space == core::AddressSpace::kOut;
std::optional<uint32_t> group, binding, location, index;
for (auto* attribute : var->attributes) {
Mark(attribute);
enum Status { kSuccess, kErrored, kInvalid };
auto res = Switch(
attribute, //
[&](const ast::BindingAttribute* attr) {
auto value = BindingAttribute(attr);
if (!value) {
return kErrored;
}
binding = value.Get();
return kSuccess;
},
[&](const ast::GroupAttribute* attr) {
auto value = GroupAttribute(attr);
if (!value) {
return kErrored;
}
group = value.Get();
return kSuccess;
},
[&](const ast::LocationAttribute* attr) {
if (!has_io_address_space) {
return kInvalid;
}
auto value = LocationAttribute(attr);
if (!value) {
return kErrored;
}
location = value.Get();
return kSuccess;
},
[&](const ast::IndexAttribute* attr) {
if (!has_io_address_space) {
return kInvalid;
}
auto value = IndexAttribute(attr);
if (!value) {
return kErrored;
}
index = value.Get();
return kSuccess;
},
[&](const ast::BuiltinAttribute* attr) {
if (!has_io_address_space) {
return kInvalid;
}
return BuiltinAttribute(attr) ? kSuccess : kErrored;
},
[&](const ast::InterpolateAttribute* attr) {
if (!has_io_address_space) {
return kInvalid;
}
return InterpolateAttribute(attr) ? kSuccess : kErrored;
},
[&](const ast::InvariantAttribute* attr) {
if (!has_io_address_space) {
return kInvalid;
}
return InvariantAttribute(attr) ? kSuccess : kErrored;
},
[&](const ast::InternalAttribute* attr) {
return InternalAttribute(attr) ? kSuccess : kErrored;
},
[&](Default) { return kInvalid; });
switch (res) {
case kSuccess:
break;
case kErrored:
return nullptr;
case kInvalid:
ErrorInvalidAttribute(attribute, "module-scope 'var'");
return nullptr;
}
}
std::optional<BindingPoint> binding_point;
if (group && binding) {
binding_point = BindingPoint{group.value(), binding.value()};
}
sem = builder_->create<sem::GlobalVariable>(
var, var_ty, core::EvaluationStage::kRuntime, address_space, access,
/* constant_value */ nullptr, binding_point, location, index);
} else {
for (auto* attribute : var->attributes) {
Mark(attribute);
bool ok = Switch(
attribute,
[&](const ast::InternalAttribute* attr) { return InternalAttribute(attr); },
[&](Default) {
ErrorInvalidAttribute(attribute, "function-scope 'var'");
return false;
});
if (!ok) {
return nullptr;
}
}
sem = builder_->create<sem::LocalVariable>(var, var_ty, core::EvaluationStage::kRuntime,
address_space, access, current_statement_,
/* constant_value */ nullptr);
}
sem->SetInitializer(rhs);
builder_->Sem().Add(var, sem);
return sem;
}
sem::Parameter* Resolver::Parameter(const ast::Parameter* param,
const ast::Function* func,
uint32_t index) {
Mark(param->name);
auto add_note = [&] {
AddNote("while instantiating parameter " + param->name->symbol.Name(), param->source);
};
std::optional<uint32_t> location, group, binding;
if (func->IsEntryPoint()) {
for (auto* attribute : param->attributes) {
Mark(attribute);
bool ok = Switch(
attribute, //
[&](const ast::LocationAttribute* attr) {
auto value = LocationAttribute(attr);
if (!value) {
return false;
}
location = value.Get();
return true;
},
[&](const ast::BuiltinAttribute* attr) -> bool { return BuiltinAttribute(attr); },
[&](const ast::InvariantAttribute* attr) -> bool {
return InvariantAttribute(attr);
},
[&](const ast::InterpolateAttribute* attr) -> bool {
return InterpolateAttribute(attr);
},
[&](const ast::InternalAttribute* attr) -> bool { return InternalAttribute(attr); },
[&](const ast::GroupAttribute* attr) -> bool {
if (validator_.IsValidationEnabled(
param->attributes, ast::DisabledValidation::kEntryPointParameter)) {
ErrorInvalidAttribute(attribute, "function parameters");
return false;
}
auto value = GroupAttribute(attr);
if (!value) {
return false;
}
group = value.Get();
return true;
},
[&](const ast::BindingAttribute* attr) -> bool {
if (validator_.IsValidationEnabled(
param->attributes, ast::DisabledValidation::kEntryPointParameter)) {
ErrorInvalidAttribute(attribute, "function parameters");
return false;
}
auto value = BindingAttribute(attr);
if (!value) {
return false;
}
binding = value.Get();
return true;
},
[&](Default) {
ErrorInvalidAttribute(attribute, "function parameters");
return false;
});
if (!ok) {
return nullptr;
}
}
} else {
for (auto* attribute : param->attributes) {
Mark(attribute);
bool ok = Switch(
attribute, //
[&](const ast::InternalAttribute* attr) -> bool { return InternalAttribute(attr); },
[&](Default) {
if (attribute->IsAnyOf<ast::LocationAttribute, ast::BuiltinAttribute,
ast::InvariantAttribute, ast::InterpolateAttribute>()) {
ErrorInvalidAttribute(attribute, "non-entry point function parameters");
} else {
ErrorInvalidAttribute(attribute, "function parameters");
}
return false;
});
if (!ok) {
return nullptr;
}
}
}
if (!validator_.NoDuplicateAttributes(param->attributes)) {
return nullptr;
}
core::type::Type* ty = Type(param->type);
if (!ty) {
return nullptr;
}
if (!ApplyAddressSpaceUsageToType(core::AddressSpace::kUndefined, ty, param->type->source)) {
add_note();
return nullptr;
}
if (auto* ptr = ty->As<core::type::Pointer>()) {
// For MSL, we push module-scope variables into the entry point as pointer
// parameters, so we also need to handle their store type.
if (!ApplyAddressSpaceUsageToType(ptr->AddressSpace(),
const_cast<core::type::Type*>(ptr->StoreType()),
param->source)) {
add_note();
return nullptr;
}
}
std::optional<BindingPoint> binding_point;
if (group && binding) {
binding_point = BindingPoint{group.value(), binding.value()};
}
auto* sem = builder_->create<sem::Parameter>(
param, index, ty, core::AddressSpace::kUndefined, core::Access::kUndefined,
core::ParameterUsage::kNone, binding_point, location);
builder_->Sem().Add(param, sem);
if (!validator_.Parameter(sem)) {
return nullptr;
}
return sem;
}
core::Access Resolver::DefaultAccessForAddressSpace(core::AddressSpace address_space) {
// https://gpuweb.github.io/gpuweb/wgsl/#storage-class
switch (address_space) {
case core::AddressSpace::kStorage:
case core::AddressSpace::kUniform:
case core::AddressSpace::kHandle:
return core::Access::kRead;
default:
break;
}
return core::Access::kReadWrite;
}
bool Resolver::AllocateOverridableConstantIds() {
constexpr size_t kLimit = std::numeric_limits<decltype(OverrideId::value)>::max();
// The next pipeline constant ID to try to allocate.
OverrideId next_id;
bool ids_exhausted = false;
auto increment_next_id = [&] {
if (next_id.value == kLimit) {
ids_exhausted = true;
} else {
next_id.value = next_id.value + 1;
}
};
// Allocate constant IDs in global declaration order, so that they are
// deterministic.
// TODO(crbug.com/tint/1192): If a transform changes the order or removes an
// unused constant, the allocation may change on the next Resolver pass.
for (auto* decl : builder_->AST().GlobalDeclarations()) {
auto* override = decl->As<ast::Override>();
if (!override) {
continue;
}
auto* sem = sem_.Get(override);
OverrideId id;
if (ast::HasAttribute<ast::IdAttribute>(override->attributes)) {
id = sem->OverrideId();
} else {
// No ID was specified, so allocate the next available ID.
while (!ids_exhausted && override_ids_.Contains(next_id)) {
increment_next_id();
}
if (ids_exhausted) {
AddError(
"number of 'override' variables exceeded limit of " + std::to_string(kLimit),
decl->source);
return false;
}
id = next_id;
increment_next_id();
}
const_cast<sem::GlobalVariable*>(sem)->SetOverrideId(id);
}
return true;
}
void Resolver::SetShadows() {
for (auto it : dependencies_.shadows) {
CastableBase* b = sem_.Get(it.value);
if (TINT_UNLIKELY(!b)) {
StringStream err;
err << "AST node '" << it.value->TypeInfo().name << "' had no semantic info\n"
<< "Pointer: " << it.value;
AddICE(err.str(), it.value->source);
}
Switch(
sem_.Get(it.key), //
[&](sem::LocalVariable* local) { local->SetShadows(b); },
[&](sem::Parameter* param) { param->SetShadows(b); });
}
}
sem::GlobalVariable* Resolver::GlobalVariable(const ast::Variable* v) {
UniqueVector<const sem::GlobalVariable*, 4> transitively_referenced_overrides;
TINT_SCOPED_ASSIGNMENT(resolved_overrides_, &transitively_referenced_overrides);
auto* sem = As<sem::GlobalVariable>(Variable(v, /* is_global */ true));
if (!sem) {
return nullptr;
}
if (!validator_.NoDuplicateAttributes(v->attributes)) {
return nullptr;
}
if (!validator_.GlobalVariable(sem, override_ids_)) {
return nullptr;
}
// Track the pipeline-overridable constants that are transitively referenced by this
// variable.
for (auto* var : transitively_referenced_overrides) {
builder_->Sem().AddTransitivelyReferencedOverride(sem, var);
}
if (auto* arr = sem->Type()->UnwrapRef()->As<core::type::Array>()) {
auto* refs = builder_->Sem().TransitivelyReferencedOverrides(arr);
if (refs) {
for (auto* var : *refs) {
builder_->Sem().AddTransitivelyReferencedOverride(sem, var);
}
}
}
return sem;
}
sem::Statement* Resolver::ConstAssert(const ast::ConstAssert* assertion) {
ExprEvalStageConstraint constraint{core::EvaluationStage::kConstant, "const assertion"};
TINT_SCOPED_ASSIGNMENT(expr_eval_stage_constraint_, constraint);
auto* expr = ValueExpression(assertion->condition);
if (!expr) {
return nullptr;
}
auto* cond = expr->ConstantValue();
if (auto* ty = cond->Type(); !ty->Is<core::type::Bool>()) {
AddError("const assertion condition must be a bool, got '" + ty->FriendlyName() + "'",
assertion->condition->source);
return nullptr;
}
if (!cond->ValueAs<bool>()) {
AddError("const assertion failed", assertion->source);
return nullptr;
}
auto* sem =
builder_->create<sem::Statement>(assertion, current_compound_statement_, current_function_);
builder_->Sem().Add(assertion, sem);
return sem;
}
sem::Function* Resolver::Function(const ast::Function* decl) {
Mark(decl->name);
auto* func = builder_->create<sem::Function>(decl);
builder_->Sem().Add(decl, func);
TINT_SCOPED_ASSIGNMENT(current_function_, func);
validator_.DiagnosticFilters().Push();
TINT_DEFER(validator_.DiagnosticFilters().Pop());
for (auto* attribute : decl->attributes) {
Mark(attribute);
bool ok = Switch(
attribute,
[&](const ast::DiagnosticAttribute* attr) { return DiagnosticAttribute(attr); },
[&](const ast::StageAttribute* attr) { return StageAttribute(attr); },
[&](const ast::MustUseAttribute* attr) { return MustUseAttribute(attr); },
[&](const ast::WorkgroupAttribute* attr) {
auto value = WorkgroupAttribute(attr);
if (!value) {
return false;
}
func->SetWorkgroupSize(value.Get());
return true;
},
[&](const ast::InternalAttribute* attr) { return InternalAttribute(attr); },
[&](Default) {
ErrorInvalidAttribute(attribute, "functions");
return false;
});
if (!ok) {
return nullptr;
}
}
if (!validator_.NoDuplicateAttributes(decl->attributes)) {
return nullptr;
}
// Resolve all the parameters
uint32_t parameter_index = 0;
Hashmap<Symbol, Source, 8> parameter_names;
for (auto* param : decl->params) {
Mark(param);
{ // Check the parameter name is unique for the function
if (auto added = parameter_names.Add(param->name->symbol, param->source); !added) {
auto name = param->name->symbol.Name();
AddError("redefinition of parameter '" + name + "'", param->source);
AddNote("previous definition is here", *added.value);
return nullptr;
}
}
auto* p = Parameter(param, decl, parameter_index++);
if (!p) {
return nullptr;
}
func->AddParameter(p);
auto* p_ty = const_cast<core::type::Type*>(p->Type());
if (auto* str = p_ty->As<core::type::Struct>()) {
switch (decl->PipelineStage()) {
case ast::PipelineStage::kVertex:
str->AddUsage(core::type::PipelineStageUsage::kVertexInput);
break;
case ast::PipelineStage::kFragment:
str->AddUsage(core::type::PipelineStageUsage::kFragmentInput);
break;
case ast::PipelineStage::kCompute:
str->AddUsage(core::type::PipelineStageUsage::kComputeInput);
break;
case ast::PipelineStage::kNone:
break;
}
}
}
// Resolve the return type
core::type::Type* return_type = nullptr;
if (auto ty = decl->return_type) {
return_type = Type(ty);
if (!return_type) {
return nullptr;
}
} else {
return_type = builder_->create<core::type::Void>();
}
func->SetReturnType(return_type);
if (decl->IsEntryPoint()) {
// Determine if the return type has a location
bool permissive = validator_.IsValidationDisabled(
decl->attributes, ast::DisabledValidation::kEntryPointParameter) ||
validator_.IsValidationDisabled(
decl->attributes, ast::DisabledValidation::kFunctionParameter);
for (auto* attribute : decl->return_type_attributes) {
Mark(attribute);
enum Status { kSuccess, kErrored, kInvalid };
auto res = Switch(
attribute, //
[&](const ast::LocationAttribute* attr) {
auto value = LocationAttribute(attr);
if (!value) {
return kErrored;
}
func->SetReturnLocation(value.Get());
return kSuccess;
},
[&](const ast::IndexAttribute* attr) {
auto value = IndexAttribute(attr);
if (!value) {
return kErrored;
}
func->SetReturnIndex(value.Get());
return kSuccess;
},
[&](const ast::BuiltinAttribute* attr) {
return BuiltinAttribute(attr) ? kSuccess : kErrored;
},
[&](const ast::InternalAttribute* attr) {
return InternalAttribute(attr) ? kSuccess : kErrored;
},
[&](const ast::InterpolateAttribute* attr) {
return InterpolateAttribute(attr) ? kSuccess : kErrored;
},
[&](const ast::InvariantAttribute* attr) {
return InvariantAttribute(attr) ? kSuccess : kErrored;
},
[&](const ast::BindingAttribute* attr) {
if (!permissive) {
return kInvalid;
}
return BindingAttribute(attr) ? kSuccess : kErrored;
},
[&](const ast::GroupAttribute* attr) {
if (!permissive) {
return kInvalid;
}
return GroupAttribute(attr) ? kSuccess : kErrored;
},
[&](Default) { return kInvalid; });
switch (res) {
case kSuccess:
break;
case kErrored:
return nullptr;
case kInvalid:
ErrorInvalidAttribute(attribute, "entry point return types");
return nullptr;
}
}
} else {
for (auto* attribute : decl->return_type_attributes) {
Mark(attribute);
bool ok = Switch(attribute, //
[&](Default) {
ErrorInvalidAttribute(attribute,
"non-entry point function return types");
return false;
});
if (!ok) {
return nullptr;
}
}
}
if (auto* str = return_type->As<core::type::Struct>()) {
if (!ApplyAddressSpaceUsageToType(core::AddressSpace::kUndefined, str, decl->source)) {
AddNote("while instantiating return type for " + decl->name->symbol.Name(),
decl->source);
return nullptr;
}
switch (decl->PipelineStage()) {
case ast::PipelineStage::kVertex:
str->AddUsage(core::type::PipelineStageUsage::kVertexOutput);
break;
case ast::PipelineStage::kFragment:
str->AddUsage(core::type::PipelineStageUsage::kFragmentOutput);
break;
case ast::PipelineStage::kCompute:
str->AddUsage(core::type::PipelineStageUsage::kComputeOutput);
break;
case ast::PipelineStage::kNone:
break;
}
}
ApplyDiagnosticSeverities(func);
if (decl->IsEntryPoint()) {
entry_points_.Push(func);
}
if (decl->body) {
Mark(decl->body);
if (TINT_UNLIKELY(current_compound_statement_)) {
StringStream err;
err << "Resolver::Function() called with a current compound statement";
AddICE(err.str(), decl->body->source);
return nullptr;
}
auto* body = StatementScope(decl->body, builder_->create<sem::FunctionBlockStatement>(func),
[&] { return Statements(decl->body->statements); });
if (!body) {
return nullptr;
}
func->Behaviors() = body->Behaviors();
if (func->Behaviors().Contains(sem::Behavior::kReturn)) {
// https://www.w3.org/TR/WGSL/#behaviors-rules
// We assign a behavior to each function: it is its body’s behavior
// (treating the body as a regular statement), with any "Return" replaced
// by "Next".
func->Behaviors().Remove(sem::Behavior::kReturn);
func->Behaviors().Add(sem::Behavior::kNext);
}
}
if (!validator_.NoDuplicateAttributes(decl->return_type_attributes)) {
return nullptr;
}
auto stage = current_function_ ? current_function_->Declaration()->PipelineStage()
: ast::PipelineStage::kNone;
if (!validator_.Function(func, stage)) {
return nullptr;
}
// If this is an entry point, mark all transitively called functions as being
// used by this entry point.
if (decl->IsEntryPoint()) {
for (auto* f : func->TransitivelyCalledFunctions()) {
const_cast<sem::Function*>(f)->AddAncestorEntryPoint(func);
}
}
return func;
}
bool Resolver::Statements(VectorRef<const ast::Statement*> stmts) {
sem::Behaviors behaviors{sem::Behavior::kNext};
bool reachable = true;
for (auto* stmt : stmts) {
Mark(stmt);
auto* sem = Statement(stmt);
if (!sem) {
return false;
}
// s1 s2:(B1∖{Next}) ∪ B2
sem->SetIsReachable(reachable);
if (reachable) {
behaviors = (behaviors - sem::Behavior::kNext) + sem->Behaviors();
}
reachable = reachable && sem->Behaviors().Contains(sem::Behavior::kNext);
}
current_statement_->Behaviors() = behaviors;
if (!validator_.Statements(stmts)) {
return false;
}
return true;
}
sem::Statement* Resolver::Statement(const ast::Statement* stmt) {
return Switch(
stmt,
// Compound statements. These create their own sem::CompoundStatement
// bindings.
[&](const ast::BlockStatement* b) { return BlockStatement(b); },
[&](const ast::ForLoopStatement* l) { return ForLoopStatement(l); },
[&](const ast::LoopStatement* l) { return LoopStatement(l); },
[&](const ast::WhileStatement* w) { return WhileStatement(w); },
[&](const ast::IfStatement* i) { return IfStatement(i); },
[&](const ast::SwitchStatement* s) { return SwitchStatement(s); },
// Non-Compound statements
[&](const ast::AssignmentStatement* a) { return AssignmentStatement(a); },
[&](const ast::BreakStatement* b) { return BreakStatement(b); },
[&](const ast::BreakIfStatement* b) { return BreakIfStatement(b); },
[&](const ast::CallStatement* c) { return CallStatement(c); },
[&](const ast::CompoundAssignmentStatement* c) { return CompoundAssignmentStatement(c); },
[&](const ast::ContinueStatement* c) { return ContinueStatement(c); },
[&](const ast::DiscardStatement* d) { return DiscardStatement(d); },
[&](const ast::IncrementDecrementStatement* i) { return IncrementDecrementStatement(i); },
[&](const ast::ReturnStatement* r) { return ReturnStatement(r); },
[&](const ast::VariableDeclStatement* v) { return VariableDeclStatement(v); },
[&](const ast::ConstAssert* sa) { return ConstAssert(sa); },
// Error cases
[&](const ast::CaseStatement*) {
AddError("case statement can only be used inside a switch statement", stmt->source);
return nullptr;
},
[&](Default) {
AddError("unknown statement type: " + std::string(stmt->TypeInfo().name), stmt->source);
return nullptr;
});
}
sem::CaseStatement* Resolver::CaseStatement(const ast::CaseStatement* stmt,
const core::type::Type* ty) {
auto* sem =
builder_->create<sem::CaseStatement>(stmt, current_compound_statement_, current_function_);
return StatementScope(stmt, sem, [&] {
sem->Selectors().reserve(stmt->selectors.Length());
for (auto* sel : stmt->selectors) {
Mark(sel);
ExprEvalStageConstraint constraint{core::EvaluationStage::kConstant, "case selector"};
TINT_SCOPED_ASSIGNMENT(expr_eval_stage_constraint_, constraint);
const core::constant::Value* const_value = nullptr;
if (!sel->IsDefault()) {
// The sem statement was created in the switch when attempting to determine the
// common type.
auto* materialized = Materialize(sem_.GetVal(sel->expr), ty);
if (!materialized) {
return false;
}
if (!materialized->Type()->IsAnyOf<core::type::I32, core::type::U32>()) {
AddError("case selector must be an i32 or u32 value", sel->source);
return false;
}
const_value = materialized->ConstantValue();
if (!const_value) {
AddError("case selector must be a constant expression", sel->source);
return false;
}
}
sem->Selectors().emplace_back(builder_->create<sem::CaseSelector>(sel, const_value));
}
Mark(stmt->body);
auto* body = BlockStatement(stmt->body);
if (!body) {
return false;
}
sem->SetBlock(body);
sem->Behaviors() = body->Behaviors();
return true;
});
}
sem::IfStatement* Resolver::IfStatement(const ast::IfStatement* stmt) {
auto* sem =
builder_->create<sem::IfStatement>(stmt, current_compound_statement_, current_function_);
return StatementScope(stmt, sem, [&] {
auto* cond = Load(ValueExpression(stmt->condition));
if (!cond) {
return false;
}
sem->SetCondition(cond);
sem->Behaviors() = cond->Behaviors();
sem->Behaviors().Remove(sem::Behavior::kNext);
Mark(stmt->body);
auto* body = builder_->create<sem::BlockStatement>(stmt->body, current_compound_statement_,
current_function_);
if (!StatementScope(stmt->body, body, [&] { return Statements(stmt->body->statements); })) {
return false;
}
sem->Behaviors().Add(body->Behaviors());
if (stmt->else_statement) {
Mark(stmt->else_statement);
auto* else_sem = Statement(stmt->else_statement);
if (!else_sem) {
return false;
}
sem->Behaviors().Add(else_sem->Behaviors());
} else {
// https://www.w3.org/TR/WGSL/#behaviors-rules
// if statements without an else branch are treated as if they had an
// empty else branch (which adds Next to their behavior)
sem->Behaviors().Add(sem::Behavior::kNext);
}
return validator_.IfStatement(sem);
});
}
sem::BlockStatement* Resolver::BlockStatement(const ast::BlockStatement* stmt) {
auto* sem = builder_->create<sem::BlockStatement>(
stmt->As<ast::BlockStatement>(), current_compound_statement_, current_function_);
return StatementScope(stmt, sem, [&] { return Statements(stmt->statements); });
}
sem::LoopStatement* Resolver::LoopStatement(const ast::LoopStatement* stmt) {
auto* sem =
builder_->create<sem::LoopStatement>(stmt, current_compound_statement_, current_function_);
return StatementScope(stmt, sem, [&] {
Mark(stmt->body);
auto* body = builder_->create<sem::LoopBlockStatement>(
stmt->body, current_compound_statement_, current_function_);
return StatementScope(stmt->body, body, [&] {
if (!Statements(stmt->body->statements)) {
return false;
}
auto& behaviors = sem->Behaviors();
behaviors = body->Behaviors();
if (stmt->continuing) {
Mark(stmt->continuing);
auto* continuing = StatementScope(
stmt->continuing,
builder_->create<sem::LoopContinuingBlockStatement>(
stmt->continuing, current_compound_statement_, current_function_),
[&] { return Statements(stmt->continuing->statements); });
if (!continuing) {
return false;
}
behaviors.Add(continuing->Behaviors());
}
if (behaviors.Contains(sem::Behavior::kBreak)) { // Does the loop exit?
behaviors.Add(sem::Behavior::kNext);
} else {
behaviors.Remove(sem::Behavior::kNext);
}
behaviors.Remove(sem::Behavior::kBreak, sem::Behavior::kContinue);
return validator_.LoopStatement(sem);
});
});
}
sem::ForLoopStatement* Resolver::ForLoopStatement(const ast::ForLoopStatement* stmt) {
auto* sem = builder_->create<sem::ForLoopStatement>(stmt, current_compound_statement_,
current_function_);
return StatementScope(stmt, sem, [&] {
auto& behaviors = sem->Behaviors();
if (auto* initializer = stmt->initializer) {
Mark(initializer);
auto* init = Statement(initializer);
if (!init) {
return false;
}
behaviors.Add(init->Behaviors());
}
if (auto* cond_expr = stmt->condition) {
auto* cond = Load(ValueExpression(cond_expr));
if (!cond) {
return false;
}
sem->SetCondition(cond);
behaviors.Add(cond->Behaviors());
}
if (auto* continuing = stmt->continuing) {
Mark(continuing);
auto* cont = Statement(continuing);
if (!cont) {
return false;
}
behaviors.Add(cont->Behaviors());
}
Mark(stmt->body);
auto* body = builder_->create<sem::LoopBlockStatement>(
stmt->body, current_compound_statement_, current_function_);
if (!StatementScope(stmt->body, body, [&] { return Statements(stmt->body->statements); })) {
return false;
}
behaviors.Add(body->Behaviors());
if (stmt->condition || behaviors.Contains(sem::Behavior::kBreak)) { // Does the loop exit?
behaviors.Add(sem::Behavior::kNext);
} else {
behaviors.Remove(sem::Behavior::kNext);
}
behaviors.Remove(sem::Behavior::kBreak, sem::Behavior::kContinue);
return validator_.ForLoopStatement(sem);
});
}
sem::WhileStatement* Resolver::WhileStatement(const ast::WhileStatement* stmt) {
auto* sem =
builder_->create<sem::WhileStatement>(stmt, current_compound_statement_, current_function_);
return StatementScope(stmt, sem, [&] {
auto& behaviors = sem->Behaviors();
auto* cond = Load(ValueExpression(stmt->condition));
if (!cond) {
return false;
}
sem->SetCondition(cond);
behaviors.Add(cond->Behaviors());
Mark(stmt->body);
auto* body = builder_->create<sem::LoopBlockStatement>(
stmt->body, current_compound_statement_, current_function_);
if (!StatementScope(stmt->body, body, [&] { return Statements(stmt->body->statements); })) {
return false;
}
behaviors.Add(body->Behaviors());
// Always consider the while as having a 'next' behaviour because it has
// a condition. We don't check if the condition will terminate but it isn't
// valid to have an infinite loop in a WGSL program, so a non-terminating
// condition is already an invalid program.
behaviors.Add(sem::Behavior::kNext);
behaviors.Remove(sem::Behavior::kBreak, sem::Behavior::kContinue);
return validator_.WhileStatement(sem);
});
}
sem::Expression* Resolver::Expression(const ast::Expression* root) {
Vector<const ast::Expression*, 64> sorted;
constexpr size_t kMaxExpressionDepth = 512U;
bool failed = false;
if (!ast::TraverseExpressions<ast::TraverseOrder::RightToLeft>(
root, [&](const ast::Expression* expr, size_t depth) {
if (depth > kMaxExpressionDepth) {
AddError(
"reached max expression depth of " + std::to_string(kMaxExpressionDepth),
expr->source);
failed = true;
return ast::TraverseAction::Stop;
}
if (!Mark(expr)) {
failed = true;
return ast::TraverseAction::Stop;
}
if (auto* binary = expr->As<ast::BinaryExpression>();
binary && binary->IsLogical()) {
// Store potential const-eval short-circuit pair
logical_binary_lhs_to_parent_.Add(binary->lhs, binary);
}
sorted.Push(expr);
return ast::TraverseAction::Descend;
})) {
AddError("TraverseExpressions failed", root->source);
return nullptr;
}
if (failed) {
return nullptr;
}
for (auto* expr : tint::Reverse(sorted)) {
auto* sem_expr = Switch(
expr, //
[&](const ast::IndexAccessorExpression* array) { return IndexAccessor(array); },
[&](const ast::BinaryExpression* bin_op) { return Binary(bin_op); },
[&](const ast::BitcastExpression* bitcast) { return Bitcast(bitcast); },
[&](const ast::CallExpression* call) { return Call(call); },
[&](const ast::IdentifierExpression* ident) { return Identifier(ident); },
[&](const ast::LiteralExpression* literal) { return Literal(literal); },
[&](const ast::MemberAccessorExpression* member) { return MemberAccessor(member); },
[&](const ast::UnaryOpExpression* unary) { return UnaryOp(unary); },
[&](const ast::PhonyExpression*) {
return builder_->create<sem::ValueExpression>(
expr, builder_->create<core::type::Void>(), core::EvaluationStage::kRuntime,
current_statement_,
/* constant_value */ nullptr,
/* has_side_effects */ false);
},
[&](Default) {
StringStream err;
err << "unhandled expression type: " << expr->TypeInfo().name;
AddICE(err.str(), expr->source);
return nullptr;
});
if (!sem_expr) {
return nullptr;
}
auto* val = sem_expr->As<sem::ValueExpression>();
if (val) {
if (auto* constraint = expr_eval_stage_constraint_.constraint) {
if (!validator_.EvaluationStage(val, expr_eval_stage_constraint_.stage,
constraint)) {
return nullptr;
}
}
}
builder_->Sem().Add(expr, sem_expr);
if (expr == root) {
return sem_expr;
}
// If we just processed the lhs of a constexpr logical binary expression, mark the rhs for
// short-circuiting.
if (val && val->ConstantValue()) {
if (auto binary = logical_binary_lhs_to_parent_.Find(expr)) {
const bool lhs_is_true = val->ConstantValue()->ValueAs<bool>();
if (((*binary)->IsLogicalAnd() && !lhs_is_true) ||
((*binary)->IsLogicalOr() && lhs_is_true)) {
// Mark entire expression tree to not const-evaluate
auto r = ast::TraverseExpressions( //
(*binary)->rhs, [&](const ast::Expression* e) {
skip_const_eval_.Add(e);
return ast::TraverseAction::Descend;
});
if (!r) {
AddError("TraverseExpressions failed", root->source);
return nullptr;
}
}
}
}
}
AddICE("Expression() did not find root node", root->source);
return nullptr;
}
sem::ValueExpression* Resolver::ValueExpression(const ast::Expression* expr) {
return sem_.AsValueExpression(Expression(expr));
}
sem::TypeExpression* Resolver::TypeExpression(const ast::Expression* expr) {
identifier_resolve_hint_ = {expr, "type"};
return sem_.AsTypeExpression(Expression(expr));
}
sem::FunctionExpression* Resolver::FunctionExpression(const ast::Expression* expr) {
identifier_resolve_hint_ = {expr, "call target"};
return sem_.AsFunctionExpression(Expression(expr));
}
core::type::Type* Resolver::Type(const ast::Expression* ast) {
auto* type_expr = TypeExpression(ast);
if (!type_expr) {
return nullptr;
}
return const_cast<core::type::Type*>(type_expr->Type());
}
sem::BuiltinEnumExpression<core::AddressSpace>* Resolver::AddressSpaceExpression(
const ast::Expression* expr) {
identifier_resolve_hint_ = {expr, "address space", core::kAddressSpaceStrings};
auto address_space_expr = sem_.AsAddressSpace(Expression(expr));
if (TINT_UNLIKELY(!address_space_expr)) {
return nullptr;
}
if (TINT_UNLIKELY(
address_space_expr->Value() == core::AddressSpace::kPixelLocal &&
!enabled_extensions_.Contains(wgsl::Extension::kChromiumExperimentalPixelLocal))) {
StringStream err;
err << "'pixel_local' address space requires the '"
<< wgsl::Extension::kChromiumExperimentalPixelLocal << "' extension enabled";
AddError(err.str(), expr->source);
return nullptr;
}
return address_space_expr;
}
sem::BuiltinEnumExpression<core::BuiltinValue>* Resolver::BuiltinValueExpression(
const ast::Expression* expr) {
identifier_resolve_hint_ = {expr, "builtin value", core::kBuiltinValueStrings};
return sem_.AsBuiltinValue(Expression(expr));
}
sem::BuiltinEnumExpression<core::TexelFormat>* Resolver::TexelFormatExpression(
const ast::Expression* expr) {
identifier_resolve_hint_ = {expr, "texel format", core::kTexelFormatStrings};
return sem_.AsTexelFormat(Expression(expr));
}
sem::BuiltinEnumExpression<core::Access>* Resolver::AccessExpression(const ast::Expression* expr) {
identifier_resolve_hint_ = {expr, "access", core::kAccessStrings};
return sem_.AsAccess(Expression(expr));
}
sem::BuiltinEnumExpression<core::InterpolationSampling>* Resolver::InterpolationSampling(
const ast::Expression* expr) {
identifier_resolve_hint_ = {expr, "interpolation sampling",
core::kInterpolationSamplingStrings};
return sem_.AsInterpolationSampling(Expression(expr));
}
sem::BuiltinEnumExpression<core::InterpolationType>* Resolver::InterpolationType(
const ast::Expression* expr) {
identifier_resolve_hint_ = {expr, "interpolation type", core::kInterpolationTypeStrings};
return sem_.AsInterpolationType(Expression(expr));
}
void Resolver::RegisterStore(const sem::ValueExpression* expr) {
auto& info = alias_analysis_infos_[current_function_];
Switch(
expr->RootIdentifier(),
[&](const sem::GlobalVariable* global) {
info.module_scope_writes.insert({global, expr});
},
[&](const sem::Parameter* param) { info.parameter_writes.insert(param); });
}
bool Resolver::AliasAnalysis(const sem::Call* call) {
auto* target = call->Target()->As<sem::Function>();
if (!target) {
return true;
}
if (validator_.IsValidationDisabled(target->Declaration()->attributes,
ast::DisabledValidation::kIgnorePointerAliasing)) {
return true;
}
// Helper to generate an aliasing error diagnostic.
struct Alias {
const sem::ValueExpression* expr; // the "other expression"
enum { Argument, ModuleScope } type; // the type of the "other" expression
std::string access; // the access performed for the "other" expression
};
auto make_error = [&](const sem::ValueExpression* arg, Alias&& var) {
AddError("invalid aliased pointer argument", arg->Declaration()->source);
switch (var.type) {
case Alias::Argument:
AddNote("aliases with another argument passed here",
var.expr->Declaration()->source);
break;
case Alias::ModuleScope: {
auto* func = var.expr->Stmt()->Function();
auto func_name = func->Declaration()->name->symbol.Name();
AddNote(
"aliases with module-scope variable " + var.access + " in '" + func_name + "'",
var.expr->Declaration()->source);
break;
}
}
return false;
};
auto& args = call->Arguments();
auto& target_info = alias_analysis_infos_[target];
auto& caller_info = alias_analysis_infos_[current_function_];
// Track the set of root identifiers that are read and written by arguments passed in this
// call.
std::unordered_map<const sem::Variable*, const sem::ValueExpression*> arg_reads;
std::unordered_map<const sem::Variable*, const sem::ValueExpression*> arg_writes;
for (size_t i = 0; i < args.Length(); i++) {
auto* arg = args[i];
if (!arg->Type()->Is<core::type::Pointer>()) {
continue;
}
auto* root = arg->RootIdentifier();
if (target_info.parameter_writes.count(target->Parameters()[i])) {
// Arguments that are written to can alias with any other argument or module-scope
// variable access.
if (arg_writes.count(root)) {
return make_error(arg, {arg_writes.at(root), Alias::Argument, "write"});
}
if (arg_reads.count(root)) {
return make_error(arg, {arg_reads.at(root), Alias::Argument, "read"});
}
if (target_info.module_scope_reads.count(root)) {
return make_error(
arg, {target_info.module_scope_reads.at(root), Alias::ModuleScope, "read"});
}
if (target_info.module_scope_writes.count(root)) {
return make_error(
arg, {target_info.module_scope_writes.at(root), Alias::ModuleScope, "write"});
}
arg_writes.insert({root, arg});
// Propagate the write access to the caller.
Switch(
root,
[&](const sem::GlobalVariable* global) {
caller_info.module_scope_writes.insert({global, arg});
},
[&](const sem::Parameter* param) { caller_info.parameter_writes.insert(param); });
} else if (target_info.parameter_reads.count(target->Parameters()[i])) {
// Arguments that are read from can alias with arguments or module-scope variables
// that are written to.
if (arg_writes.count(root)) {
return make_error(arg, {arg_writes.at(root), Alias::Argument, "write"});
}
if (target_info.module_scope_writes.count(root)) {
return make_error(
arg, {target_info.module_scope_writes.at(root), Alias::ModuleScope, "write"});
}
arg_reads.insert({root, arg});
// Propagate the read access to the caller.
Switch(
root,
[&](const sem::GlobalVariable* global) {
caller_info.module_scope_reads.insert({global, arg});
},
[&](const sem::Parameter* param) { caller_info.parameter_reads.insert(param); });
}
}
// Propagate module-scope variable uses to the caller.
for (auto read : target_info.module_scope_reads) {
caller_info.module_scope_reads.insert({read.first, read.second});
}
for (auto write : target_info.module_scope_writes) {
caller_info.module_scope_writes.insert({write.first, write.second});
}
return true;
}
const core::type::Type* Resolver::ConcreteType(const core::type::Type* ty,
const core::type::Type* target_ty,
const Source& source) {
auto i32 = [&] { return builder_->create<core::type::I32>(); };
auto f32 = [&] { return builder_->create<core::type::F32>(); };
auto i32v = [&](uint32_t width) { return builder_->create<core::type::Vector>(i32(), width); };
auto f32v = [&](uint32_t width) { return builder_->create<core::type::Vector>(f32(), width); };
auto f32m = [&](uint32_t columns, uint32_t rows) {
return builder_->create<core::type::Matrix>(f32v(rows), columns);
};
return Switch(
ty, //
[&](const core::type::AbstractInt*) { return target_ty ? target_ty : i32(); },
[&](const core::type::AbstractFloat*) { return target_ty ? target_ty : f32(); },
[&](const core::type::Vector* v) {
return Switch(
v->type(), //
[&](const core::type::AbstractInt*) {
return target_ty ? target_ty : i32v(v->Width());
},
[&](const core::type::AbstractFloat*) {
return target_ty ? target_ty : f32v(v->Width());
});
},
[&](const core::type::Matrix* m) {
return Switch(m->type(), //
[&](const core::type::AbstractFloat*) {
return target_ty ? target_ty : f32m(m->columns(), m->rows());
});
},
[&](const core::type::Array* a) -> const core::type::Type* {
const core::type::Type* target_el_ty = nullptr;
if (auto* target_arr_ty = As<core::type::Array>(target_ty)) {
target_el_ty = target_arr_ty->ElemType();
}
if (auto* el_ty = ConcreteType(a->ElemType(), target_el_ty, source)) {
return Array(source, source, source, el_ty, a->Count(), /* explicit_stride */ 0);
}
return nullptr;
},
[&](const core::type::Struct* s) -> const core::type::Type* {
if (auto tys = s->ConcreteTypes(); !tys.IsEmpty()) {
return target_ty ? target_ty : tys[0];
}
return nullptr;
});
}
const sem::ValueExpression* Resolver::Load(const sem::ValueExpression* expr) {
if (!expr) {
// Allow for Load(ValueExpression(blah)), where failures pass through Load()
return nullptr;
}
if (!expr->Type()->Is<core::type::Reference>()) {
// Expression is not a reference type, so cannot be loaded. Just return expr.
return expr;
}
auto* load = builder_->create<sem::Load>(expr, current_statement_);
load->Behaviors() = expr->Behaviors();
builder_->Sem().Replace(expr->Declaration(), load);
// Track the load for the alias analysis.
auto& alias_info = alias_analysis_infos_[current_function_];
Switch(
expr->RootIdentifier(),
[&](const sem::GlobalVariable* global) {
alias_info.module_scope_reads.insert({global, expr});
},
[&](const sem::Parameter* param) { alias_info.parameter_reads.insert(param); });
return load;
}
const sem::ValueExpression* Resolver::Materialize(
const sem::ValueExpression* expr,
const core::type::Type* target_type /* = nullptr */) {
if (!expr) {
// Allow for Materialize(ValueExpression(blah)), where failures pass through Materialize()
return nullptr;
}
auto* decl = expr->Declaration();
auto* concrete_ty = ConcreteType(expr->Type(), target_type, decl->source);
if (!concrete_ty) {
return expr; // Does not require materialization
}
auto* src_ty = expr->Type();
if (!validator_.Materialize(concrete_ty, src_ty, decl->source)) {
return nullptr;
}
const core::constant::Value* materialized_val = nullptr;
if (!skip_const_eval_.Contains(decl)) {
auto expr_val = expr->ConstantValue();
if (TINT_UNLIKELY(!expr_val)) {
StringStream err;
err << decl->source << "Materialize(" << decl->TypeInfo().name
<< ") called on expression with no constant value";
AddICE(err.str(), expr->Declaration()->source);
return nullptr;
}
auto val = const_eval_.Convert(concrete_ty, expr_val, decl->source);
if (!val) {
// Convert() has already failed and raised an diagnostic error.
return nullptr;
}
materialized_val = val.Get();
if (TINT_UNLIKELY(!materialized_val)) {
StringStream err;
err << decl->source << "ConvertValue(" << expr_val->Type()->FriendlyName() << " -> "
<< concrete_ty->FriendlyName() << ") returned invalid value";
AddICE(err.str(), expr->Declaration()->source);
return nullptr;
}
}
auto* m =
builder_->create<sem::Materialize>(expr, current_statement_, concrete_ty, materialized_val);
m->Behaviors() = expr->Behaviors();
builder_->Sem().Replace(decl, m);
return m;
}
template <size_t N>
bool Resolver::MaybeMaterializeAndLoadArguments(Vector<const sem::ValueExpression*, N>& args,
const sem::CallTarget* target) {
for (size_t i = 0, n = std::min(args.Length(), target->Parameters().Length()); i < n; i++) {
const auto* param_ty = target->Parameters()[i]->Type();
if (ShouldMaterializeArgument(param_ty)) {
auto* materialized = Materialize(args[i], param_ty);
if (!materialized) {
return false;
}
args[i] = materialized;
}
if (!param_ty->Is<core::type::Reference>()) {
auto* load = Load(args[i]);
if (!load) {
return false;
}
args[i] = load;
}
}
return true;
}
bool Resolver::ShouldMaterializeArgument(const core::type::Type* parameter_ty) const {
const auto* param_el_ty = parameter_ty->DeepestElement();
return param_el_ty && !param_el_ty->Is<core::type::AbstractNumeric>();
}
bool Resolver::Convert(const core::constant::Value*& c,
const core::type::Type* target_ty,
const Source& source) {
auto r = const_eval_.Convert(target_ty, c, source);
if (!r) {
return false;
}
c = r.Get();
return true;
}
template <size_t N>
tint::Result<Vector<const core::constant::Value*, N>> Resolver::ConvertArguments(
const Vector<const sem::ValueExpression*, N>& args,
const sem::CallTarget* target) {
auto const_args = tint::Transform(args, [](auto* arg) { return arg->ConstantValue(); });
for (size_t i = 0, n = std::min(args.Length(), target->Parameters().Length()); i < n; i++) {
if (!Convert(const_args[i], target->Parameters()[i]->Type(),
args[i]->Declaration()->source)) {
return tint::Failure;
}
}
return const_args;
}
sem::ValueExpression* Resolver::IndexAccessor(const ast::IndexAccessorExpression* expr) {
auto* idx = Load(Materialize(sem_.GetVal(expr->index)));
if (!idx) {
return nullptr;
}
const auto* obj = sem_.GetVal(expr->object);
if (idx->Stage() != core::EvaluationStage::kConstant) {
// If the index is non-constant, then the resulting expression is non-constant, so we'll
// have to materialize the object. For example, consider:
// vec2(1, 2)[runtime-index]
obj = Materialize(obj);
}
if (!obj) {
return nullptr;
}
auto* obj_raw_ty = obj->Type();
auto* obj_ty = obj_raw_ty->UnwrapRef();
auto* ty = Switch(
obj_ty, //
[&](const core::type::Array* arr) { return arr->ElemType(); },
[&](const core::type::Vector* vec) { return vec->type(); },
[&](const core::type::Matrix* mat) {
return builder_->create<core::type::Vector>(mat->type(), mat->rows());
},
[&](Default) {
AddError("cannot index type '" + sem_.TypeNameOf(obj_ty) + "'", expr->source);
return nullptr;
});
if (ty == nullptr) {
return nullptr;
}
auto* idx_ty = idx->Type()->UnwrapRef();
if (!idx_ty->IsAnyOf<core::type::I32, core::type::U32>()) {
AddError("index must be of type 'i32' or 'u32', found: '" + sem_.TypeNameOf(idx_ty) + "'",
idx->Declaration()->source);
return nullptr;
}
// If we're extracting from a reference, we return a reference.
if (auto* ref = obj_raw_ty->As<core::type::Reference>()) {
ty = builder_->create<core::type::Reference>(ref->AddressSpace(), ty, ref->Access());
}
const core::constant::Value* val = nullptr;
auto stage = core::EarliestStage(obj->Stage(), idx->Stage());
if (stage == core::EvaluationStage::kConstant && skip_const_eval_.Contains(expr)) {
stage = core::EvaluationStage::kNotEvaluated;
} else {
if (auto* idx_val = idx->ConstantValue()) {
auto res = const_eval_.Index(obj->ConstantValue(), obj->Type(), idx_val,
idx->Declaration()->source);
if (!res) {
return nullptr;
}
val = res.Get();
}
}
bool has_side_effects = idx->HasSideEffects() || obj->HasSideEffects();
auto* sem = builder_->create<sem::IndexAccessorExpression>(
expr, ty, stage, obj, idx, current_statement_, std::move(val), has_side_effects,
obj->RootIdentifier());
sem->Behaviors() = idx->Behaviors() + obj->Behaviors();
return sem;
}
sem::ValueExpression* Resolver::Bitcast(const ast::BitcastExpression* expr) {
auto* inner = Load(Materialize(sem_.GetVal(expr->expr)));
if (!inner) {
return nullptr;
}
auto* ty = Type(expr->type);
if (!ty) {
return nullptr;
}
if (!validator_.Bitcast(expr, ty)) {
return nullptr;
}
auto stage = inner->Stage();
if (stage == core::EvaluationStage::kConstant && skip_const_eval_.Contains(expr)) {
stage = core::EvaluationStage::kNotEvaluated;
}
const core::constant::Value* value = nullptr;
if (stage == core::EvaluationStage::kConstant) {
if (auto r = const_eval_.Bitcast(ty, inner->ConstantValue(), expr->source)) {
value = r.Get();
} else {
return nullptr;
}
}
auto* sem = builder_->create<sem::ValueExpression>(expr, ty, stage, current_statement_,
std::move(value), inner->HasSideEffects());
sem->Behaviors() = inner->Behaviors();
return sem;
}
sem::Call* Resolver::Call(const ast::CallExpression* expr) {
// A CallExpression can resolve to one of:
// * A function call.
// * A builtin call.
// * A value constructor.
// * A value conversion.
auto* target = expr->target;
Mark(target);
auto* ident = target->identifier;
Mark(ident);
// Resolve all of the arguments, their types and the set of behaviors.
Vector<const sem::ValueExpression*, 8> args;
args.Reserve(expr->args.Length());
auto args_stage = core::EvaluationStage::kConstant;
sem::Behaviors arg_behaviors;
for (size_t i = 0; i < expr->args.Length(); i++) {
auto* arg = sem_.GetVal(expr->args[i]);
if (!arg) {
return nullptr;
}
args.Push(arg);
args_stage = core::EarliestStage(args_stage, arg->Stage());
arg_behaviors.Add(arg->Behaviors());
}
arg_behaviors.Remove(sem::Behavior::kNext);
// Did any arguments have side effects?
bool has_side_effects =
std::any_of(args.begin(), args.end(), [](auto* e) { return e->HasSideEffects(); });
// ctor_or_conv is a helper for building either a sem::ValueConstructor or
// sem::ValueConversion call for a CtorConvIntrinsic with an optional template argument type.
auto ctor_or_conv = [&](CtorConvIntrinsic ty,
const core::type::Type* template_arg) -> sem::Call* {
auto arg_tys = tint::Transform(args, [](auto* arg) { return arg->Type(); });
auto match = core::intrinsic::Lookup(intrinsic_context_, ty, template_arg, arg_tys,
args_stage, expr->source);
if (!match) {
return nullptr;
}
auto overload_stage = match->const_eval_fn ? core::EvaluationStage::kConstant
: core::EvaluationStage::kRuntime;
sem::CallTarget* target_sem = nullptr;
// Is this overload a constructor or conversion?
if (match->info->flags.Contains(OverloadFlag::kIsConstructor)) {
// Type constructor
auto params = Transform(match->parameters, [&](auto& p, size_t i) {
return builder_->create<sem::Parameter>(nullptr, static_cast<uint32_t>(i), p.type,
core::AddressSpace::kUndefined,
core::Access::kUndefined, p.usage);
});
target_sem = constructors_.GetOrCreate(match.Get(), [&] {
return builder_->create<sem::ValueConstructor>(match->return_type,
std::move(params), overload_stage);
});
} else {
// Type conversion
target_sem = converters_.GetOrCreate(match.Get(), [&] {
auto param = builder_->create<sem::Parameter>(
nullptr, 0u, match->parameters[0].type, core::AddressSpace::kUndefined,
core::Access::kUndefined, match->parameters[0].usage);
return builder_->create<sem::ValueConversion>(match->return_type, param,
overload_stage);
});
}
if (!MaybeMaterializeAndLoadArguments(args, target_sem)) {
return nullptr;
}
const core::constant::Value* value = nullptr;
auto stage = core::EarliestStage(overload_stage, args_stage);
if (stage == core::EvaluationStage::kConstant && skip_const_eval_.Contains(expr)) {
stage = core::EvaluationStage::kNotEvaluated;
}
if (stage == core::EvaluationStage::kConstant) {
auto const_args = ConvertArguments(args, target_sem);
if (!const_args) {
return nullptr;
}
auto const_eval_fn = match->const_eval_fn;
if (auto r = (const_eval_.*const_eval_fn)(target_sem->ReturnType(), const_args.Get(),
expr->source)) {
value = r.Get();
} else {
return nullptr;
}
}
return builder_->create<sem::Call>(expr, target_sem, stage, std::move(args),
current_statement_, value, has_side_effects);
};
// arr_or_str_init is a helper for building a sem::ValueConstructor for an array or structure
// constructor call target.
auto arr_or_str_init = [&](const core::type::Type* ty,
const sem::CallTarget* call_target) -> sem::Call* {
if (!MaybeMaterializeAndLoadArguments(args, call_target)) {
return nullptr;
}
auto stage = args_stage; // The evaluation stage of the call
const core::constant::Value* value = nullptr; // The constant value for the call
if (stage == core::EvaluationStage::kConstant && skip_const_eval_.Contains(expr)) {
stage = core::EvaluationStage::kNotEvaluated;
}
if (stage == core::EvaluationStage::kConstant) {
auto els = tint::Transform(args, [&](auto* arg) { return arg->ConstantValue(); });
if (auto r = const_eval_.ArrayOrStructCtor(ty, std::move(els))) {
value = r.Get();
} else {
return nullptr;
}
if (!value) {
// Constant evaluation failed.
// Can happen for expressions that will fail validation (later).
// Use the kRuntime EvaluationStage, as kConstant will trigger an assertion in
// the sem::ValueExpression constructor, which checks that kConstant is paired
// with a constant value.
stage = core::EvaluationStage::kRuntime;
}
}
return builder_->create<sem::Call>(expr, call_target, stage, std::move(args),
current_statement_, value, has_side_effects);
};
auto ty_init_or_conv = [&](const core::type::Type* type) {
return Switch(
type, //
[&](const core::type::I32*) { return ctor_or_conv(CtorConvIntrinsic::kI32, nullptr); },
[&](const core::type::U32*) { return ctor_or_conv(CtorConvIntrinsic::kU32, nullptr); },
[&](const core::type::F16*) {
return validator_.CheckF16Enabled(expr->source)
? ctor_or_conv(CtorConvIntrinsic::kF16, nullptr)
: nullptr;
},
[&](const core::type::F32*) { return ctor_or_conv(CtorConvIntrinsic::kF32, nullptr); },
[&](const core::type::Bool*) {
return ctor_or_conv(CtorConvIntrinsic::kBool, nullptr);
},
[&](const core::type::Vector* v) {
if (v->Packed()) {
TINT_ASSERT(v->Width() == 3u);
return ctor_or_conv(CtorConvIntrinsic::kPackedVec3, v->type());
}
return ctor_or_conv(core::intrinsic::VectorCtorConv(v->Width()), v->type());
},
[&](const core::type::Matrix* m) {
return ctor_or_conv(core::intrinsic::MatrixCtorConv(m->columns(), m->rows()),
m->type());
},
[&](const core::type::Array* arr) -> sem::Call* {
auto* call_target = array_ctors_.GetOrCreate(
ArrayConstructorSig{{arr, args.Length(), args_stage}},
[&]() -> sem::ValueConstructor* {
auto params = tint::Transform(args, [&](auto, size_t i) {
return builder_->create<sem::Parameter>(
nullptr, // declaration
static_cast<uint32_t>(i), // index
arr->ElemType(), // type
core::AddressSpace::kUndefined, // address_space
core::Access::kUndefined);
});
return builder_->create<sem::ValueConstructor>(arr, std::move(params),
args_stage);
});
auto* call = arr_or_str_init(arr, call_target);
if (!call) {
return nullptr;
}
// Validation must occur after argument materialization in arr_or_str_init().
if (!validator_.ArrayConstructor(expr, arr)) {
return nullptr;
}
return call;
},
[&](const core::type::Struct* str) -> sem::Call* {
auto* call_target = struct_ctors_.GetOrCreate(
StructConstructorSig{{str, args.Length(), args_stage}},
[&]() -> sem::ValueConstructor* {
Vector<sem::Parameter*, 8> params;
params.Resize(std::min(args.Length(), str->Members().Length()));
for (size_t i = 0, n = params.Length(); i < n; i++) {
params[i] = builder_->create<sem::Parameter>(
nullptr, // declaration
static_cast<uint32_t>(i), // index
str->Members()[i]->Type(), // type
core::AddressSpace::kUndefined, // address_space
core::Access::kUndefined); // access
}
return builder_->create<sem::ValueConstructor>(str, std::move(params),
args_stage);
});
auto* call = arr_or_str_init(str, call_target);
if (!call) {
return nullptr;
}
// Validation must occur after argument materialization in arr_or_str_init().
if (!validator_.StructureInitializer(expr, str)) {
return nullptr;
}
return call;
},
[&](Default) {
AddError("type is not constructible", expr->source);
return nullptr;
});
};
auto inferred_array = [&]() -> tint::sem::Call* {
auto el_count =
builder_->create<core::type::ConstantArrayCount>(static_cast<uint32_t>(args.Length()));
auto arg_tys = tint::Transform(args, [](auto* arg) { return arg->Type()->UnwrapRef(); });
auto el_ty = core::type::Type::Common(arg_tys);
if (!el_ty) {
AddError("cannot infer common array element type from constructor arguments",
expr->source);
Hashset<const core::type::Type*, 8> types;
for (size_t i = 0; i < args.Length(); i++) {
if (types.Add(args[i]->Type())) {
AddNote("argument " + std::to_string(i) + " is of type '" +
sem_.TypeNameOf(args[i]->Type()) + "'",
args[i]->Declaration()->source);
}
}
return nullptr;
}
auto* arr = Array(expr->source, expr->source, expr->source, el_ty, el_count,
/* explicit_stride */ 0);
if (!arr) {
return nullptr;
}
return ty_init_or_conv(arr);
};
auto call = [&]() -> sem::Call* {
auto resolved = dependencies_.resolved_identifiers.Get(ident);
if (!resolved) {
StringStream err;
err << "identifier '" << ident->symbol.Name() << "' was not resolved";
AddICE(err.str(), ident->source);
return nullptr;
}
if (auto* ast_node = resolved->Node()) {
return Switch(
sem_.Get(ast_node), //
[&](core::type::Type* t) -> tint::sem::Call* {
// User declared types cannot be templated.
if (!TINT_LIKELY(CheckNotTemplated("type", ident))) {
return nullptr;
}
return ty_init_or_conv(t);
},
[&](sem::Function* f) -> sem::Call* {
if (!TINT_LIKELY(CheckNotTemplated("function", ident))) {
return nullptr;
}
return FunctionCall(expr, f, args, arg_behaviors);
},
[&](sem::Expression* e) {
sem_.ErrorUnexpectedExprKind(e, "call target");
return nullptr;
},
[&](Default) {
ErrorMismatchedResolvedIdentifier(ident->source, *resolved, "call target");
return nullptr;
});
}
if (auto f = resolved->BuiltinFn(); f != core::BuiltinFn::kNone) {
if (!TINT_LIKELY(CheckNotTemplated("builtin", ident))) {
return nullptr;
}
return BuiltinCall(expr, f, args);
}
if (auto b = resolved->BuiltinType(); b != core::Builtin::kUndefined) {
if (!ident->Is<ast::TemplatedIdentifier>()) {
// No template arguments provided.
// Check to see if this is an inferred-element-type call.
switch (b) {
case core::Builtin::kArray:
return inferred_array();
case core::Builtin::kVec2:
return ctor_or_conv(CtorConvIntrinsic::kVec2, nullptr);
case core::Builtin::kVec3:
return ctor_or_conv(CtorConvIntrinsic::kVec3, nullptr);
case core::Builtin::kVec4:
return ctor_or_conv(CtorConvIntrinsic::kVec4, nullptr);
case core::Builtin::kMat2X2:
return ctor_or_conv(CtorConvIntrinsic::kMat2x2, nullptr);
case core::Builtin::kMat2X3:
return ctor_or_conv(CtorConvIntrinsic::kMat2x3, nullptr);
case core::Builtin::kMat2X4:
return ctor_or_conv(CtorConvIntrinsic::kMat2x4, nullptr);
case core::Builtin::kMat3X2:
return ctor_or_conv(CtorConvIntrinsic::kMat3x2, nullptr);
case core::Builtin::kMat3X3:
return ctor_or_conv(CtorConvIntrinsic::kMat3x3, nullptr);
case core::Builtin::kMat3X4:
return ctor_or_conv(CtorConvIntrinsic::kMat3x4, nullptr);
case core::Builtin::kMat4X2:
return ctor_or_conv(CtorConvIntrinsic::kMat4x2, nullptr);
case core::Builtin::kMat4X3:
return ctor_or_conv(CtorConvIntrinsic::kMat4x3, nullptr);
case core::Builtin::kMat4X4:
return ctor_or_conv(CtorConvIntrinsic::kMat4x4, nullptr);
default:
break;
}
}
auto* ty = BuiltinType(b, ident);
if (TINT_UNLIKELY(!ty)) {
return nullptr;
}
return ty_init_or_conv(ty);
}
if (auto* unresolved = resolved->Unresolved()) {
AddError("unresolved call target '" + unresolved->name + "'", expr->source);
return nullptr;
}
ErrorMismatchedResolvedIdentifier(ident->source, *resolved, "call target");
return nullptr;
}();
if (!call) {
return nullptr;
}
if (call->Target()->IsAnyOf<sem::ValueConstructor, sem::ValueConversion>()) {
// The target of the call was a type.
// Associate the target identifier expression with the resolved type.
auto* ty_expr =
builder_->create<sem::TypeExpression>(target, current_statement_, call->Type());
builder_->Sem().Add(target, ty_expr);
}
return validator_.Call(call, current_statement_) ? call : nullptr;
}
template <size_t N>
sem::Call* Resolver::BuiltinCall(const ast::CallExpression* expr,
core::BuiltinFn fn,
Vector<const sem::ValueExpression*, N>& args) {
auto arg_stage = core::EvaluationStage::kConstant;
for (auto* arg : args) {
arg_stage = core::EarliestStage(arg_stage, arg->Stage());
}
auto arg_tys = tint::Transform(args, [](auto* arg) { return arg->Type(); });
auto overload =
core::intrinsic::Lookup(intrinsic_context_, fn, arg_tys, arg_stage, expr->source);
if (!overload) {
return nullptr;
}
// De-duplicate builtins that are identical.
auto* target = builtins_.GetOrCreate(std::make_pair(overload.Get(), fn), [&] {
auto params = Transform(overload->parameters, [&](auto& p, size_t i) {
return builder_->create<sem::Parameter>(nullptr, static_cast<uint32_t>(i), p.type,
core::AddressSpace::kUndefined,
core::Access::kUndefined, p.usage);
});
sem::PipelineStageSet supported_stages;
auto flags = overload->info->flags;
if (flags.Contains(OverloadFlag::kSupportsVertexPipeline)) {
supported_stages.Add(ast::PipelineStage::kVertex);
}
if (flags.Contains(OverloadFlag::kSupportsFragmentPipeline)) {
supported_stages.Add(ast::PipelineStage::kFragment);
}
if (flags.Contains(OverloadFlag::kSupportsComputePipeline)) {
supported_stages.Add(ast::PipelineStage::kCompute);
}
auto eval_stage = overload->const_eval_fn ? core::EvaluationStage::kConstant
: core::EvaluationStage::kRuntime;
return builder_->create<sem::BuiltinFn>(
fn, overload->return_type, std::move(params), eval_stage, supported_stages,
flags.Contains(OverloadFlag::kIsDeprecated), flags.Contains(OverloadFlag::kMustUse));
});
if (fn == core::BuiltinFn::kTintMaterialize) {
args[0] = Materialize(args[0]);
if (!args[0]) {
return nullptr;
}
} else {
// Materialize arguments if the parameter type is not abstract
if (!MaybeMaterializeAndLoadArguments(args, target)) {
return nullptr;
}
}
if (target->IsDeprecated()) {
AddWarning("use of deprecated builtin", expr->source);
}
// If the builtin is @const, and all arguments have constant values, evaluate the builtin
// now.
const core::constant::Value* value = nullptr;
auto stage = core::EarliestStage(arg_stage, target->Stage());
if (stage == core::EvaluationStage::kConstant && skip_const_eval_.Contains(expr)) {
stage = core::EvaluationStage::kNotEvaluated;
}
if (stage == core::EvaluationStage::kConstant) {
auto const_args = ConvertArguments(args, target);
if (!const_args) {
return nullptr;
}
auto const_eval_fn = overload->const_eval_fn;
if (auto r = (const_eval_.*const_eval_fn)(target->ReturnType(), const_args.Get(),
expr->source)) {
value = r.Get();
} else {
return nullptr;
}
}
bool has_side_effects =
target->HasSideEffects() ||
std::any_of(args.begin(), args.end(), [](auto* e) { return e->HasSideEffects(); });
auto* call = builder_->create<sem::Call>(expr, target, stage, std::move(args),
current_statement_, value, has_side_effects);
if (current_function_) {
current_function_->AddDirectlyCalledBuiltin(target);
current_function_->AddDirectCall(call);
}
if (!validator_.RequiredExtensionForBuiltinFn(call)) {
return nullptr;
}
if (IsTexture(fn)) {
if (!validator_.TextureBuiltinFn(call)) {
return nullptr;
}
CollectTextureSamplerPairs(target, call->Arguments());
}
if (fn == core::BuiltinFn::kWorkgroupUniformLoad) {
if (!validator_.WorkgroupUniformLoad(call)) {
return nullptr;
}
}
if (fn == core::BuiltinFn::kSubgroupBroadcast) {
if (!validator_.SubgroupBroadcast(call)) {
return nullptr;
}
}
if (!validator_.BuiltinCall(call)) {
return nullptr;
}
return call;
}
core::type::Type* Resolver::BuiltinType(core::Builtin builtin_ty, const ast::Identifier* ident) {
auto& b = *builder_;
auto check_no_tmpl_args = [&](core::type::Type* ty) -> core::type::Type* {
return TINT_LIKELY(CheckNotTemplated("type", ident)) ? ty : nullptr;
};
auto af = [&] { return b.create<core::type::AbstractFloat>(); };
auto f32 = [&] { return b.create<core::type::F32>(); };
auto i32 = [&] { return b.create<core::type::I32>(); };
auto u32 = [&] { return b.create<core::type::U32>(); };
auto f16 = [&] {
return validator_.CheckF16Enabled(ident->source) ? b.create<core::type::F16>() : nullptr;
};
auto templated_identifier =
[&](size_t min_args, size_t max_args = /* use min */ 0) -> const ast::TemplatedIdentifier* {
if (max_args == 0) {
max_args = min_args;
}
auto* tmpl_ident = ident->As<ast::TemplatedIdentifier>();
if (!tmpl_ident) {
if (TINT_UNLIKELY(min_args != 0)) {
AddError("expected '<' for '" + ident->symbol.Name() + "'",
Source{ident->source.range.end});
}
return nullptr;
}
if (min_args == max_args) {
if (TINT_UNLIKELY(tmpl_ident->arguments.Length() != min_args)) {
AddError("'" + ident->symbol.Name() + "' requires " + std::to_string(min_args) +
" template arguments",
ident->source);
return nullptr;
}
} else {
if (TINT_UNLIKELY(tmpl_ident->arguments.Length() < min_args)) {
AddError("'" + ident->symbol.Name() + "' requires at least " +
std::to_string(min_args) + " template arguments",
ident->source);
return nullptr;
}
if (TINT_UNLIKELY(tmpl_ident->arguments.Length() > max_args)) {
AddError("'" + ident->symbol.Name() + "' requires at most " +
std::to_string(max_args) + " template arguments",