| // 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_Print_hpp |
| #define rr_Print_hpp |
| |
| #if !defined(NDEBUG) |
| #define ENABLE_RR_PRINT 1 // Enables RR_PRINT(), RR_WATCH() |
| #endif // !defined(NDEBUG) |
| |
| #ifdef ENABLE_RR_PRINT |
| |
| #include "Reactor.hpp" |
| |
| #include <string> |
| #include <vector> |
| |
| namespace rr { |
| |
| // PrintValue holds the printf format and value(s) for a single argument |
| // to Print(). A single argument can be expanded into multiple printf |
| // values - for example a Float4 will expand to "%f %f %f %f" and four |
| // scalar values. |
| // The PrintValue constructor accepts the following: |
| // * Reactor LValues, RValues, Pointers. |
| // * Standard Plain-Old-Value types (int, float, bool, etc) |
| // * Custom types that specialize the PrintValue::Ty template struct. |
| // * Static arrays in the form T[N] where T can be any of the above. |
| class PrintValue |
| { |
| // Ty is a template that can be specialized for printing type T. |
| // Each specialization must expose: |
| // * A 'static std::string fmt(const T& v)' method that provides the |
| // printf format specifier. |
| // * A 'static std::vector<rr::Value*> val(const T& v)' method that |
| // returns all the printf format values. |
| template <typename T> struct Ty |
| { |
| // static std::string fmt(const T& v); |
| // static std::vector<rr::Value*> val(const T& v); |
| }; |
| |
| // returns the printf values for all the values in the given array. |
| template <typename T> |
| static std::vector<Value*> val(const T* list, int count) { |
| std::vector<Value*> values; |
| values.reserve(count); |
| for (int i = 0; i < count; i++) |
| { |
| auto v = val(list[i]); |
| values.insert(values.end(), v.begin(), v.end()); |
| } |
| return values; |
| } |
| |
| // fmt returns the comma-delimited list of printf format strings for |
| // every element in the provided list, all enclosed in square brackets. |
| template <typename T> |
| static std::string fmt(const T* list, int count) |
| { |
| std::string out = "["; |
| for (int i = 0; i < count; i++) |
| { |
| if (i > 0) { out += ", "; } |
| out += fmt(list[i]); |
| } |
| return out + "]"; |
| } |
| |
| static std::string addr(const void* ptr) |
| { |
| char buf[32]; |
| snprintf(buf, sizeof(buf), "%p", ptr); |
| return buf; |
| } |
| |
| public: |
| const std::string format; |
| const std::vector<Value*> values; |
| |
| // Constructs a PrintValue for the given value. |
| template <typename T> |
| PrintValue(const T& v) : format(fmt(v)), values(val(v)) {} |
| |
| // Constructs a PrintValue for the given static array. |
| template <typename T, int N> |
| PrintValue(const T (&v)[N]) : format(fmt(&v[0], N)), values(val(&v[0], N)) {} |
| |
| // Constructs a PrintValue for the given array starting at arr of length |
| // len. |
| template <typename T> |
| PrintValue(const T* arr, int len) : format(fmt(arr, len)), values(val(arr, len)) {} |
| |
| // PrintValue constructors for plain-old-data values. |
| PrintValue(bool v) : format(v ? "true" : "false") {} |
| PrintValue(int8_t v) : format(std::to_string(v)) {} |
| PrintValue(uint8_t v) : format(std::to_string(v)) {} |
| PrintValue(int16_t v) : format(std::to_string(v)) {} |
| PrintValue(uint16_t v) : format(std::to_string(v)) {} |
| PrintValue(int32_t v) : format(std::to_string(v)) {} |
| PrintValue(uint32_t v) : format(std::to_string(v)) {} |
| PrintValue(int64_t v) : format(std::to_string(v)) {} |
| PrintValue(uint64_t v) : format(std::to_string(v)) {} |
| PrintValue(float v) : format(std::to_string(v)) {} |
| PrintValue(double v) : format(std::to_string(v)) {} |
| |
| template <typename T> |
| PrintValue(const T* v) : format(addr(v)) {} |
| |
| // vals is a helper to build composite value lists. |
| // vals returns the full, sequential list of printf argument values used |
| // to print all the provided variadic values. |
| // vals() is intended to be used by implementations of |
| // PrintValue::Ty<>::vals() to help declare aggregate types. |
| // For example, if you were declaring a PrintValue::Ty<> specialization |
| // for a custom Mat4x4 matrix formed from four Vector4 values, you'd |
| // write: |
| // |
| // namespace rr |
| // { |
| // template <> struct PrintValue::Ty<Mat4x4> |
| // { |
| // static std::string fmt(const Mat4x4& v) |
| // { |
| // return "[a: <%f, %f, %f, %f>," |
| // " b: <%f, %f, %f, %f>," |
| // " c: <%f, %f, %f, %f>," |
| // " d: <%f, %f, %f, %f>]"; |
| // } |
| // static std::vector<rr::Value*> val(const Mat4x4& v) |
| // { |
| // return PrintValue::vals(v.a, v.b, v.c, v.d); |
| // } |
| // }; |
| // } |
| template<typename ... ARGS> |
| static std::vector<Value*> vals(ARGS... v) |
| { |
| std::vector< std::vector<Value*> > lists = {val(v)...}; |
| std::vector<Value*> joined; |
| for (const auto& list : lists) |
| { |
| joined.insert(joined.end(), list.begin(), list.end()); |
| } |
| return joined; |
| } |
| |
| // returns the printf format specifier for the given type via the |
| // PrintValue::Ty<T> specialization. |
| template <typename T> |
| static std::string fmt(const T& v) { return Ty<T>::fmt(v); } |
| |
| // returns the printf value for the given type with a |
| // PrintValue::Ty<T> specialization. |
| template <typename T> |
| static std::vector<Value*> val(const T& v) { return Ty<T>::val(v); } |
| }; |
| |
| // PrintValue::Ty<T> specializations for basic types. |
| template <> struct PrintValue::Ty<const char*> |
| { |
| static std::string fmt(const char* v) { return "%s"; } |
| static std::vector<Value*> val(const char* v); |
| }; |
| template <> struct PrintValue::Ty<std::string> |
| { |
| static std::string fmt(const std::string& v) { return PrintValue::Ty<const char*>::fmt(v.c_str()); } |
| static std::vector<Value*> val(const std::string& v) { return PrintValue::Ty<const char*>::val(v.c_str()); } |
| }; |
| |
| // PrintValue::Ty<T> specializations for standard Reactor types. |
| template <> struct PrintValue::Ty<Bool> |
| { |
| static std::string fmt(const RValue<Bool>& v) { return "%d"; } |
| static std::vector<Value*> val(const RValue<Bool>& v) { return {v.value}; } |
| }; |
| template <> struct PrintValue::Ty<Byte> |
| { |
| static std::string fmt(const RValue<Byte>& v) { return "%d"; } |
| static std::vector<Value*> val(const RValue<Byte>& v); |
| }; |
| template <> struct PrintValue::Ty<Byte4> |
| { |
| static std::string fmt(const RValue<Byte4>& v) { return "[%d, %d, %d, %d]"; } |
| static std::vector<Value*> val(const RValue<Byte4>& v); |
| }; |
| template <> struct PrintValue::Ty<Int> |
| { |
| static std::string fmt(const RValue<Int>& v) { return "%d"; } |
| static std::vector<Value*> val(const RValue<Int>& v); |
| }; |
| template <> struct PrintValue::Ty<Int2> |
| { |
| static std::string fmt(const RValue<Int>& v) { return "[%d, %d]"; } |
| static std::vector<Value*> val(const RValue<Int2>& v); |
| }; |
| template <> struct PrintValue::Ty<Int4> |
| { |
| static std::string fmt(const RValue<Int4>& v) { return "[%d, %d, %d, %d]"; } |
| static std::vector<Value*> val(const RValue<Int4>& v); |
| }; |
| template <> struct PrintValue::Ty<UInt> |
| { |
| static std::string fmt(const RValue<UInt>& v) { return "%u"; } |
| static std::vector<Value*> val(const RValue<UInt>& v); |
| }; |
| template <> struct PrintValue::Ty<UInt2> |
| { |
| static std::string fmt(const RValue<UInt>& v) { return "[%u, %u]"; } |
| static std::vector<Value*> val(const RValue<UInt2>& v); |
| }; |
| template <> struct PrintValue::Ty<UInt4> |
| { |
| static std::string fmt(const RValue<UInt4>& v) { return "[%u, %u, %u, %u]"; } |
| static std::vector<Value*> val(const RValue<UInt4>& v); |
| }; |
| template <> struct PrintValue::Ty<Short> |
| { |
| static std::string fmt(const RValue<Short>& v) { return "%d"; } |
| static std::vector<Value*> val(const RValue<Short>& v); |
| }; |
| template <> struct PrintValue::Ty<Short4> |
| { |
| static std::string fmt(const RValue<Short4>& v) { return "[%d, %d, %d, %d]"; } |
| static std::vector<Value*> val(const RValue<Short4>& v); |
| }; |
| template <> struct PrintValue::Ty<UShort> |
| { |
| static std::string fmt(const RValue<UShort>& v) { return "%u"; } |
| static std::vector<Value*> val(const RValue<UShort>& v); |
| }; |
| template <> struct PrintValue::Ty<UShort4> |
| { |
| static std::string fmt(const RValue<UShort4>& v) { return "[%u, %u, %u, %u]"; } |
| static std::vector<Value*> val(const RValue<UShort4>& v); |
| }; |
| template <> struct PrintValue::Ty<Float> |
| { |
| static std::string fmt(const RValue<Float>& v) { return "[%f]"; } |
| static std::vector<Value*> val(const RValue<Float>& v); |
| }; |
| template <> struct PrintValue::Ty<Float4> |
| { |
| static std::string fmt(const RValue<Float4>& v) { return "[%f, %f, %f, %f]"; } |
| static std::vector<Value*> val(const RValue<Float4>& v); |
| }; |
| template <> struct PrintValue::Ty<Long> |
| { |
| static std::string fmt(const RValue<Long>& v) { return "%lld"; } |
| static std::vector<Value*> val(const RValue<Long>& v) { return {v.value}; } |
| }; |
| template <typename T> struct PrintValue::Ty< Pointer<T> > |
| { |
| static std::string fmt(const RValue<Pointer<T>>& v) { return "%p"; } |
| static std::vector<Value*> val(const RValue<Pointer<T>>& v) { return {v.value}; } |
| }; |
| template <typename T> struct PrintValue::Ty< Reference<T> > |
| { |
| static std::string fmt(const Reference<T>& v) { return PrintValue::Ty<T>::fmt(v); } |
| static std::vector<Value*> val(const Reference<T>& v) { return PrintValue::Ty<T>::val(v); } |
| }; |
| template <typename T> struct PrintValue::Ty< RValue<T> > |
| { |
| static std::string fmt(const RValue<T>& v) { return PrintValue::Ty<T>::fmt(v); } |
| static std::vector<Value*> val(const RValue<T>& v) { return PrintValue::Ty<T>::val(v); } |
| }; |
| |
| // Printv emits a call to printf() using the function, file and line, |
| // message and optional values. |
| // See Printv below. |
| void Printv(const char* function, const char* file, int line, const char* msg, std::initializer_list<PrintValue> vals); |
| |
| // Printv emits a call to printf() using the provided message and optional |
| // values. |
| // Printf replaces any bracketed indices in the message with string |
| // representations of the corresponding value in vals. |
| // For example: |
| // Printv("{0} and {1}", "red", "green"); |
| // Would print the string: |
| // "red and green" |
| // Arguments can be indexed in any order. |
| // Invalid indices are not substituted. |
| inline void Printv(const char* msg, std::initializer_list<PrintValue> vals) |
| { |
| Printv(nullptr, nullptr, 0, msg, vals); |
| } |
| |
| // Print is a wrapper over Printv that wraps the variadic arguments into an |
| // initializer_list before calling Printv. |
| template <typename ... ARGS> |
| void Print(const char* msg, const ARGS& ... vals) { Printv(msg, {vals...}); } |
| |
| // Print is a wrapper over Printv that wraps the variadic arguments into an |
| // initializer_list before calling Printv. |
| template <typename ... ARGS> |
| void Print(const char* function, const char* file, int line, const char* msg, const ARGS& ... vals) |
| { |
| Printv(function, file, line, msg, {vals...}); |
| } |
| |
| // RR_LOG is a macro that calls Print(), automatically populating the |
| // function, file and line parameters and appending a newline to the string. |
| // |
| // RR_LOG() is intended to be used for debugging JIT compiled code, and is |
| // not intended for production use. |
| #if defined(_WIN32) |
| #define RR_LOG(msg, ...) Print(__FUNCSIG__, __FILE__, static_cast<int>(__LINE__), msg "\n", ##__VA_ARGS__) |
| #else |
| #define RR_LOG(msg, ...) Print(__PRETTY_FUNCTION__, __FILE__, static_cast<int>(__LINE__), msg "\n", ##__VA_ARGS__) |
| #endif |
| |
| // Macro magic to perform variadic dispatch. |
| // See: https://renenyffenegger.ch/notes/development/languages/C-C-plus-plus/preprocessor/macros/__VA_ARGS__/count-arguments |
| // Note, this doesn't attempt to use the ##__VA_ARGS__ trick to handle 0 |
| #define RR_MSVC_EXPAND_BUG(X) X // Helper macro to force expanding __VA_ARGS__ to satisfy MSVC compiler. |
| #define RR_GET_NTH_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, N, ...) N |
| #define RR_COUNT_ARGUMENTS(...) RR_MSVC_EXPAND_BUG(RR_GET_NTH_ARG(__VA_ARGS__, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)) |
| static_assert(1 == RR_COUNT_ARGUMENTS(a), "RR_COUNT_ARGUMENTS broken"); // Sanity checks. |
| static_assert(2 == RR_COUNT_ARGUMENTS(a, b), "RR_COUNT_ARGUMENTS broken"); |
| static_assert(3 == RR_COUNT_ARGUMENTS(a, b, c), "RR_COUNT_ARGUMENTS broken"); |
| |
| // RR_WATCH_FMT(...) resolves to a string literal that lists all the |
| // arguments by name. This string can be passed to LOG() to print each of |
| // the arguments with their name and value. |
| // |
| // RR_WATCH_FMT(...) uses the RR_COUNT_ARGUMENTS helper macro to delegate to a |
| // corresponding RR_WATCH_FMT_n specialization macro below. |
| #define RR_WATCH_CONCAT(a, b) a ## b |
| #define RR_WATCH_CONCAT2(a, b) RR_WATCH_CONCAT(a, b) |
| #define RR_WATCH_FMT(...) RR_MSVC_EXPAND_BUG(RR_WATCH_CONCAT2(RR_WATCH_FMT_, RR_COUNT_ARGUMENTS(__VA_ARGS__))(__VA_ARGS__)) |
| #define RR_WATCH_FMT_1(_1) "\n " #_1 ": {0}" |
| #define RR_WATCH_FMT_2(_1, _2) RR_WATCH_FMT_1(_1) "\n " #_2 ": {1}" |
| #define RR_WATCH_FMT_3(_1, _2, _3) RR_WATCH_FMT_2(_1, _2) "\n " #_3 ": {2}" |
| #define RR_WATCH_FMT_4(_1, _2, _3, _4) RR_WATCH_FMT_3(_1, _2, _3) "\n " #_4 ": {3}" |
| #define RR_WATCH_FMT_5(_1, _2, _3, _4, _5) RR_WATCH_FMT_4(_1, _2, _3, _4) "\n " #_5 ": {4}" |
| #define RR_WATCH_FMT_6(_1, _2, _3, _4, _5, _6) RR_WATCH_FMT_5(_1, _2, _3, _4, _5) "\n " #_6 ": {5}" |
| #define RR_WATCH_FMT_7(_1, _2, _3, _4, _5, _6, _7) RR_WATCH_FMT_6(_1, _2, _3, _4, _5, _6) "\n " #_7 ": {6}" |
| #define RR_WATCH_FMT_8(_1, _2, _3, _4, _5, _6, _7, _8) RR_WATCH_FMT_7(_1, _2, _3, _4, _5, _6, _7) "\n " #_8 ": {7}" |
| #define RR_WATCH_FMT_9(_1, _2, _3, _4, _5, _6, _7, _8, _9) RR_WATCH_FMT_8(_1, _2, _3, _4, _5, _6, _7, _8) "\n " #_9 ": {8}" |
| #define RR_WATCH_FMT_10(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10) RR_WATCH_FMT_9(_1, _2, _3, _4, _5, _6, _7, _8, _9) "\n " #_10 ": {9}" |
| #define RR_WATCH_FMT_11(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) RR_WATCH_FMT_10(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10) "\n " #_11 ": {10}" |
| #define RR_WATCH_FMT_12(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) RR_WATCH_FMT_11(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) "\n " #_12 ": {11}" |
| |
| // RR_WATCH() is a helper that prints the name and value of all the supplied |
| // arguments. |
| // For example, if you had the Int and bool variables 'foo' and 'bar' that |
| // you want to print, you can simply write: |
| // RR_WATCH(foo, bar) |
| // When this JIT compiled code is executed, it will print the string |
| // "foo: 1, bar: true" to stdout. |
| // |
| // RR_WATCH() is intended to be used for debugging JIT compiled code, and |
| // is not intended for production use. |
| #define RR_WATCH(...) RR_LOG(RR_WATCH_FMT(__VA_ARGS__), __VA_ARGS__) |
| |
| } // namespace rr |
| |
| #endif // ENABLE_RR_PRINT |
| |
| #endif // rr_Print_hpp |