analysis::StaticArrayOptPass Class Reference

#include <llvmexpr/analysis/passes/StaticArrayOptPass.hpp>

Inheritance diagram for analysis::StaticArrayOptPass:

Collaboration diagram for analysis::StaticArrayOptPass:

Public Member Functions
const char *	getName () const override
PreservedAnalyses	run (std::vector< Token > &tokens, AnalysisManager &am) override
Public Member Functions inherited from analysis::Pass
	Pass ()=default
virtual	~Pass ()=default
	Pass (const Pass &)=delete
Pass &	operator= (const Pass &)=delete
	Pass (Pass &&)=delete
Pass &	operator= (Pass &&)=delete

Detailed Description

Converts dynamic array allocations to static allocations when possible. This optimization transforms ARRAY_ALLOC_DYN to ARRAY_ALLOC_STATIC when:

1. Array size is known at compile time (via constant propagation)
2. Array size is <= threshold (1024 elements)
3. Array is allocated only once in the entire expression

The transformation involves:

• Changing token type from ARRAY_ALLOC_DYN to ARRAY_ALLOC_STATIC
• Setting the static_size in the payload
• Inserting a DROP instruction to consume the size value from stack

Depends on: ConstPropPass, BlockAnalysisPass

Definition at line 41 of file StaticArrayOptPass.hpp.

Member Function Documentation

getName()

const char * analysis::StaticArrayOptPass::getName ( ) const

inlinenodiscardoverridevirtual

Implements analysis::Pass.

Definition at line 43 of file StaticArrayOptPass.hpp.

                                                       {
        return "Static Array Optimization Pass";
    }

run()

PreservedAnalyses analysis::StaticArrayOptPass::run ( std::vector< Token > & tokens, AnalysisManager & am )

overridevirtual

Implements analysis::TransformationPass.

Definition at line 37 of file StaticArrayOptPass.cpp.

                                                               {
    const auto& const_result = am.getResult<ConstPropPass>();
    const auto& in_stacks = const_result.const_stack_in;
 
    const auto& block_result = am.getResult<BlockAnalysisPass>();
    const auto& cfg_blocks = block_result.cfg_blocks;
 
    std::map<std::string, int> array_alloc_count;
    for (const auto& token : tokens) {
        if (token.type == TokenType::ArrayAllocStatic ||
            token.type == TokenType::ArrayAllocDyn) {
            const auto& payload = std::get<TokenPayloadArrayOp>(token.payload);
            array_alloc_count[payload.name]++;
        }
    }
 
    std::map<int, int> dyn_to_static;
 
    for (size_t block_idx = 0; block_idx < cfg_blocks.size(); ++block_idx) {
        const auto& block = cfg_blocks[block_idx];
 
        auto current_stack = in_stacks[block_idx];
 
        for (int token_idx = block.start_token_idx;
             token_idx < block.end_token_idx; ++token_idx) {
            const auto& token = tokens[token_idx];
            const auto behavior = get_token_behavior(token);
 
            while (current_stack.size() < static_cast<size_t>(behavior.arity)) {
                current_stack.insert(current_stack.begin(), std::nullopt);
            }
 
            std::vector<std::optional<double>> args;
            for (int k = 0; k < behavior.arity; ++k) {
                args.push_back(current_stack.back());
                current_stack.pop_back();
            }
            std::ranges::reverse(args);
 
            if (token.type == TokenType::ArrayAllocDyn) {
                const auto& payload =
                    std::get<TokenPayloadArrayOp>(token.payload);
                // Convert to static allocation if:
                // 1. Size is a compile-time constant (from ConstPropPass)
                // 2. Size <= threshold
                // 3. Only allocated once
                if (args[0].has_value() &&
                    array_alloc_count[payload.name] == 1) {
                    int size = static_cast<int>(args[0].value());
                    if (size > 0 && size <= SINGLEEXPR_STACK_ALLOC_THRESHOLD) {
                        dyn_to_static[token_idx] = size;
                    }
                }
            }
 
            for (int k = 0; k < behavior.arity + behavior.stack_effect; ++k) {
                current_stack.emplace_back(std::nullopt);
            }
        }
    }
 
    std::vector<std::pair<int, Token>> insertions; // position, token to insert
 
    for (auto& it : std::ranges::reverse_view(dyn_to_static)) {
        int token_idx = it.first;
        int size = it.second;
 
        auto& token = tokens[token_idx];
        auto& payload = std::get<TokenPayloadArrayOp>(token.payload);
 
        token.type = TokenType::ArrayAllocStatic;
        token.text = payload.name + "{}^" + std::to_string(size);
        payload.static_size = size;
 
        Token drop_token{.type = TokenType::Drop,
                         .text = "drop1",
                         .payload = TokenPayloadStackOp{.n = 1}};
 
        insertions.emplace_back(token_idx, drop_token);
    }
 
    for (const auto& [pos, drop_token] : insertions) {
        tokens.insert(tokens.begin() + pos, drop_token);
    }
 
    if (!dyn_to_static.empty()) {
        return PreservedAnalyses::none();
    }
 
    return PreservedAnalyses::all();
}

References analysis::PreservedAnalyses::all(), ArrayAllocDyn, ArrayAllocStatic, Drop, get_token_behavior(), analysis::AnalysisManager::getResult(), and analysis::PreservedAnalyses::none().

---

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

• llvmexpr/analysis/passes/StaticArrayOptPass.hpp
• llvmexpr/analysis/passes/StaticArrayOptPass.cpp