CodeGen_C_prologue.template.cpp

/* MACHINE GENERATED By Halide. */
#if !(__cplusplus >= 201103L || _MSVC_LANG >= 201103L)
#error "This code requires C++11 (or later); please upgrade your compiler."
#endif

#if !defined(__has_builtin)
#define __has_builtin(x) 0
#endif

#include <assert.h>
#include <fenv.h>
#include <float.h>
#include <limits.h>
#include <math.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <type_traits>

extern "C" {
int64_t halide_current_time_ns(void *ctx);
void halide_profiler_pipeline_end(void *, void *);
struct halide_buffer_t;
char *halide_buffer_to_string(char *, char *, const halide_buffer_t *);
}

#ifdef _WIN32
#ifndef _MT
__declspec(dllimport) float __cdecl roundf(float);
__declspec(dllimport) double __cdecl round(double);
#endif
#else
inline float asinh_f32(float x) {
    return asinhf(x);
}
inline float acosh_f32(float x) {
    return acoshf(x);
}
inline float atanh_f32(float x) {
    return atanhf(x);
}
inline double asinh_f64(double x) {
    return asinh(x);
}
inline double acosh_f64(double x) {
    return acosh(x);
}
inline double atanh_f64(double x) {
    return atanh(x);
}
#endif
inline float sqrt_f32(float x) {
    return sqrtf(x);
}
inline float sin_f32(float x) {
    return sinf(x);
}
inline float asin_f32(float x) {
    return asinf(x);
}
inline float cos_f32(float x) {
    return cosf(x);
}
inline float acos_f32(float x) {
    return acosf(x);
}
inline float tan_f32(float x) {
    return tanf(x);
}
inline float atan_f32(float x) {
    return atanf(x);
}
inline float atan2_f32(float x, float y) {
    return atan2f(x, y);
}
inline float sinh_f32(float x) {
    return sinhf(x);
}
inline float cosh_f32(float x) {
    return coshf(x);
}
inline float tanh_f32(float x) {
    return tanhf(x);
}
inline float hypot_f32(float x, float y) {
    return hypotf(x, y);
}
inline float exp_f32(float x) {
    return expf(x);
}
inline float log_f32(float x) {
    return logf(x);
}
inline float pow_f32(float x, float y) {
    return powf(x, y);
}
inline float floor_f32(float x) {
    return floorf(x);
}
inline float ceil_f32(float x) {
    return ceilf(x);
}

inline double sqrt_f64(double x) {
    return sqrt(x);
}
inline double sin_f64(double x) {
    return sin(x);
}
inline double asin_f64(double x) {
    return asin(x);
}
inline double cos_f64(double x) {
    return cos(x);
}
inline double acos_f64(double x) {
    return acos(x);
}
inline double tan_f64(double x) {
    return tan(x);
}
inline double atan_f64(double x) {
    return atan(x);
}
inline double atan2_f64(double x, double y) {
    return atan2(x, y);
}
inline double sinh_f64(double x) {
    return sinh(x);
}
inline double cosh_f64(double x) {
    return cosh(x);
}
inline double tanh_f64(double x) {
    return tanh(x);
}
inline double hypot_f64(double x, double y) {
    return hypot(x, y);
}
inline double exp_f64(double x) {
    return exp(x);
}
inline double log_f64(double x) {
    return log(x);
}
inline double pow_f64(double x, double y) {
    return pow(x, y);
}
inline double floor_f64(double x) {
    return floor(x);
}
inline double ceil_f64(double x) {
    return ceil(x);
}

inline float nan_f32() {
    return NAN;
}
inline float neg_inf_f32() {
    return -INFINITY;
}
inline float inf_f32() {
    return INFINITY;
}
inline bool is_nan_f32(float x) {
    return isnan(x);
}
inline bool is_nan_f64(double x) {
    return isnan(x);
}
inline bool is_inf_f32(float x) {
    return isinf(x);
}
inline bool is_inf_f64(double x) {
    return isinf(x);
}
inline bool is_finite_f32(float x) {
    return isfinite(x);
}
inline bool is_finite_f64(double x) {
    return isfinite(x);
}

template<typename A, typename B>
inline A reinterpret(const B &b) {
    static_assert(sizeof(A) == sizeof(B), "type size mismatch");
    A a;
    memcpy(&a, &b, sizeof(a));
    return a;
}

inline float float_from_bits(uint32_t bits) {
    return reinterpret<float, uint32_t>(bits);
}

template<typename T>
inline int halide_popcount_fallback(T a) {
    int bits_set = 0;
    while (a != 0) {
        bits_set += 1;
        // See: https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetKernighan
        a &= a - 1;
    }
    return bits_set;
}

template<typename T>
inline int halide_popcount(T a) {
    return halide_popcount_fallback<T>(a);
}

template<>
inline int halide_popcount<uint64_t>(uint64_t a) {
#ifdef _MSC_VER
#if defined(_WIN64)
    return __popcnt64(a);
#else
    return __popcnt((uint32_t)(a >> 32)) + __popcnt((uint32_t)(a & 0xffffffff));
#endif
#else
#if defined(__builtin_popcountll)
    static_assert(sizeof(unsigned long long) >= sizeof(uint64_t), "");
    return return __builtin_popcountll(a);
#else
    return halide_popcount_fallback<uint64_t>(a);
#endif
#endif
}

template<typename T>
inline int halide_count_leading_zeros(T a) {
    int leading_zeros = 0;
    int bit = sizeof(a) * 8 - 1;
    while (bit >= 0 && (a & (((T)1) << bit)) == 0) {
        leading_zeros++;
        bit--;
    }
    return leading_zeros;
}

template<typename T>
inline int halide_count_trailing_zeros(T a) {
    int trailing_zeros = 0;
    constexpr int bits = sizeof(a) * 8;
    int bit = 0;
    while (bit < bits && (a & (((T)1) << bit)) == 0) {
        trailing_zeros++;
        bit++;
    }
    return trailing_zeros;
}

template<typename T>
inline T halide_cpp_max(const T &a, const T &b) {
    return (a > b) ? a : b;
}

template<typename T>
inline T halide_cpp_min(const T &a, const T &b) {
    return (a < b) ? a : b;
}

template<typename T>
inline T halide_cpp_fma(const T &a, const T &b, const T &c) {
#if __has_builtin(__builtin_fma)
    return __builtin_fma(a, b, c);
#else
    if (sizeof(T) == sizeof(float)) {
        return fmaf(a, b, c);
    } else {
        return (T)fma((double)a, (double)b, (double)c);
    }
#endif
}

template<typename T>
inline T halide_cpp_fmod(const T &a, const T &b) {
#if __has_builtin(__builtin_fmod)
    return __builtin_fmod(a, b);
#else
    if (sizeof(T) == sizeof(float)) {
        return fmod(a, b);
    } else {
        return (T)fmod((double)a, (double)b);
    }
#endif
}

template<typename T>
inline void halide_maybe_unused(const T &) {
}

template<typename A, typename B>
const B &return_second(const A &a, const B &b) {
    halide_maybe_unused(a);
    return b;
}

namespace {
template<void (*FreeFn)(void *, void *)>
class HalideFreeHelper {
    void *const user_context;
    void *ptr;

public:
    HalideFreeHelper(void *user_context, void *ptr)
        : user_context(user_context), ptr(ptr) {
    }
    ~HalideFreeHelper() {
        free();
    }
    void free() {
        if (ptr) {
            FreeFn(user_context, ptr);
            ptr = nullptr;
        }
    }
};

}  // namespace