MathFunctionImpl< VectorWidth, MathOp::Cos > 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::Cos >

Definition at line 476 of file Math.hpp.

Member Function Documentation

generate()

template<int VectorWidth>

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

inlinestatic

Definition at line 477 of file Math.hpp.

                                                                           {
        constexpr auto OP_INFO = get_math_op_info(MathOp::Cos);
        // 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_cos_c2 = gen->getConstant(-0.4999999701976776F);
                auto* float_cos_c4 = gen->getConstant(0.04166652262210846F);
                auto* float_cos_c6 = gen->getConstant(-0.001388676579343155F);
                auto* float_cos_c8 = gen->getConstant(2.4390448881604243e-05F);
                // NOLINTEND(cppcoreguidelines-avoid-magic-numbers)
                auto* one_float = gen->getConstant(1.0F);
                llvm::Value* sign = gen->getInt32Constant(0);
                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_cos_c8, float_cos_c6});
                t3 = gen->createIntrinsicCall(llvm::Intrinsic::fma,
                                              {t3, t2, float_cos_c4});
                t3 = gen->createIntrinsicCall(llvm::Intrinsic::fma,
                                              {t3, t2, float_cos_c2});
                t1 = gen->createIntrinsicCall(llvm::Intrinsic::fma,
                                              {t3, t2, one_float});
                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 Cos, and get_math_op_info().

---

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

• llvmexpr/codegen/llvm/Math.hpp