| // 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. |
| |
| #ifndef SRC_TINT_LANG_SPIRV_WRITER_AST_PRINTER_SCALAR_CONSTANT_H_ |
| #define SRC_TINT_LANG_SPIRV_WRITER_AST_PRINTER_SCALAR_CONSTANT_H_ |
| |
| #include <stdint.h> |
| |
| #include <cstring> |
| #include <functional> |
| |
| #include "src/tint/lang/core/number.h" |
| #include "src/tint/utils/math/hash.h" |
| |
| // Forward declarations |
| namespace tint::sem { |
| class Call; |
| } // namespace tint::sem |
| |
| namespace tint::spirv::writer { |
| |
| /// ScalarConstant represents a scalar constant value |
| struct ScalarConstant { |
| /// The struct type to hold the bits representation of f16 in the Value union |
| struct F16 { |
| /// The 16 bits representation of the f16, stored as uint16_t |
| uint16_t bits_representation; |
| }; |
| |
| /// The constant value |
| union Value { |
| /// The value as a bool |
| bool b; |
| /// The value as a uint32_t |
| uint32_t u32; |
| /// The value as a int32_t |
| int32_t i32; |
| /// The value as a float |
| float f32; |
| /// The value as bits representation of a f16 |
| F16 f16; |
| |
| /// The value that is wide enough to encompass all other types (including |
| /// future 64-bit data types). |
| uint64_t u64; |
| }; |
| |
| /// The kind of constant |
| enum class Kind { kBool, kU32, kI32, kF32, kF16 }; |
| |
| /// Constructor |
| inline ScalarConstant() { value.u64 = 0; } |
| |
| /// @param value the value of the constant |
| /// @returns a new ScalarConstant with the provided value and kind Kind::kU32 |
| static inline ScalarConstant U32(uint32_t value) { |
| ScalarConstant c; |
| c.value.u32 = value; |
| c.kind = Kind::kU32; |
| return c; |
| } |
| |
| /// @param value the value of the constant |
| /// @returns a new ScalarConstant with the provided value and kind Kind::kI32 |
| static inline ScalarConstant I32(int32_t value) { |
| ScalarConstant c; |
| c.value.i32 = value; |
| c.kind = Kind::kI32; |
| return c; |
| } |
| |
| /// @param value the value of the constant |
| /// @returns a new ScalarConstant with the provided value and kind Kind::kF32 |
| static inline ScalarConstant F32(float value) { |
| ScalarConstant c; |
| c.value.f32 = value; |
| c.kind = Kind::kF32; |
| return c; |
| } |
| |
| /// @param value the value of the constant |
| /// @returns a new ScalarConstant with the provided value and kind Kind::kF16 |
| static inline ScalarConstant F16(core::f16::type value) { |
| ScalarConstant c; |
| c.value.f16 = {core::f16(value).BitsRepresentation()}; |
| c.kind = Kind::kF16; |
| return c; |
| } |
| |
| /// @param value the value of the constant |
| /// @returns a new ScalarConstant with the provided value and kind Kind::kBool |
| static inline ScalarConstant Bool(bool value) { |
| ScalarConstant c; |
| c.value.b = value; |
| c.kind = Kind::kBool; |
| return c; |
| } |
| |
| /// Equality operator |
| /// @param rhs the ScalarConstant to compare against |
| /// @returns true if this ScalarConstant is equal to `rhs` |
| inline bool operator==(const ScalarConstant& rhs) const { |
| return value.u64 == rhs.value.u64 && kind == rhs.kind; |
| } |
| |
| /// Inequality operator |
| /// @param rhs the ScalarConstant to compare against |
| /// @returns true if this ScalarConstant is not equal to `rhs` |
| inline bool operator!=(const ScalarConstant& rhs) const { return !(*this == rhs); } |
| |
| /// The constant value |
| Value value; |
| /// The constant value kind |
| Kind kind = Kind::kBool; |
| }; |
| |
| } // namespace tint::spirv::writer |
| |
| namespace std { |
| |
| /// Custom std::hash specialization for tint::Symbol so symbols can be used as |
| /// keys for std::unordered_map and std::unordered_set. |
| template <> |
| class hash<tint::spirv::writer::ScalarConstant> { |
| public: |
| /// @param c the ScalarConstant |
| /// @return the Symbol internal value |
| inline std::size_t operator()(const tint::spirv::writer::ScalarConstant& c) const { |
| uint32_t value = 0; |
| std::memcpy(&value, &c.value, sizeof(value)); |
| return tint::Hash(value, c.kind); |
| } |
| }; |
| |
| } // namespace std |
| |
| #endif // SRC_TINT_LANG_SPIRV_WRITER_AST_PRINTER_SCALAR_CONSTANT_H_ |