FrexpReg.h

Go to the documentation of this file.

// FrexpReg.h:
// -------------------
//

#ifndef __IPSDKUTIL_INSTRUCTIONSET_ARITHMETIC_DETAIL_COMMON_FREXPREG_H__
#define __IPSDKUTIL_INSTRUCTIONSET_ARITHMETIC_DETAIL_COMMON_FREXPREG_H__

#include <IPSDKUtil/IPSDKUtilExports.h>
#include <IPSDKUtil/InstructionSet/RegType.h>
#include <IPSDKUtil/InstructionSet/Arithmetic/detail/SubReg.h>
#include <IPSDKUtil/InstructionSet/Logical/detail/BitwiseAndReg.h>
#include <IPSDKUtil/InstructionSet/Logical/detail/BitwiseAndNotReg.h>
#include <IPSDKUtil/InstructionSet/Logical/detail/BitwiseOrReg.h>
#include <IPSDKUtil/InstructionSet/Logical/detail/ShiftRightReg.h>
#include <IPSDKUtil/InstructionSet/detail/BitwiseCastReg.h>
#include <IPSDKUtil/InstructionSet/detail/AssignReg.h>
#include <IPSDKUtil/Tools/ForceInline.h>

namespace ipsdk {
namespace simd {
namespace detail {


template <eInstructionSet::domain IS>
struct FrexpReg<IS, ipReal32>
{
    static IPSDK_FORCEINLINE
    typename RegType<IS, ipReal32>::Type
    act(const typename RegType<IS, ipReal32>::Type& in,
        typename RegType<IS, ipInt32>::Type& e)
    {
        typename RegType<IS, ipReal32>::Type m;
        act(in, m, e);
        return m;
    }

    static IPSDK_FORCEINLINE
    void
    act(const typename RegType<IS, ipReal32>::Type& in,
        typename RegType<IS, ipReal32>::Type& m,
        typename RegType<IS, ipInt32>::Type& e)
    {
        typedef typename RegType<IS, ipReal32>::Type RegReal32;
        typedef typename RegType<IS, ipInt32>::Type RegInt32;
        
        const ipInt32 scalarMask1 = 0x7F800000;
        const ipInt32 scalarMask2 = 0x3F000000;
        const ipInt32 scalar126 = 0x7E;

        RegInt32 r126;
        RegReal32 tmp, mask1, mask2, eReal32;

        AssignReg<IS, ipReal32>::act(mask1, *reinterpret_cast<const ipReal32*>(&scalarMask1));
        AssignReg<IS, ipReal32>::act(mask2, *reinterpret_cast<const ipReal32*>(&scalarMask2));
        AssignReg<IS, ipInt32>::act(r126, 0x7E);

        BitwiseAndReg<IS, ipReal32>::act(in, mask1, eReal32);
        BitwiseCastReg<IS, ipReal32, ipInt32>::act(eReal32, e);

        BitwiseAndNotReg<IS, ipReal32>::act(in, mask1, tmp);
        ShiftRightReg<IS, ipInt32>::act(e, 23, e);
        SubReg<IS, ipInt32>::act(e, r126, e);

        BitwiseOrReg<IS, ipReal32>::act(tmp, mask2, m);
    }
    
    static IPSDK_FORCEINLINE
    void
    act(const typename RegType<IS, ipReal32>::Type& in,
        typename RegType<IS, ipReal32>::Type& m,
        typename RegType<IS, ipReal32>::Type& e)
    {
        typedef typename RegType<IS, ipReal32>::Type RegReal32;
        typedef typename RegType<IS, ipInt32>::Type RegInt32;
        
        const ipInt32 scalarMask1 = 0x7F800000;
        const ipInt32 scalarMask2 = 0x3F000000;
        const ipInt32 scalar126 = 0x7E;
        RegReal32 mask1, mask2, r126, tmp;

        AssignReg<IS, ipReal32>::act(mask1, *reinterpret_cast<const ipReal32*>(&scalarMask1));
        AssignReg<IS, ipReal32>::act(mask2, *reinterpret_cast<const ipReal32*>(&scalarMask2));
        AssignReg<IS, ipReal32>::act(r126, *reinterpret_cast<const ipReal32*>(&scalar126));

        BitwiseAndReg<IS, ipReal32>::act(in, mask1, e);

        BitwiseAndNotReg<IS, ipReal32>::act(in, mask1, tmp);
        ShiftRightReg<IS, ipReal32>::act(e, 23, e);
        SubReg<IS, ipReal32>::act(e, r126, e);

        BitwiseOrReg<IS, ipReal32>::act(tmp, mask2, m);
    }
};

template <eInstructionSet::domain IS>
struct FrexpReg<IS, ipReal64>
{
    static const ipInt64 s_scalarMask1 = 0x7FF0000000000000;
    static const ipInt64 s_scalarMask2 = 0x3FE0000000000000;
    static const ipInt64 s_scalar1022 = 1022;
    static const ipInt32 s_nbBitsInMantissa = 52;
    
    static IPSDK_FORCEINLINE
    typename RegType<IS, ipReal64>::Type
    act(const typename RegType<IS, ipReal64>::Type& in,
        typename RegType<IS, ipInt64>::Type& e)
    {
        typename RegType<IS, ipReal64>::Type m;
        act(in, m, e);
        return m;
    }

    static IPSDK_FORCEINLINE
    void
    act(const typename RegType<IS, ipReal64>::Type& in,
        typename RegType<IS, ipReal64>::Type& m,
        typename RegType<IS, ipInt64>::Type& e)
    {
        typedef typename RegType<IS, ipReal64>::Type RegReal64;
        typedef typename RegType<IS, ipInt64>::Type RegInt64;
        
        RegInt64 r1022;
        RegReal64 tmp, mask1, mask2, eReal64;

        AssignReg<IS, ipReal64>::act(mask1, *reinterpret_cast<const ipReal64*>(&s_scalarMask1));
        AssignReg<IS, ipReal64>::act(mask2, *reinterpret_cast<const ipReal64*>(&s_scalarMask2));
        AssignReg<IS, ipInt64>::act(r1022, s_scalar1022);

        BitwiseAndReg<IS, ipReal64>::act(in, mask1, eReal64);
        BitwiseCastReg<IS, ipReal64, ipInt64>::act(eReal64, e);

        BitwiseAndNotReg<IS, ipReal64>::act(in, mask1, tmp);
        ShiftRightReg<IS, ipInt64>::act(e, s_nbBitsInMantissa, e);
        SubReg<IS, ipInt64>::act(e, r1022, e);

        BitwiseOrReg<IS, ipReal64>::act(tmp, mask2, m);
    }
    
    static IPSDK_FORCEINLINE
    void
    act(const typename RegType<IS, ipReal64>::Type& in,
        typename RegType<IS, ipReal64>::Type& m,
        typename RegType<IS, ipReal64>::Type& e)
    {
        typedef typename RegType<IS, ipReal64>::Type RegReal64;
        typedef typename RegType<IS, ipInt64>::Type RegInt64;
        
        RegReal64 mask1, mask2, r126, tmp;

        AssignReg<IS, ipReal64>::act(mask1, *reinterpret_cast<const ipReal64*>(&s_scalarMask1));
        AssignReg<IS, ipReal64>::act(mask2, *reinterpret_cast<const ipReal64*>(&s_scalarMask2));
        AssignReg<IS, ipReal64>::act(r126, *reinterpret_cast<const ipReal64*>(&s_scalar1022));

        BitwiseAndReg<IS, ipReal64>::act(in, mask1, e);

        BitwiseAndNotReg<IS, ipReal64>::act(in, mask1, tmp);
        ShiftRightReg<IS, ipReal64>::act(e, 23, e);
        SubReg<IS, ipReal64>::act(e, r126, e);

        BitwiseOrReg<IS, ipReal64>::act(tmp, mask2, m);
    }
};


} // end of namespace detail
} // end of namespace simd
} // end of namespace ipsdk

#endif // __IPSDKUTIL_INSTRUCTIONSET_ARITHMETIC_DETAIL_COMMON_FREXPREG_H__