| // Copyright 2019 The SwiftShader Authors. All Rights Reserved. |
| // |
| // 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 rr_Traits_hpp |
| #define rr_Traits_hpp |
| |
| #include <stdint.h> |
| #include <type_traits> |
| |
| namespace rr { |
| |
| // Forward declarations |
| class Value; |
| |
| class Void; |
| class Bool; |
| class Byte; |
| class SByte; |
| class Short; |
| class UShort; |
| class Int; |
| class UInt; |
| class Long; |
| class Half; |
| class Float; |
| class Float4; |
| |
| template<class T> |
| class Pointer; |
| template<class T> |
| class LValue; |
| template<class T> |
| class RValue; |
| |
| // IsDefined<T>::value is true if T is a valid type, otherwise false. |
| template<typename T, typename Enable = void> |
| struct IsDefined |
| { |
| static constexpr bool value = false; |
| }; |
| |
| template<typename T> |
| struct IsDefined<T, std::enable_if_t<(sizeof(T) > 0)>> |
| { |
| static constexpr bool value = true; |
| }; |
| |
| template<> |
| struct IsDefined<void> |
| { |
| static constexpr bool value = true; |
| }; |
| |
| // CToReactorT<T> resolves to the corresponding Reactor type for the given C |
| // template type T. |
| template<typename T, typename ENABLE = void> |
| struct CToReactor; |
| template<typename T> |
| using CToReactorT = typename CToReactor<T>::type; |
| |
| // CToReactor specializations for POD types. |
| template<> |
| struct CToReactor<void> |
| { |
| using type = Void; |
| }; |
| template<> |
| struct CToReactor<bool> |
| { |
| using type = Bool; |
| static Bool cast(bool); |
| }; |
| template<> |
| struct CToReactor<uint8_t> |
| { |
| using type = Byte; |
| static Byte cast(uint8_t); |
| }; |
| template<> |
| struct CToReactor<int8_t> |
| { |
| using type = SByte; |
| static SByte cast(int8_t); |
| }; |
| template<> |
| struct CToReactor<int16_t> |
| { |
| using type = Short; |
| static Short cast(int16_t); |
| }; |
| template<> |
| struct CToReactor<uint16_t> |
| { |
| using type = UShort; |
| static UShort cast(uint16_t); |
| }; |
| template<> |
| struct CToReactor<int32_t> |
| { |
| using type = Int; |
| static Int cast(int32_t); |
| }; |
| template<> |
| struct CToReactor<uint32_t> |
| { |
| using type = UInt; |
| static UInt cast(uint32_t); |
| }; |
| template<> |
| struct CToReactor<float> |
| { |
| using type = Float; |
| static Float cast(float); |
| }; |
| template<> |
| struct CToReactor<float[4]> |
| { |
| using type = Float4; |
| static Float4 cast(float[4]); |
| }; |
| |
| // TODO: Long has no constructor that takes a uint64_t |
| template<> |
| struct CToReactor<uint64_t> |
| { |
| using type = Long; /* static Long cast(uint64_t); */ |
| }; |
| |
| // HasReactorType<T>::value resolves to true iff there exists a |
| // CToReactorT specialization for type T. |
| template<typename T> |
| using HasReactorType = IsDefined<CToReactorT<T>>; |
| |
| // CToReactorPtr<T>::type resolves to the corresponding Reactor Pointer<> |
| // type for T*. |
| // For T types that have a CToReactorT<> specialization, |
| // CToReactorPtr<T>::type resolves to Pointer< CToReactorT<T> >, otherwise |
| // CToReactorPtr<T>::type resolves to Pointer<Byte>. |
| template<typename T, typename ENABLE = void> |
| struct CToReactorPtr |
| { |
| using type = Pointer<Byte>; |
| static inline type cast(const T *v); // implemented in Traits.inl |
| }; |
| |
| // CToReactorPtr specialization for T types that have a CToReactorT<> |
| // specialization. |
| template<typename T> |
| struct CToReactorPtr<T, std::enable_if_t<HasReactorType<T>::value>> |
| { |
| using type = Pointer<CToReactorT<T>>; |
| static inline type cast(const T *v); // implemented in Traits.inl |
| }; |
| |
| // CToReactorPtr specialization for void*. |
| // Maps to Pointer<Byte> instead of Pointer<Void>. |
| template<> |
| struct CToReactorPtr<void, void> |
| { |
| using type = Pointer<Byte>; |
| static inline type cast(const void *v); // implemented in Traits.inl |
| }; |
| |
| // CToReactorPtr specialization for function pointer types. |
| // Maps to Pointer<Byte>. |
| // Drops the 'const' qualifier from the cast() method to avoid warnings |
| // about const having no meaning for function types. |
| template<typename T> |
| struct CToReactorPtr<T, std::enable_if_t<std::is_function<T>::value>> |
| { |
| using type = Pointer<Byte>; |
| static inline type cast(T *v); // implemented in Traits.inl |
| }; |
| |
| template<typename T> |
| using CToReactorPtrT = typename CToReactorPtr<T>::type; |
| |
| // CToReactor specialization for pointer types. |
| // For T types that have a CToReactorT<> specialization, |
| // CToReactorT<T*>::type resolves to Pointer< CToReactorT<T> >, otherwise |
| // CToReactorT<T*>::type resolves to Pointer<Byte>. |
| template<typename T> |
| struct CToReactor<T, std::enable_if_t<std::is_pointer<T>::value>> |
| { |
| using elem = typename std::remove_pointer<T>::type; |
| using type = CToReactorPtrT<elem>; |
| static inline type cast(T v); // implemented in Traits.inl |
| }; |
| |
| // CToReactor specialization for enum types. |
| template<typename T> |
| struct CToReactor<T, std::enable_if_t<std::is_enum<T>::value>> |
| { |
| using underlying = typename std::underlying_type<T>::type; |
| using type = CToReactorT<underlying>; |
| static type cast(T v); // implemented in Traits.inl |
| }; |
| |
| // IsRValue::value is true if T is of type RValue<X>, where X is any type. |
| template<typename T, typename Enable = void> |
| struct IsRValue |
| { |
| static constexpr bool value = false; |
| }; |
| template<typename T> |
| struct IsRValue<T, std::enable_if_t<IsDefined<typename T::rvalue_underlying_type>::value>> |
| { |
| static constexpr bool value = true; |
| }; |
| |
| // IsLValue::value is true if T is of, or derives from type LValue<T>. |
| template<typename T> |
| struct IsLValue |
| { |
| static constexpr bool value = std::is_base_of<LValue<T>, T>::value; |
| }; |
| |
| // IsReference::value is true if T is of type Reference<X>, where X is any type. |
| template<typename T, typename Enable = void> |
| struct IsReference |
| { |
| static constexpr bool value = false; |
| }; |
| template<typename T> |
| struct IsReference<T, std::enable_if_t<IsDefined<typename T::reference_underlying_type>::value>> |
| { |
| static constexpr bool value = true; |
| }; |
| |
| // ReactorTypeT<T> returns the LValue Reactor type for T. |
| // T can be a C-type, RValue or LValue. |
| template<typename T, typename ENABLE = void> |
| struct ReactorType; |
| template<typename T> |
| using ReactorTypeT = typename ReactorType<T>::type; |
| template<typename T> |
| struct ReactorType<T, std::enable_if_t<IsDefined<CToReactorT<T>>::value>> |
| { |
| using type = CToReactorT<T>; |
| static type cast(T v) { return CToReactor<T>::cast(v); } |
| }; |
| template<typename T> |
| struct ReactorType<T, std::enable_if_t<IsRValue<T>::value>> |
| { |
| using type = typename T::rvalue_underlying_type; |
| static type cast(T v) { return type(v); } |
| }; |
| template<typename T> |
| struct ReactorType<T, std::enable_if_t<IsLValue<T>::value>> |
| { |
| using type = T; |
| static type cast(T v) { return type(v); } |
| }; |
| template<typename T> |
| struct ReactorType<T, std::enable_if_t<IsReference<T>::value>> |
| { |
| using type = T; |
| static type cast(T v) { return type(v); } |
| }; |
| |
| // Reactor types that can be used as a return type for a function. |
| template<typename T> |
| struct CanBeUsedAsReturn |
| { |
| static constexpr bool value = false; |
| }; |
| template<> |
| struct CanBeUsedAsReturn<Void> |
| { |
| static constexpr bool value = true; |
| }; |
| template<> |
| struct CanBeUsedAsReturn<Int> |
| { |
| static constexpr bool value = true; |
| }; |
| template<> |
| struct CanBeUsedAsReturn<UInt> |
| { |
| static constexpr bool value = true; |
| }; |
| template<> |
| struct CanBeUsedAsReturn<Float> |
| { |
| static constexpr bool value = true; |
| }; |
| template<typename T> |
| struct CanBeUsedAsReturn<Pointer<T>> |
| { |
| static constexpr bool value = true; |
| }; |
| |
| // Reactor types that can be used as a parameter types for a function. |
| template<typename T> |
| struct CanBeUsedAsParameter |
| { |
| static constexpr bool value = false; |
| }; |
| template<> |
| struct CanBeUsedAsParameter<Int> |
| { |
| static constexpr bool value = true; |
| }; |
| template<> |
| struct CanBeUsedAsParameter<UInt> |
| { |
| static constexpr bool value = true; |
| }; |
| template<> |
| struct CanBeUsedAsParameter<Float> |
| { |
| static constexpr bool value = true; |
| }; |
| template<typename T> |
| struct CanBeUsedAsParameter<Pointer<T>> |
| { |
| static constexpr bool value = true; |
| }; |
| |
| // AssertParameterTypeIsValid statically asserts that all template parameter |
| // types can be used as a Reactor function parameter. |
| template<typename T, typename... other> |
| struct AssertParameterTypeIsValid : AssertParameterTypeIsValid<other...> |
| { |
| static_assert(CanBeUsedAsParameter<T>::value, "Invalid parameter type"); |
| }; |
| template<typename T> |
| struct AssertParameterTypeIsValid<T> |
| { |
| static_assert(CanBeUsedAsParameter<T>::value, "Invalid parameter type"); |
| }; |
| |
| // AssertFunctionSignatureIsValid statically asserts that the Reactor |
| // function signature is valid. |
| template<typename Return, typename... Arguments> |
| class AssertFunctionSignatureIsValid; |
| template<typename Return> |
| class AssertFunctionSignatureIsValid<Return(Void)> |
| {}; |
| template<typename Return, typename... Arguments> |
| class AssertFunctionSignatureIsValid<Return(Arguments...)> |
| { |
| static_assert(CanBeUsedAsReturn<Return>::value, "Invalid return type"); |
| static_assert(sizeof(AssertParameterTypeIsValid<Arguments...>) >= 0, ""); |
| }; |
| |
| } // namespace rr |
| |
| #endif // rr_Traits_hpp |