analysis::DynamicArrayAllocOptPass Class Reference

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

Inheritance diagram for analysis::DynamicArrayAllocOptPass:

Collaboration diagram for analysis::DynamicArrayAllocOptPass:

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

Eliminates redundant dynamic array allocations. If between two allocations of the same array, there are no reads or writes to that array on all possible control flow paths, the first allocation is replaced with a DROP instruction to maintain stack effects.

Depends on: BlockAnalysisPass, BuildCFGPass

Definition at line 36 of file DynamicArrayAllocOptPass.hpp.

Member Function Documentation

getName()

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

inlinenodiscardoverridevirtual

Implements analysis::Pass.

Definition at line 38 of file DynamicArrayAllocOptPass.hpp.

                                                       {
        return "Dynamic Array Allocation Optimization Pass";
    }

run()

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

overridevirtual

Implements analysis::TransformationPass.

Definition at line 123 of file DynamicArrayAllocOptPass.cpp.

                                                                     {
    const auto& block_result = am.getResult<BlockAnalysisPass>();
    const auto& cfg_blocks = block_result.cfg_blocks;
 
    std::set<int> allocations_to_remove;
 
    std::map<std::string, std::vector<int>> dynamic_allocations;
 
    for (size_t i = 0; i < tokens.size(); ++i) {
        const auto& token = tokens[i];
        if (token.type == TokenType::ArrayAllocDyn) {
            const auto& payload = std::get<TokenPayloadArrayOp>(token.payload);
            dynamic_allocations[payload.name].push_back(static_cast<int>(i));
        }
    }
 
    for (const auto& [array_name, alloc_indices] : dynamic_allocations) {
        if (alloc_indices.size() < 2) {
            continue;
        }
 
        for (size_t i = 0; i < alloc_indices.size() - 1; ++i) {
            int first_alloc = alloc_indices[i];
            int second_alloc = alloc_indices[i + 1];
 
            bool used = is_array_used_between(array_name, tokens, cfg_blocks,
                                              first_alloc, second_alloc);
 
            if (!used) {
                allocations_to_remove.insert(first_alloc);
            }
        }
    }
 
    if (allocations_to_remove.empty()) {
        return PreservedAnalyses::all();
    }
 
    for (int token_idx : allocations_to_remove) {
        auto& token = tokens[token_idx];
        token.type = TokenType::Drop;
        token.text = "drop1";
        token.payload = TokenPayloadStackOp{.n = 1};
    }
 
    return PreservedAnalyses::none();
}

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

---

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

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