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

Definition at line 231 of file Math.hpp.

Member Function Documentation

generate()

template<int VectorWidth>

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

inlinestatic

Definition at line 232 of file Math.hpp.

                                                                           {
        constexpr auto OP_INFO = get_math_op_info(MathOp::Exp);
        // https://github.com/vapoursynth/vapoursynth/blob/2a3d3657320ca505c784b98f10e7cd9649d6169a/src/core/expr/jitcompiler_x86.cpp#L635
        return gen->createFunction(
            OP_INFO.name, OP_INFO.arity,
            [gen](llvm::ArrayRef<llvm::Value*> args) -> llvm::Value* {
                auto* x = args[0];
                // NOLINTBEGIN(cppcoreguidelines-avoid-magic-numbers)
                auto* exp_hi = gen->getConstant(88.3762626647949F);
                auto* exp_lo = gen->getConstant(-88.3762626647949F);
                auto* log2e = gen->getConstant(std::numbers::log2e_v<float>);
                auto* exp_p0 = gen->getConstant(1.9875691500E-4F);
                auto* exp_p1 = gen->getConstant(1.3981999507E-3F);
                auto* exp_p2 = gen->getConstant(8.3334519073E-3F);
                auto* exp_p3 = gen->getConstant(4.1665795894E-2F);
                auto* exp_p4 = gen->getConstant(1.6666665459E-1F);
                auto* exp_p5 = gen->getConstant(5.0000001201E-1F);
                auto* half = gen->getConstant(0.5F);
                auto* one = gen->getConstant(1.0F);
                auto* neg_exp_c1 = gen->getConstant(-0.693359375F);
                auto* neg_exp_c2 = gen->getConstant(2.12194440e-4F);
                auto* const_0x7f = gen->getInt32Constant(0x7F);
                auto* const_23 = gen->getInt32Constant(23);
                // NOLINTEND(cppcoreguidelines-avoid-magic-numbers)
                x = gen->createIntrinsicCall(llvm::Intrinsic::minnum,
                                             {x, exp_hi});
                x = gen->createIntrinsicCall(llvm::Intrinsic::maxnum,
                                             {x, exp_lo});
                auto* fx = gen->createIntrinsicCall(llvm::Intrinsic::fma,
                                                    {log2e, x, half});
                auto* etmp =
                    gen->createIntrinsicCall(llvm::Intrinsic::nearbyint, {fx});
                auto* cmp_gt = gen->builder.CreateFCmpOGT(etmp, fx);
                auto* ext_cmp =
                    gen->builder.CreateSExt(cmp_gt, gen->getInt32Type());
                auto* one_int =
                    gen->builder.CreateBitCast(one, gen->getInt32Type());
                auto* mask_int = gen->builder.CreateAnd(ext_cmp, one_int);
                auto* mask =
                    gen->builder.CreateBitCast(mask_int, gen->getFloatType());
                fx = gen->builder.CreateFSub(etmp, mask);
                x = gen->createIntrinsicCall(llvm::Intrinsic::fma,
                                             {fx, neg_exp_c1, x});
                x = gen->createIntrinsicCall(llvm::Intrinsic::fma,
                                             {fx, neg_exp_c2, x});
                auto* z = gen->builder.CreateFMul(x, x);
                llvm::Value* y = exp_p0;
                y = gen->createIntrinsicCall(llvm::Intrinsic::fma,
                                             {y, x, exp_p1});
                y = gen->createIntrinsicCall(llvm::Intrinsic::fma,
                                             {y, x, exp_p2});
                y = gen->createIntrinsicCall(llvm::Intrinsic::fma,
                                             {y, x, exp_p3});
                y = gen->createIntrinsicCall(llvm::Intrinsic::fma,
                                             {y, x, exp_p4});
                y = gen->createIntrinsicCall(llvm::Intrinsic::fma,
                                             {y, x, exp_p5});
                y = gen->createIntrinsicCall(llvm::Intrinsic::fma, {y, z, x});
                y = gen->builder.CreateFAdd(y, one);
                auto* emm0_float =
                    gen->createIntrinsicCall(llvm::Intrinsic::nearbyint, {fx});
                auto* emm0 =
                    gen->builder.CreateFPToSI(emm0_float, gen->getInt32Type());
                emm0 = gen->builder.CreateAdd(emm0, const_0x7f);
                emm0 = gen->builder.CreateShl(emm0, const_23);
                auto* emm0_as_float =
                    gen->builder.CreateBitCast(emm0, gen->getFloatType());
                x = gen->builder.CreateFMul(y, emm0_as_float);
                return x;
            });
    }

References Exp, and get_math_op_info().

---

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

• llvmexpr/codegen/llvm/Math.hpp