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

Definition at line 305 of file Math.hpp.

Member Function Documentation

generate()

template<int VectorWidth>

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

inlinestatic

Definition at line 306 of file Math.hpp.

                                                                           {
        constexpr auto OP_INFO = get_math_op_info(MathOp::Log);
        // https://github.com/vapoursynth/vapoursynth/blob/2a3d3657320ca505c784b98f10e7cd9649d6169a/src/core/expr/jitcompiler_x86.cpp#L671
        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* min_norm_pos = gen->getInt32Constant(0x00800000);
                auto* inv_mant_mask = gen->getInt32Constant(~0x7F800000);
                auto* sqrt_1_2 = gen->getConstant(0.707106781186547524F);
                auto* log_p0 = gen->getConstant(7.0376836292E-2F);
                auto* log_p1 = gen->getConstant(-1.1514610310E-1F);
                auto* log_p2 = gen->getConstant(1.1676998740E-1F);
                auto* log_p3 = gen->getConstant(-1.2420140846E-1F);
                auto* log_p4 = gen->getConstant(1.4249322787E-1F);
                auto* log_p5 = gen->getConstant(-1.6668057665E-1F);
                auto* log_p6 = gen->getConstant(2.0000714765E-1F);
                auto* log_p7 = gen->getConstant(-2.4999993993E-1F);
                auto* log_p8 = gen->getConstant(3.3333331174E-1F);
                auto* log_q2 = gen->getConstant(0.693359375F);
                auto* log_q1 = gen->getConstant(-2.12194440e-4F);
                auto* one = gen->getConstant(1.0F);
                auto* neg_half = gen->getConstant(-0.5F);
                auto* const_0x7f = gen->getInt32Constant(0x7F);
                auto* const_23 = gen->getInt32Constant(23);
                // NOLINTEND(cppcoreguidelines-avoid-magic-numbers)
                auto* is_one = gen->builder.CreateFCmpOEQ(x, one);
                auto* min_norm_pos_float = gen->builder.CreateBitCast(
                    min_norm_pos, gen->getFloatType());
                x = gen->createIntrinsicCall(llvm::Intrinsic::maxnum,
                                             {x, min_norm_pos_float});
                auto* x_as_int =
                    gen->builder.CreateBitCast(x, gen->getInt32Type());
                auto* emm0i = gen->builder.CreateLShr(x_as_int, const_23);
                auto* x_masked =
                    gen->builder.CreateAnd(x_as_int, inv_mant_mask);
                auto* half_as_int = gen->builder.CreateBitCast(
                    gen->getConstant(
                        0.5F), // NOLINT(cppcoreguidelines-avoid-magic-numbers)
                    gen->getInt32Type()); // NOLINT(cppcoreguidelines-avoid-magic-numbers)
                x_masked = gen->builder.CreateOr(x_masked, half_as_int);
                x = gen->builder.CreateBitCast(x_masked, gen->getFloatType());
                emm0i = gen->builder.CreateSub(emm0i, const_0x7f);
                auto* emm0 =
                    gen->builder.CreateSIToFP(emm0i, gen->getFloatType());
                emm0 = gen->builder.CreateFAdd(emm0, one);
                auto* mask = gen->builder.CreateFCmpOLT(x, sqrt_1_2);
                auto* ext_mask =
                    gen->builder.CreateSExt(mask, gen->getInt32Type());
                x_as_int = gen->builder.CreateBitCast(x, gen->getInt32Type());
                auto* etmp_as_int = gen->builder.CreateAnd(ext_mask, x_as_int);
                auto* etmp = gen->builder.CreateBitCast(etmp_as_int,
                                                        gen->getFloatType());
                x = gen->builder.CreateFSub(x, one);
                auto* one_as_int =
                    gen->builder.CreateBitCast(one, gen->getInt32Type());
                auto* maskf_as_int =
                    gen->builder.CreateAnd(ext_mask, one_as_int);
                auto* maskf = gen->builder.CreateBitCast(maskf_as_int,
                                                         gen->getFloatType());
                emm0 = gen->builder.CreateFSub(emm0, maskf);
                x = gen->builder.CreateFAdd(x, etmp);
                auto* z = gen->builder.CreateFMul(x, x);
                llvm::Value* y = log_p0;
                y = gen->createIntrinsicCall(llvm::Intrinsic::fma,
                                             {y, x, log_p1});
                y = gen->createIntrinsicCall(llvm::Intrinsic::fma,
                                             {y, x, log_p2});
                y = gen->createIntrinsicCall(llvm::Intrinsic::fma,
                                             {y, x, log_p3});
                y = gen->createIntrinsicCall(llvm::Intrinsic::fma,
                                             {y, x, log_p4});
                y = gen->createIntrinsicCall(llvm::Intrinsic::fma,
                                             {y, x, log_p5});
                y = gen->createIntrinsicCall(llvm::Intrinsic::fma,
                                             {y, x, log_p6});
                y = gen->createIntrinsicCall(llvm::Intrinsic::fma,
                                             {y, x, log_p7});
                y = gen->createIntrinsicCall(llvm::Intrinsic::fma,
                                             {y, x, log_p8});
                y = gen->builder.CreateFMul(y, x);
                y = gen->builder.CreateFMul(y, z);
                y = gen->createIntrinsicCall(llvm::Intrinsic::fma,
                                             {emm0, log_q1, y});
                y = gen->createIntrinsicCall(llvm::Intrinsic::fma,
                                             {z, neg_half, y});
                x = gen->builder.CreateFAdd(x, y);
                x = gen->createIntrinsicCall(llvm::Intrinsic::fma,
                                             {emm0, log_q2, x});
                x_as_int = gen->builder.CreateBitCast(x, gen->getInt32Type());
                auto* ext_is_one =
                    gen->builder.CreateSExt(is_one, gen->getInt32Type());
                auto* not_ext_is_one = gen->builder.CreateNot(ext_is_one);
                auto* result_as_int =
                    gen->builder.CreateAnd(not_ext_is_one, x_as_int);
                x = gen->builder.CreateBitCast(result_as_int,
                                               gen->getFloatType());
                return x;
            });
    }

References get_math_op_info(), and Log.

---

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

• llvmexpr/codegen/llvm/Math.hpp