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

Inheritance diagram for SingleExprIRGenerator:

Collaboration diagram for SingleExprIRGenerator:

[legend]

Public Member Functions
	SingleExprIRGenerator (const std::vector< Token > &tokens_in, const VSVideoInfo out_vi, const std::vector< const VSVideoInfo > &in_vi, bool mirror, const std::map< std::pair< int, std::string >, int > &p_map, const std::vector< std::string > &output_props, const analysis::ExpressionAnalysisResults &analysis_results_in, llvm::LLVMContext &context_ref, llvm::Module &module_ref, llvm::IRBuilder<> &builder_ref, MathLibraryManager &math_mgr, std::string func_name_in, int approx_math_in)
Public Member Functions inherited from IRGeneratorBase
	IRGeneratorBase (const std::vector< Token > &tokens_in, const VSVideoInfo out_vi, const std::vector< const VSVideoInfo > &in_vi, int width_in, int height_in, bool mirror, const std::map< std::pair< int, std::string >, int > &p_map, const analysis::ExpressionAnalysisResults &analysis_results_in, llvm::LLVMContext &context_ref, llvm::Module &module_ref, llvm::IRBuilder<> &builder_ref, MathLibraryManager &math_mgr, std::string func_name_in, int approx_math_in)
virtual	~IRGeneratorBase ()=default
	IRGeneratorBase (const IRGeneratorBase &)=delete
IRGeneratorBase &	operator= (const IRGeneratorBase &)=delete
	IRGeneratorBase (IRGeneratorBase &&)=delete
IRGeneratorBase &	operator= (IRGeneratorBase &&)=delete
void	generate ()

Protected Member Functions
void	defineFunctionSignature () override
void	generateLoops () override
bool	processModeSpecificToken (const Token &token, std::vector< llvm::Value * > &rpn_stack, llvm::Value x, llvm::Value y, llvm::Value x_fp, llvm::Value y_fp, bool no_x_bounds_check) override
void	finalizeAndStoreResult (llvm::Value result_val, llvm::Value x, llvm::Value *y) override
Protected Member Functions inherited from IRGeneratorBase
llvm::AllocaInst *	createAllocaInEntry (llvm::Type *type, const std::string &name)
template<typename... Args>
llvm::Value *	createIntrinsicCall (llvm::Intrinsic::ID intrinsic_id, Args... args)
void	assumeAligned (llvm::Value *ptr_value, unsigned alignment)
template<typename MemInstT>
void	setMemoryInstAttrs (MemInstT *inst, unsigned alignment, int rwptr_index)
llvm::Value *	getFinalCoord (llvm::Value coord, llvm::Value max_dim, bool use_mirror)
llvm::Value *	generateLoadFromRowPtr (llvm::Value row_ptr, int clip_idx, llvm::Value x, int rel_x, bool use_mirror, bool no_x_bounds_check)
void	addLoopMetadata (llvm::BranchInst *loop_br)
llvm::Value *	generatePixelLoad (int clip_idx, llvm::Value x, llvm::Value y, bool mirror)
void	generatePixelStore (llvm::Value value_to_store, llvm::Value x, llvm::Value *y)
void	generateIRFromTokens (llvm::Value x, llvm::Value y, llvm::Value x_fp, llvm::Value y_fp, bool no_x_bounds_check)
bool	processCommonToken (const Token &token, std::vector< llvm::Value * > &rpn_stack, llvm::Type float_ty, llvm::Type i32_ty, bool use_approx_math)

Additional Inherited Members
Protected Attributes inherited from IRGeneratorBase
const std::vector< Token > &	tokens
const VSVideoInfo *	vo
const std::vector< const VSVideoInfo * > &	vi
int	num_inputs
int	width
int	height
bool	mirror_boundary
const std::map< std::pair< int, std::string >, int > &	prop_map
const analysis::ExpressionAnalysisResults &	analysis_results
std::string	func_name
int	approx_math
llvm::LLVMContext &	context
llvm::Module &	module
llvm::IRBuilder &	builder
MathLibraryManager &	math_manager
llvm::Function *	func
llvm::Value *	rwptrs_arg
llvm::Value *	strides_arg
llvm::Value *	props_arg
std::vector< llvm::Value * >	preloaded_base_ptrs
std::vector< llvm::Value * >	preloaded_strides
llvm::MDNode *	alias_scope_domain
std::vector< llvm::MDNode * >	alias_scopes
std::vector< llvm::MDNode * >	alias_scope_lists
std::vector< llvm::MDNode * >	noalias_scope_lists
std::map< analysis::RelYAccess, llvm::Value * >	row_ptr_cache

Detailed Description

This file is part of Vapoursynth-llvmexpr.

Vapoursynth-llvmexpr is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

Vapoursynth-llvmexpr is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with Vapoursynth-llvmexpr. If not, see https://www.gnu.org/licenses/.

Definition at line 25 of file SingleExprIRGenerator.hpp.

Constructor & Destructor Documentation

◆ SingleExprIRGenerator()

SingleExprIRGenerator::SingleExprIRGenerator	(	const std::vector< Token > &	tokens_in,
		const VSVideoInfo *	out_vi,
		const std::vector< const VSVideoInfo * > &	in_vi,
		bool	mirror,
		const std::map< std::pair< int, std::string >, int > &	p_map,
		const std::vector< std::string > &	output_props,
		const analysis::ExpressionAnalysisResults &	analysis_results_in,
		llvm::LLVMContext &	context_ref,
		llvm::Module &	module_ref,
		llvm::IRBuilder<> &	builder_ref,
		MathLibraryManager &	math_mgr,
		std::string	func_name_in,
		int	approx_math_in )

This file is part of Vapoursynth-llvmexpr.

Vapoursynth-llvmexpr is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

Vapoursynth-llvmexpr is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with Vapoursynth-llvmexpr. If not, see https://www.gnu.org/licenses/.

Definition at line 30 of file SingleExprIRGenerator.cpp.

    : IRGeneratorBase(tokens_in, out_vi, in_vi, out_vi->width, out_vi->height,
                      mirror, p_map, analysis_results_in, context_ref,
                      module_ref, builder_ref, math_mgr,
                      std::move(func_name_in), approx_math_in),
      output_props_list(output_props) {
 
    for (size_t i = 0; i < output_props_list.size(); ++i) {
        output_prop_map[output_props_list[i]] = static_cast<int>(i);
    }
}

References IRGeneratorBase::height, IRGeneratorBase::IRGeneratorBase(), and IRGeneratorBase::width.

Member Function Documentation

◆ defineFunctionSignature()

void SingleExprIRGenerator::defineFunctionSignature ( )

overrideprotectedvirtual

Implements IRGeneratorBase.

Definition at line 50 of file SingleExprIRGenerator.cpp.

                                                    {
    llvm::Type* void_ty = llvm::Type::getVoidTy(context);
    llvm::Type* ptr_ty = llvm::PointerType::get(context, 0);
    llvm::Type* context_ptr_ty = ptr_ty; // opaque pointer (void*)
    llvm::Type* i8_ptr_ptr_ty = ptr_ty; // opaque pointer (represents uint8_t**)
    llvm::Type* i32_ptr_ty = ptr_ty;    // opaque pointer (represents int32_t*)
    llvm::Type* float_ptr_ty = ptr_ty;  // opaque pointer (represents float*)
 
    llvm::FunctionType* func_ty = llvm::FunctionType::get(
        void_ty, {context_ptr_ty, i8_ptr_ptr_ty, i32_ptr_ty, float_ptr_ty},
        false);
 
    func = llvm::Function::Create(func_ty, llvm::Function::ExternalLinkage,
                                  func_name, &module);
    func->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::None);
 
    context_arg = func->getArg(0);
    context_arg->setName("context");
    rwptrs_arg = func->getArg(1);
    rwptrs_arg->setName("rwptrs");
    strides_arg = func->getArg(2);
    strides_arg->setName("strides");
    props_arg = func->getArg(3);
    props_arg->setName("props");
 
    func->addParamAttr(2, llvm::Attribute::ReadOnly); // strides (int32_t*)
 
    // Declare Host API functions for dynamic array management
    llvm::Type* i64_ty = builder.getInt64Ty();
    llvm::Type* i8_ptr_ty = ptr_ty;
 
    // float* llvmexpr_ensure_buffer(const char* name, int64_t size)
    llvm::FunctionType* ensure_buffer_ty =
        llvm::FunctionType::get(float_ptr_ty, {i8_ptr_ty, i64_ty}, false);
    llvmexpr_ensure_buffer_func = llvm::Function::Create(
        ensure_buffer_ty, llvm::Function::ExternalLinkage,
        "llvmexpr_ensure_buffer", &module);
 
    // int64_t llvmexpr_get_buffer_size(const char* name)
    llvm::FunctionType* get_buffer_size_ty =
        llvm::FunctionType::get(i64_ty, {i8_ptr_ty}, false);
    llvmexpr_get_buffer_size_func = llvm::Function::Create(
        get_buffer_size_ty, llvm::Function::ExternalLinkage,
        "llvmexpr_get_buffer_size", &module);
}

References IRGeneratorBase::builder, IRGeneratorBase::context, IRGeneratorBase::func, IRGeneratorBase::func_name, IRGeneratorBase::module, IRGeneratorBase::props_arg, IRGeneratorBase::rwptrs_arg, and IRGeneratorBase::strides_arg.

◆ finalizeAndStoreResult()

void SingleExprIRGenerator::finalizeAndStoreResult	(	llvm::Value *	result_val,
		llvm::Value *	x,
		llvm::Value *	y )

overrideprotectedvirtual

Implements IRGeneratorBase.

Definition at line 538 of file SingleExprIRGenerator.cpp.

                                   {
    // No-op for SingleExpr, all stores are explicit
}

◆ generateLoops()

void SingleExprIRGenerator::generateLoops ( )

overrideprotectedvirtual

Implements IRGeneratorBase.

Definition at line 96 of file SingleExprIRGenerator.cpp.

                    { // TODO: rename this. Nothing to do with loops here.
    llvm::BasicBlock* entry_bb =
        llvm::BasicBlock::Create(context, "entry", func);
    builder.SetInsertPoint(entry_bb);
 
    // Pre-load all plane pointers and strides
    plane_base_ptrs.resize(num_inputs + 1);
    plane_strides.resize(num_inputs + 1);
    const int num_planes = // NOLINT(cppcoreguidelines-init-variables)
        vo->format.numPlanes;
    for (int i = 0; i <= num_inputs; ++i) {
        plane_base_ptrs[i].resize(num_planes);
        plane_strides[i].resize(num_planes);
        for (int p = 0; p < num_planes; ++p) {
            int flat_idx = (i * num_planes) + p;
            llvm::Value* base_ptr_i = builder.CreateLoad(
                llvm::PointerType::get(context, 0),
                builder.CreateGEP(llvm::PointerType::get(context, 0),
                                  rwptrs_arg, builder.getInt32(flat_idx)));
            llvm::Value* stride_i = builder.CreateLoad(
                builder.getInt32Ty(),
                builder.CreateGEP(builder.getInt32Ty(), strides_arg,
                                  builder.getInt32(flat_idx)));
            plane_base_ptrs[i][p] = base_ptr_i;
            plane_strides[i][p] = stride_i;
        }
    }
 
    // Aligned loads for properties
    for (const auto& [key, idx] : prop_map) {
        llvm::Value* prop_val = builder.CreateLoad(
            builder.getFloatTy(),
            builder.CreateGEP(builder.getFloatTy(), props_arg,
                              builder.getInt32(idx)));
        const std::string unique_prop_name =
            std::format("prop_{}_{}", key.first, key.second);
        llvm::Value* alloca =
            createAllocaInEntry(builder.getFloatTy(), unique_prop_name);
        builder.CreateStore(prop_val, alloca);
        prop_allocas[unique_prop_name] = alloca;
    }
 
    //NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
    llvm::APInt payload_bits(32, 0x7FC0DEAD);
    llvm::APFloat nan_payload_apf(llvm::APFloat::IEEEsingle(), payload_bits);
    llvm::Value* nan_with_payload =
        llvm::ConstantFP::get(context, nan_payload_apf);
 
    for (const auto& prop_name : output_props_list) {
        const std::string mangled_input_name =
            std::format("prop_0_{}", prop_name);
        if (prop_allocas.contains(mangled_input_name)) {
            prop_allocas[prop_name] = prop_allocas.at(mangled_input_name);
        } else {
            if (!prop_allocas.contains(prop_name)) {
                llvm::Value* alloca =
                    createAllocaInEntry(builder.getFloatTy(), prop_name);
                builder.CreateStore(nan_with_payload, alloca);
                prop_allocas[prop_name] = alloca;
            }
        }
    }
 
    // Only generate IR if there are tokens to process
    if (!tokens.empty()) {
        generateIRFromTokens(nullptr, nullptr, nullptr, nullptr, true);
    }
 
    // Store output properties back
    for (const auto& [name, idx] : output_prop_map) {
        llvm::Value* val =
            builder.CreateLoad(builder.getFloatTy(), prop_allocas.at(name));
        builder.CreateStore(
            val,
            builder.CreateGEP(builder.getFloatTy(), props_arg,
                              builder.getInt32(prop_map.size() + 1 + idx)));
    }
 
    builder.CreateRetVoid();
}

References IRGeneratorBase::builder, IRGeneratorBase::context, IRGeneratorBase::createAllocaInEntry(), IRGeneratorBase::func, IRGeneratorBase::generateIRFromTokens(), IRGeneratorBase::num_inputs, IRGeneratorBase::prop_map, IRGeneratorBase::props_arg, IRGeneratorBase::rwptrs_arg, IRGeneratorBase::strides_arg, IRGeneratorBase::tokens, and IRGeneratorBase::vo.

◆ processModeSpecificToken()

bool SingleExprIRGenerator::processModeSpecificToken	(	const Token &	token,
		std::vector< llvm::Value * > &	rpn_stack,
		llvm::Value *	x,
		llvm::Value *	y,
		llvm::Value *	x_fp,
		llvm::Value *	y_fp,
		bool	no_x_bounds_check )

overrideprotectedvirtual

Implements IRGeneratorBase.

Definition at line 289 of file SingleExprIRGenerator.cpp.

                                             {
    llvm::Type* float_ty = builder.getFloatTy();
    llvm::Type* i32_ty = builder.getInt32Ty();
 
    switch (token.type) {
    case TokenType::ConstantClipWidth: {
        const auto& payload = std::get<TokenPayloadClipDim>(token.payload);
        const VSVideoInfo* vinfo = vi[payload.clip_idx];
        rpn_stack.push_back(
            builder.CreateSIToFP(builder.getInt32(vinfo->width), float_ty));
        return true;
    }
    case TokenType::ConstantClipHeight: {
        const auto& payload = std::get<TokenPayloadClipDim>(token.payload);
        const VSVideoInfo* vinfo = vi[payload.clip_idx];
        rpn_stack.push_back(
            builder.CreateSIToFP(builder.getInt32(vinfo->height), float_ty));
        return true;
    }
    case TokenType::ConstantClipPlaneWidth: {
        const auto& payload = std::get<TokenPayloadClipPlaneDim>(token.payload);
        const VSVideoInfo* vinfo = vi[payload.clip_idx];
        int plane_w = vinfo->width;
        if (vinfo->format.colorFamily == cfYUV && payload.plane_idx > 0) {
            plane_w >>= vinfo->format.subSamplingW;
        }
        rpn_stack.push_back(
            builder.CreateSIToFP(builder.getInt32(plane_w), float_ty));
        return true;
    }
    case TokenType::ConstantClipPlaneHeight: {
        const auto& payload = std::get<TokenPayloadClipPlaneDim>(token.payload);
        const VSVideoInfo* vinfo = vi[payload.clip_idx];
        int plane_h = vinfo->height;
        if (vinfo->format.colorFamily == cfYUV && payload.plane_idx > 0) {
            plane_h >>= vinfo->format.subSamplingH;
        }
        rpn_stack.push_back(
            builder.CreateSIToFP(builder.getInt32(plane_h), float_ty));
        return true;
    }
    case TokenType::ConstantPlaneWidth: {
        const auto& payload = std::get<TokenPayloadPlaneDim>(token.payload);
        int plane_w = vo->width; // NOLINT(cppcoreguidelines-init-variables)
        if (vo->format.colorFamily == cfYUV && payload.plane_idx > 0) {
            plane_w >>= vo->format.subSamplingW;
        }
        rpn_stack.push_back(
            builder.CreateSIToFP(builder.getInt32(plane_w), float_ty));
        return true;
    }
    case TokenType::ConstantPlaneHeight: {
        const auto& payload = std::get<TokenPayloadPlaneDim>(token.payload);
        int plane_h = vo->height; // NOLINT(cppcoreguidelines-init-variables)
        if (vo->format.colorFamily == cfYUV && payload.plane_idx > 0) {
            plane_h >>= vo->format.subSamplingH;
        }
        rpn_stack.push_back(
            builder.CreateSIToFP(builder.getInt32(plane_h), float_ty));
        return true;
    }
    case TokenType::ClipAbsPlane: {
        const auto& payload =
            std::get<TokenPayloadClipAccessPlane>(token.payload);
        llvm::Value* coord_y_f = rpn_stack.back();
        rpn_stack.pop_back();
        llvm::Value* coord_x_f = rpn_stack.back();
        rpn_stack.pop_back();
 
        llvm::Value* coord_y =
            builder.CreateCall(llvm::Intrinsic::getOrInsertDeclaration(
                                   &module, llvm::Intrinsic::rint, {float_ty}),
                               {coord_y_f});
        coord_y = builder.CreateFPToSI(coord_y, i32_ty);
 
        llvm::Value* coord_x =
            builder.CreateCall(llvm::Intrinsic::getOrInsertDeclaration(
                                   &module, llvm::Intrinsic::rint, {float_ty}),
                               {coord_x_f});
        coord_x = builder.CreateFPToSI(coord_x, i32_ty);
 
        rpn_stack.push_back(generatePixelLoadPlane(
            payload.clip_idx, payload.plane_idx, coord_x, coord_y));
        return true;
    }
    case TokenType::StoreAbsPlane: {
        const auto& payload =
            std::get<TokenPayloadStoreAbsPlane>(token.payload);
        llvm::Value* coord_y_f = rpn_stack.back();
        rpn_stack.pop_back();
        llvm::Value* coord_x_f = rpn_stack.back();
        rpn_stack.pop_back();
        llvm::Value* val_to_store = rpn_stack.back();
        rpn_stack.pop_back();
 
        llvm::Value* coord_y =
            builder.CreateCall(llvm::Intrinsic::getOrInsertDeclaration(
                                   &module, llvm::Intrinsic::rint, {float_ty}),
                               {coord_y_f});
        coord_y = builder.CreateFPToSI(coord_y, i32_ty);
 
        llvm::Value* coord_x =
            builder.CreateCall(llvm::Intrinsic::getOrInsertDeclaration(
                                   &module, llvm::Intrinsic::rint, {float_ty}),
                               {coord_x_f});
        coord_x = builder.CreateFPToSI(coord_x, i32_ty);
 
        generatePixelStorePlane(val_to_store, payload.plane_idx, coord_x,
                                coord_y);
        return true;
    }
    case TokenType::PropStore: {
        const auto& payload = std::get<TokenPayloadPropStore>(token.payload);
        if (payload.type == PropWriteType::Delete) {
            // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
            llvm::APInt payload_bits(32, 0x7FC0DE1E); // PROP_DELETE_NAN_PAYLOAD
            llvm::APFloat nan_payload_apf(llvm::APFloat::IEEEsingle(),
                                          payload_bits);
            llvm::Value* nan_with_payload =
                llvm::ConstantFP::get(context, nan_payload_apf);
            builder.CreateStore(nan_with_payload,
                                prop_allocas.at(payload.prop_name));
        } else {
            llvm::Value* val_to_store = rpn_stack.back();
            rpn_stack.pop_back();
            builder.CreateStore(val_to_store,
                                prop_allocas.at(payload.prop_name));
        }
        return true;
    }
    case TokenType::PropAccess: {
        const auto& payload = std::get<TokenPayloadPropAccess>(token.payload);
        if (payload.clip_idx == 0 &&
            output_prop_map.contains(payload.prop_name)) {
            rpn_stack.push_back(builder.CreateLoad(
                float_ty, prop_allocas.at(payload.prop_name)));
        } else {
            const std::string unique_prop_name =
                std::format("prop_{}_{}", payload.clip_idx, payload.prop_name);
            rpn_stack.push_back(builder.CreateLoad(
                float_ty, prop_allocas.at(unique_prop_name)));
        }
        return true;
    }
 
    case TokenType::PropExists: {
        const auto& payload = std::get<TokenPayloadPropAccess>(token.payload);
        llvm::Value* prop_val = nullptr;
        if (payload.clip_idx == 0 &&
            output_prop_map.contains(payload.prop_name)) {
            prop_val = builder.CreateLoad(float_ty,
                                          prop_allocas.at(payload.prop_name));
        } else {
            const std::string unique_prop_name =
                std::format("prop_{}_{}", payload.clip_idx, payload.prop_name);
            if (!prop_allocas.contains(unique_prop_name)) {
                rpn_stack.push_back(llvm::ConstantFP::get(float_ty, 0.0));
                return true;
            }
            prop_val =
                builder.CreateLoad(float_ty, prop_allocas.at(unique_prop_name));
        }
 
        llvm::Value* prop_val_int = builder.CreateBitCast(prop_val, i32_ty);
 
        // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
        llvm::Value* read_nan_payload = builder.getInt32(0x7FC0BEEF);
        llvm::Value* is_read_nan =
            builder.CreateICmpEQ(prop_val_int, read_nan_payload);
 
        // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
        llvm::Value* delete_nan_payload = builder.getInt32(0x7FC0DE1E);
        llvm::Value* is_delete_nan =
            builder.CreateICmpEQ(prop_val_int, delete_nan_payload);
 
        llvm::Value* does_not_exist =
            builder.CreateOr(is_read_nan, is_delete_nan);
 
        llvm::Value* exists_val = builder.CreateSelect(
            does_not_exist, llvm::ConstantFP::get(float_ty, 0.0),
            llvm::ConstantFP::get(float_ty, 1.0));
        rpn_stack.push_back(exists_val);
        return true;
    }
 
    // Array
    case TokenType::ArrayAllocStatic: {
        const auto& payload = std::get<TokenPayloadArrayOp>(token.payload);
        llvm::Value* size_val = builder.getInt64(payload.static_size);
        llvm::Value* name_str =
            builder.CreateGlobalString(payload.name, payload.name + "_name");
        llvm::Value* buffer_ptr = builder.CreateCall(
            llvmexpr_ensure_buffer_func, {name_str, size_val});
        array_ptr_cache[payload.name] = buffer_ptr;
        return true;
    }
 
    case TokenType::ArrayAllocDyn: {
        const auto& payload = std::get<TokenPayloadArrayOp>(token.payload);
        llvm::Value* size_f = rpn_stack.back();
        rpn_stack.pop_back();
 
        llvm::Value* size_val =
            builder.CreateFPToSI(size_f, builder.getInt64Ty());
        llvm::Value* name_str =
            builder.CreateGlobalString(payload.name, payload.name + "_name");
        llvm::Value* buffer_ptr = builder.CreateCall(
            llvmexpr_ensure_buffer_func, {name_str, size_val});
        array_ptr_cache[payload.name] = buffer_ptr;
        return true;
    }
 
    case TokenType::ArrayLoad: {
        const auto& payload = std::get<TokenPayloadArrayOp>(token.payload);
        llvm::Value* idx_f = rpn_stack.back();
        rpn_stack.pop_back();
        llvm::Value* idx = builder.CreateFPToSI(idx_f, i32_ty);
 
        llvm::Value* array_ptr = array_ptr_cache.at(payload.name);
        llvm::Value* elem_ptr = builder.CreateGEP(float_ty, array_ptr, idx);
        llvm::Value* value = builder.CreateLoad(float_ty, elem_ptr);
        rpn_stack.push_back(value);
        return true;
    }
 
    case TokenType::ArrayStore: {
        const auto& payload = std::get<TokenPayloadArrayOp>(token.payload);
        llvm::Value* idx_f = rpn_stack.back();
        rpn_stack.pop_back();
        llvm::Value* value = rpn_stack.back();
        rpn_stack.pop_back();
 
        llvm::Value* idx = builder.CreateFPToSI(idx_f, i32_ty);
 
        llvm::Value* array_ptr = array_ptr_cache.at(payload.name);
        llvm::Value* elem_ptr = builder.CreateGEP(float_ty, array_ptr, idx);
        builder.CreateStore(value, elem_ptr);
        return true;
    }
 
    default:
        return false;
    }
}

References ArrayAllocDyn, ArrayAllocStatic, ArrayLoad, ArrayStore, IRGeneratorBase::builder, ClipAbsPlane, ConstantClipHeight, ConstantClipPlaneHeight, ConstantClipPlaneWidth, ConstantClipWidth, ConstantPlaneHeight, ConstantPlaneWidth, IRGeneratorBase::context, Delete, IRGeneratorBase::module, Token::payload, PropAccess, PropExists, PropStore, StoreAbsPlane, Token::type, IRGeneratorBase::vi, and IRGeneratorBase::vo.

The documentation for this class was generated from the following files:

llvmexpr/codegen/llvm/SingleExprIRGenerator.hpp
llvmexpr/codegen/llvm/SingleExprIRGenerator.cpp

Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ SingleExprIRGenerator()

Member Function Documentation

◆ defineFunctionSignature()

◆ finalizeAndStoreResult()

◆ generateLoops()

◆ processModeSpecificToken()