MathFunctionImpl< VectorWidth, MathOp::Sin > Struct Template Reference

#include <llvmexpr/codegen/llvm/Math.hpp>

Static Public Member Functions
static llvm::Function *	generate (MathFunctionGenerator< VectorWidth > *gen)

Detailed Description

template<int VectorWidth>
struct MathFunctionImpl< VectorWidth, MathOp::Sin >

Definition at line 409 of file Math.hpp.

Member Function Documentation

generate()

template<int VectorWidth>

llvm::Function * MathFunctionImpl< VectorWidth, MathOp::Sin >::generate ( MathFunctionGenerator< VectorWidth > * gen )

inlinestatic

Definition at line 410 of file Math.hpp.

                                                                           {
        constexpr auto OP_INFO = get_math_op_info(MathOp::Sin);
        // https://github.com/vapoursynth/vapoursynth/blob/2a3d3657320ca505c784b98f10e7cd9649d6169a/src/core/expr/jitcompiler_x86.cpp#L813
        return gen->createFunction(
            OP_INFO.name, OP_INFO.arity,
            [gen](llvm::ArrayRef<llvm::Value*> args) -> llvm::Value* {
                auto* x = args[0];
                auto* float_ty = gen->getFloatType();
                auto* int32_ty = gen->getInt32Type();
                auto* float_invpi =
                    gen->getConstant(std::numbers::inv_pi_v<float>);
                // NOLINTBEGIN(cppcoreguidelines-avoid-magic-numbers)
                auto* float_pi1 = gen->getConstant(3.140625F);
                auto* float_pi2 = gen->getConstant(0.0009670257568359375F);
                auto* float_pi3 = gen->getConstant(1.984187252998352e-07F);
                auto* float_pi4 = gen->getConstant(1.273533813134432e-11F);
                auto* float_sin_c3 = gen->getConstant(-0.1666666567325592F);
                auto* float_sin_c5 = gen->getConstant(0.00833307858556509F);
                auto* float_sin_c7 = gen->getConstant(-0.00019807418575510383F);
                auto* float_sin_c9 = gen->getConstant(2.6019030363451748e-06F);
                auto* signmask = gen->getInt32Constant(0x80000000);
                // NOLINTEND(cppcoreguidelines-avoid-magic-numbers)
                llvm::Value* sign = gen->builder.CreateBitCast(x, int32_ty);
                sign = gen->builder.CreateAnd(sign, signmask);
                llvm::Value* t1 =
                    gen->createIntrinsicCall(llvm::Intrinsic::fabs, {x});
                llvm::Value* t2 = gen->builder.CreateFMul(t1, float_invpi);
                llvm::Value* t2_rounded =
                    gen->createIntrinsicCall(llvm::Intrinsic::nearbyint, {t2});
                llvm::Value* t2i =
                    gen->builder.CreateFPToSI(t2_rounded, int32_ty);
                llvm::Value* t4 = gen->builder.CreateShl(
                    t2i, 31); // NOLINT(cppcoreguidelines-avoid-magic-numbers)
                sign = gen->builder.CreateXor(sign, t4);
                t2 = gen->builder.CreateSIToFP(t2i, float_ty);
                t1 = gen->createIntrinsicCall(
                    llvm::Intrinsic::fma,
                    {t2, gen->builder.CreateFNeg(float_pi1), t1});
                t1 = gen->createIntrinsicCall(
                    llvm::Intrinsic::fma,
                    {t2, gen->builder.CreateFNeg(float_pi2), t1});
                t1 = gen->createIntrinsicCall(
                    llvm::Intrinsic::fma,
                    {t2, gen->builder.CreateFNeg(float_pi3), t1});
                t1 = gen->createIntrinsicCall(
                    llvm::Intrinsic::fma,
                    {t2, gen->builder.CreateFNeg(float_pi4), t1});
                t2 = gen->builder.CreateFMul(t1, t1);
                llvm::Value* t3 = gen->createIntrinsicCall(
                    llvm::Intrinsic::fma, {t2, float_sin_c9, float_sin_c7});
                t3 = gen->createIntrinsicCall(llvm::Intrinsic::fma,
                                              {t3, t2, float_sin_c5});
                t3 = gen->createIntrinsicCall(llvm::Intrinsic::fma,
                                              {t3, t2, float_sin_c3});
                t3 = gen->builder.CreateFMul(t3, t2);
                t3 = gen->builder.CreateFMul(t3, t1);
                t1 = gen->builder.CreateFAdd(t1, t3);
                llvm::Value* t1_as_int =
                    gen->builder.CreateBitCast(t1, int32_ty);
                llvm::Value* result_as_int =
                    gen->builder.CreateXor(sign, t1_as_int);
                return gen->builder.CreateBitCast(result_as_int, float_ty);
            });
    }

References get_math_op_info(), and Sin.

---

The documentation for this struct was generated from the following file:

• llvmexpr/codegen/llvm/Math.hpp