154 lines
4.7 KiB
C++
154 lines
4.7 KiB
C++
// Copyright 2021 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/resolver/resolver.h"
|
|
|
|
#include "src/sem/constant.h"
|
|
|
|
namespace tint {
|
|
namespace resolver {
|
|
namespace {
|
|
|
|
using i32 = ProgramBuilder::i32;
|
|
using u32 = ProgramBuilder::u32;
|
|
using f32 = ProgramBuilder::f32;
|
|
|
|
} // namespace
|
|
|
|
sem::Constant Resolver::ConstantCast(const sem::Constant& value,
|
|
const sem::Type* target_elem_type) {
|
|
if (value.ElementType() == target_elem_type) {
|
|
return value;
|
|
}
|
|
|
|
sem::Constant::Scalars elems;
|
|
for (size_t i = 0; i < value.Elements().size(); ++i) {
|
|
if (target_elem_type->Is<sem::I32>()) {
|
|
elems.emplace_back(
|
|
value.WithScalarAt(i, [](auto&& s) { return static_cast<i32>(s); }));
|
|
} else if (target_elem_type->Is<sem::U32>()) {
|
|
elems.emplace_back(
|
|
value.WithScalarAt(i, [](auto&& s) { return static_cast<u32>(s); }));
|
|
} else if (target_elem_type->Is<sem::F32>()) {
|
|
elems.emplace_back(
|
|
value.WithScalarAt(i, [](auto&& s) { return static_cast<f32>(s); }));
|
|
} else if (target_elem_type->Is<sem::Bool>()) {
|
|
elems.emplace_back(
|
|
value.WithScalarAt(i, [](auto&& s) { return static_cast<bool>(s); }));
|
|
}
|
|
}
|
|
|
|
auto* target_type =
|
|
value.Type()->Is<sem::Vector>()
|
|
? builder_->create<sem::Vector>(target_elem_type,
|
|
static_cast<uint32_t>(elems.size()))
|
|
: target_elem_type;
|
|
|
|
return sem::Constant(target_type, elems);
|
|
}
|
|
|
|
sem::Constant Resolver::ConstantValueOf(const ast::Expression* expr) {
|
|
auto it = expr_info_.find(expr);
|
|
if (it != expr_info_.end()) {
|
|
return it->second.constant_value;
|
|
}
|
|
return {};
|
|
}
|
|
|
|
sem::Constant Resolver::EvaluateConstantValue(const ast::Expression* expr,
|
|
const sem::Type* type) {
|
|
if (auto* e = expr->As<ast::ScalarConstructorExpression>()) {
|
|
return EvaluateConstantValue(e, type);
|
|
}
|
|
if (auto* e = expr->As<ast::TypeConstructorExpression>()) {
|
|
return EvaluateConstantValue(e, type);
|
|
}
|
|
return {};
|
|
}
|
|
|
|
sem::Constant Resolver::EvaluateConstantValue(
|
|
const ast::ScalarConstructorExpression* scalar_ctor,
|
|
const sem::Type* type) {
|
|
auto* literal = scalar_ctor->literal;
|
|
if (auto* lit = literal->As<ast::SintLiteral>()) {
|
|
return {type, {lit->ValueAsI32()}};
|
|
}
|
|
if (auto* lit = literal->As<ast::UintLiteral>()) {
|
|
return {type, {lit->ValueAsU32()}};
|
|
}
|
|
if (auto* lit = literal->As<ast::FloatLiteral>()) {
|
|
return {type, {lit->value}};
|
|
}
|
|
if (auto* lit = literal->As<ast::BoolLiteral>()) {
|
|
return {type, {lit->value}};
|
|
}
|
|
TINT_UNREACHABLE(Resolver, builder_->Diagnostics());
|
|
return {};
|
|
}
|
|
|
|
sem::Constant Resolver::EvaluateConstantValue(
|
|
const ast::TypeConstructorExpression* type_ctor,
|
|
const sem::Type* type) {
|
|
auto& ctor_values = type_ctor->values;
|
|
auto* vec = type->As<sem::Vector>();
|
|
|
|
// For now, only fold scalars and vectors
|
|
if (!type->is_scalar() && !vec) {
|
|
return {};
|
|
}
|
|
|
|
auto* elem_type = vec ? vec->type() : type;
|
|
int result_size = vec ? static_cast<int>(vec->Width()) : 1;
|
|
|
|
// For zero value init, return 0s
|
|
if (ctor_values.empty()) {
|
|
if (elem_type->Is<sem::I32>()) {
|
|
return sem::Constant(type, sem::Constant::Scalars(result_size, 0));
|
|
}
|
|
if (elem_type->Is<sem::U32>()) {
|
|
return sem::Constant(type, sem::Constant::Scalars(result_size, 0u));
|
|
}
|
|
if (elem_type->Is<sem::F32>()) {
|
|
return sem::Constant(type, sem::Constant::Scalars(result_size, 0.f));
|
|
}
|
|
if (elem_type->Is<sem::Bool>()) {
|
|
return sem::Constant(type, sem::Constant::Scalars(result_size, false));
|
|
}
|
|
}
|
|
|
|
// Build value for type_ctor from each child value by casting to
|
|
// type_ctor's type.
|
|
sem::Constant::Scalars elems;
|
|
for (auto* cv : ctor_values) {
|
|
auto value = ConstantValueOf(cv);
|
|
if (!value.IsValid()) {
|
|
return {};
|
|
}
|
|
auto cast = ConstantCast(value, elem_type);
|
|
elems.insert(elems.end(), cast.Elements().begin(), cast.Elements().end());
|
|
}
|
|
|
|
// Splat single-value initializers
|
|
if (elems.size() == 1) {
|
|
for (int i = 0; i < result_size - 1; ++i) {
|
|
elems.emplace_back(elems[0]);
|
|
}
|
|
}
|
|
|
|
return sem::Constant(type, std::move(elems));
|
|
}
|
|
|
|
} // namespace resolver
|
|
} // namespace tint
|