#include "qemu/osdep.h"
#include "qemu/log.h"
#include "cpu.h"
#include "exec/exec-all.h"
#include "qemu/host-utils.h"
#include "exec/helper-proto.h"

#define glue3(x, y, z) glue(glue(x, y), z)
#define glue4(x, y, z, w) glue(glue3(x, y, z), w)
#define deref(x) *(x)
#define no_cvt(x) (x) /* when in correct type */

static inline void fpu_set_exception(CPUE2KState *env, int mask)
{
    env->fpsr.ef |= mask;
    if (env->fpsr.ef & (~env->fpcr.em & FPCR_EM)) {
        env->fpsr.es = 1;
        env->fpsr.b  = 1;
    }
}

static inline int save_exception_flags(CPUE2KState *env)
{
    int old_flags = get_float_exception_flags(&env->fp_status);
    set_float_exception_flags(0, &env->fp_status);
    return old_flags;
}

static inline void merge_exception_flags(CPUE2KState *env, int old_flags)
{
    int new_flags = get_float_exception_flags(&env->fp_status);
    float_raise((uint8_t)old_flags, &env->fp_status);
    fpu_set_exception(env,
                      ((new_flags & float_flag_invalid ? FPSR_IE : 0) |
                       (new_flags & float_flag_divbyzero ? FPSR_ZE : 0) |
                       (new_flags & float_flag_overflow ? FPSR_OE : 0) |
                       (new_flags & float_flag_underflow ? FPSR_UE : 0) |
                       (new_flags & float_flag_inexact ? FPSR_PE : 0) |
                       (new_flags & float_flag_input_denormal ? FPSR_DE : 0)));
}

void e2k_update_fp_status(CPUE2KState *env)
{
    FloatRoundMode rm;
    int x;
    
    switch(env->fpcr.rc) {
        case FPCR_RC_UP:
            rm = float_round_up;
            break;
        case FPCR_RC_DOWN:
            rm = float_round_down;
            break;
        case FPCR_RC_CHOP:
            rm = float_round_to_zero;
            break;
        case FPCR_RC_NEAR:
            rm = float_round_nearest_even;
            break;
        default:
            qemu_log_mask(LOG_UNIMP, "unknown rounding mode 0x%x\n", env->fpcr.rc);
            abort();
    }
    
    set_float_rounding_mode(rm, &env->fp_status);
        
    switch(env->fpcr.pc) {
        case FPCR_PC_XP: x = floatx80_precision_x; break;
        case FPCR_PC_DP: x = floatx80_precision_d; break;
        case FPCR_PC_SP: x = floatx80_precision_s; break;
        case FPCR_PC_RESERVED:
        default:
            qemu_log_mask(LOG_UNIMP, "unknown precision mode 0x%x\n", env->fpcr.pc);
            abort();
    }
    
    set_floatx80_rounding_precision(x, &env->fp_status);
    
}

#define GENERATE_SIMPLE_FLOAT2_OP(name, function, size) \
    uint##size##_t HELPER(name)(CPUE2KState *env, uint##size##_t x, uint##size##_t y) \
    { \
        int old_flags = save_exception_flags(env); \
        float##size z = float##size##_##function (make_float##size (x), make_float##size (y), &env->fp_status); \
        merge_exception_flags(env, old_flags); \
        return float##size##_val(z); \
    }
    
#define GENERATE_SIMPLE_FLOAT2_OPS_32_64(name, function) \
    GENERATE_SIMPLE_FLOAT2_OP(glue(name, s), function, 32) \
    GENERATE_SIMPLE_FLOAT2_OP(glue(name, d), function, 64)
    
#define GENERATE_CMP_FLOAT2_OP(ret_type, name, expr, op, in_type, cvt_macro) \
    ret_type HELPER(name)(CPUE2KState *env, in_type x, in_type y) \
    { \
        int old_flags = save_exception_flags(env); \
        ret_type z = expr op(cvt_macro(x), cvt_macro(y), &env->fp_status); \
        merge_exception_flags(env, old_flags); \
        return z; \
    }

#define GENERATE_CMP_FLOAT2_OPS_32_64_80(name, expr, op) \
    GENERATE_CMP_FLOAT2_OP(uint32_t, glue3(f, name, s), expr, glue(float32_, op), uint32_t, make_float32) \
    GENERATE_CMP_FLOAT2_OP(uint64_t, glue3(f, name, d), expr, glue(float64_, op), uint64_t, make_float32) \
    GENERATE_CMP_FLOAT2_OP(uint64_t, glue3(fx, name, x), expr, glue(floatx80_, op), floatx80*, deref)

#define GENERATE_CVT_FLOAT1_OP(name, from_t, to_t, size_from, size_to, func_from, func_to) \
    size_to HELPER(name)(CPUE2KState *env, size_from x) \
    {\
        int old_flags = save_exception_flags(env); \
        size_to z = func_to( glue3(from_t, _to_, to_t) (func_from(x), &env->fp_status) );\
        merge_exception_flags(env, old_flags); \
        return z; \
    }

GENERATE_SIMPLE_FLOAT2_OPS_32_64(fadd, add)
GENERATE_SIMPLE_FLOAT2_OPS_32_64(fsub, sub)
GENERATE_SIMPLE_FLOAT2_OPS_32_64(fmin, min)
GENERATE_SIMPLE_FLOAT2_OPS_32_64(fmax, max)
GENERATE_SIMPLE_FLOAT2_OPS_32_64(fmul, mul)
GENERATE_SIMPLE_FLOAT2_OPS_32_64(fdiv, div)
GENERATE_CMP_FLOAT2_OPS_32_64_80(cmpeq,   , eq)
GENERATE_CMP_FLOAT2_OPS_32_64_80(cmpneq, !, eq)
GENERATE_CMP_FLOAT2_OPS_32_64_80(cmple,   , le)
GENERATE_CMP_FLOAT2_OPS_32_64_80(cmpnle, !, le)
GENERATE_CMP_FLOAT2_OPS_32_64_80(cmplt,   , lt)
GENERATE_CMP_FLOAT2_OPS_32_64_80(cmpnlt, !, lt)
GENERATE_CMP_FLOAT2_OPS_32_64_80(cmpuod,  , unordered)
GENERATE_CMP_FLOAT2_OPS_32_64_80(cmpod,  !, unordered)

GENERATE_CVT_FLOAT1_OP(fstois,   float32, int32,   uint32_t, uint32_t, make_float32, no_cvt)
GENERATE_CVT_FLOAT1_OP(istofs,   int32,   float32, uint32_t, uint32_t, no_cvt, float32_val)
GENERATE_CVT_FLOAT1_OP(fstoistr, float32, int32_round_to_zero, uint32_t, uint32_t, make_float32, no_cvt)

GENERATE_CVT_FLOAT1_OP(fdtoid,   float64, int64,   uint64_t, uint64_t, make_float64, no_cvt)
GENERATE_CVT_FLOAT1_OP(idtofd,   int64,   float64, uint64_t, uint64_t, no_cvt, float64_val)
GENERATE_CVT_FLOAT1_OP(fdtoidtr, float64, int64_round_to_zero, uint64_t, uint64_t, make_float64, no_cvt)

GENERATE_CVT_FLOAT1_OP(fstofd,   float32, float64, uint32_t, uint64_t, make_float32, float64_val)
GENERATE_CVT_FLOAT1_OP(fstoid,   float32, int64,   uint32_t, uint64_t, make_float32, no_cvt)
GENERATE_CVT_FLOAT1_OP(istofd,   int32,   float64, uint32_t, uint64_t, no_cvt, float64_val)
GENERATE_CVT_FLOAT1_OP(fstoidtr, float32, int64_round_to_zero, uint32_t, uint64_t, make_float32, no_cvt)

GENERATE_CVT_FLOAT1_OP(fdtofs,   float64, float32, uint64_t, uint32_t, make_float64, float32_val)
GENERATE_CVT_FLOAT1_OP(fdtois,   float64, int32,   uint64_t, uint32_t, make_float64, no_cvt)
GENERATE_CVT_FLOAT1_OP(idtofs,   int64,   float32, uint64_t, uint32_t, no_cvt, float32_val)
GENERATE_CVT_FLOAT1_OP(fdtoistr, float64, int32_round_to_zero, uint64_t, uint32_t, make_float64, no_cvt)

GENERATE_CVT_FLOAT1_OP(fxtofs,   floatx80, float32, floatx80*, uint32_t, deref, float32_val)
GENERATE_CVT_FLOAT1_OP(fxtofd,   floatx80, float64, floatx80*, uint64_t, deref, float64_val)

void HELPER(fstofx)(floatx80 *ret, CPUE2KState *env, uint32_t x)
{
    int old_flags = save_exception_flags(env);
    *ret = float32_to_floatx80(make_float32(x), &env->fp_status);
    merge_exception_flags(env, old_flags);
}

void HELPER(fdtofx)(floatx80 *ret, CPUE2KState *env, uint64_t x)
{
    int old_flags = save_exception_flags(env);
    *ret = float64_to_floatx80(make_float64(x), &env->fp_status);
    merge_exception_flags(env, old_flags);
}

#define GEN_OP2_XX(name, op) \
    void HELPER(name)(CPUE2KState *env, floatx80 *x, floatx80 *y) \
    { \
        int old_flags = save_exception_flags(env); \
        *x = glue(floatx80_, op)(*x, *y, &env->fp_status); \
        merge_exception_flags(env, old_flags); \
    }

GEN_OP2_XX(fxaddxx, add)
GEN_OP2_XX(fxsubxx, sub)
GEN_OP2_XX(fxmulxx, mul)
GEN_OP2_XX(fxdivxx, div)

void HELPER(fxrsubxx)(CPUE2KState *env, floatx80 *x, floatx80 *y)
{
    int old_flags = save_exception_flags(env);
    *x = floatx80_sub(*y, *x, &env->fp_status);
    merge_exception_flags(env, old_flags);
}