src/tint/resolver/resolver_constants.cc

// 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/tint/resolver/resolver.h"

#include "src/tint/sem/abstract_float.h"
#include "src/tint/sem/abstract_int.h"
#include "src/tint/sem/constant.h"
#include "src/tint/sem/type_constructor.h"
#include "src/tint/utils/map.h"

using namespace tint::number_suffixes;  // NOLINT

namespace tint::resolver {
namespace {

sem::Constant::Scalars CastScalars(sem::Constant::Scalars in, const sem::Type* target_type) {
    sem::Constant::Scalars out;
    out.reserve(in.size());
    for (auto v : in) {
        // TODO(crbug.com/tint/1504): Check that value fits in new type
        out.emplace_back(Switch<sem::Constant::Scalar>(
            target_type,  //
            [&](const sem::AbstractInt*) { return sem::Constant::Cast<AInt>(v); },
            [&](const sem::AbstractFloat*) { return sem::Constant::Cast<AFloat>(v); },
            [&](const sem::I32*) { return sem::Constant::Cast<AInt>(v); },
            [&](const sem::U32*) { return sem::Constant::Cast<AInt>(v); },
            [&](const sem::F32*) { return sem::Constant::Cast<AFloat>(v); },
            [&](const sem::F16*) { return sem::Constant::Cast<AFloat>(v); },
            [&](const sem::Bool*) { return sem::Constant::Cast<bool>(v); },
            [&](Default) {
                diag::List diags;
                TINT_UNREACHABLE(Semantic, diags)
                    << "invalid element type " << target_type->TypeInfo().name;
                return sem::Constant::Scalar(false);
            }));
    }
    return out;
}

}  // namespace

sem::Constant Resolver::EvaluateConstantValue(const ast::Expression* expr, const sem::Type* type) {
    if (auto* e = expr->As<ast::LiteralExpression>()) {
        return EvaluateConstantValue(e, type);
    }
    if (auto* e = expr->As<ast::CallExpression>()) {
        return EvaluateConstantValue(e, type);
    }
    return {};
}

sem::Constant Resolver::EvaluateConstantValue(const ast::LiteralExpression* literal,
                                              const sem::Type* type) {
    return Switch(
        literal,
        [&](const ast::IntLiteralExpression* lit) {
            return sem::Constant{type, {AInt(lit->value)}};
        },
        [&](const ast::FloatLiteralExpression* lit) {
            return sem::Constant{type, {AFloat(lit->value)}};
        },
        [&](const ast::BoolLiteralExpression* lit) {
            return sem::Constant{type, {lit->value}};
        });
}

sem::Constant Resolver::EvaluateConstantValue(const ast::CallExpression* call,
                                              const sem::Type* type) {
    uint32_t result_size = 0;
    auto* el_ty = sem::Type::ElementOf(type, &result_size);
    if (!el_ty) {
        return {};
    }

    // ElementOf() will also return the element type of array, which we do not support.
    if (type->Is<sem::Array>()) {
        return {};
    }

    // For zero value init, return 0s
    if (call->args.empty()) {
        using Scalars = sem::Constant::Scalars;
        return Switch(
            el_ty,
            [&](const sem::AbstractInt*) {
                return sem::Constant(type, Scalars(result_size, AInt(0)));
            },
            [&](const sem::AbstractFloat*) {
                return sem::Constant(type, Scalars(result_size, AFloat(0)));
            },
            [&](const sem::I32*) { return sem::Constant(type, Scalars(result_size, AInt(0))); },
            [&](const sem::U32*) { return sem::Constant(type, Scalars(result_size, AInt(0))); },
            [&](const sem::F32*) { return sem::Constant(type, Scalars(result_size, AFloat(0))); },
            [&](const sem::F16*) { return sem::Constant(type, Scalars(result_size, AFloat(0))); },
            [&](const sem::Bool*) { return sem::Constant(type, 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* expr : call->args) {
        auto* arg = builder_->Sem().Get(expr);
        if (!arg) {
            return {};
        }
        auto value = arg->ConstantValue();
        if (!value) {
            return {};
        }
        elems.insert(elems.end(), value.Elements().begin(), value.Elements().end());
    }

    // Splat single-value initializers
    if (elems.size() == 1) {
        for (uint32_t i = 0; i < result_size - 1; ++i) {
            elems.emplace_back(elems[0]);
        }
    }

    // Finally cast the elements to the desired type.
    auto cast = CastScalars(elems, el_ty);

    return sem::Constant(type, std::move(cast));
}

sem::Constant Resolver::ConstantCast(const sem::Constant& value,
                                     const sem::Type* target_type,
                                     const sem::Type* target_element_type /* = nullptr */) {
    if (value.Type() == target_type) {
        return value;
    }

    if (target_element_type == nullptr) {
        target_element_type = sem::Type::ElementOf(target_type);
    }
    if (target_element_type == nullptr) {
        return {};
    }
    if (value.ElementType() == target_element_type) {
        return sem::Constant(target_type, value.Elements());
    }

    auto elems = CastScalars(value.Elements(), target_element_type);

    return sem::Constant(target_type, elems);
}

}  // namespace tint::resolver