analysis::VarInitPass Class Reference

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

Inheritance diagram for analysis::VarInitPass:

Collaboration diagram for analysis::VarInitPass:

Public Types
using	Result = VarInitResult
Public Types inherited from analysis::AnalysisPass< VarInitPass, VarInitResult >
using	Result

Public Member Functions
const char *	getName () const override
Result	run (const 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

Performs forward dataflow analysis to determine which variables and arrays are definitely initialized at each program point. Uses intersection semantics at merge points (a variable is only considered initialized if it's initialized on ALL incoming paths). Depends on: BlockAnalysisPass

Definition at line 42 of file VarInitPass.hpp.

Member Typedef Documentation

Result

using analysis::VarInitPass::Result = VarInitResult

Definition at line 44 of file VarInitPass.hpp.

Member Function Documentation

getName()

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

inlinenodiscardoverridevirtual

Implements analysis::Pass.

Definition at line 46 of file VarInitPass.hpp.

                                                       {
        return "Variable Initialization Pass";
    }

run()

VarInitPass::Result analysis::VarInitPass::run ( const std::vector< Token > & tokens, AnalysisManager & am )

overridevirtual

Implements analysis::AnalysisPass< VarInitPass, VarInitResult >.

Definition at line 89 of file VarInitPass.cpp.

                                                          {
    const auto& block_result = am.getResult<BlockAnalysisPass>();
    const auto& cfg_blocks = block_result.cfg_blocks;
 
    // Collect all variables and arrays
    std::set<std::string> all_vars;
    for (const auto& token : tokens) {
        if (token.type == TokenType::VarStore ||
            token.type == TokenType::VarLoad) {
            all_vars.insert(std::get<TokenPayloadVar>(token.payload).name);
        } else if (token.type == TokenType::ArrayAllocStatic ||
                   token.type == TokenType::ArrayAllocDyn ||
                   token.type == TokenType::ArrayStore ||
                   token.type == TokenType::ArrayLoad) {
            const auto& array_name =
                std::get<TokenPayloadArrayOp>(token.payload).name;
            all_vars.insert(var_naming::getArrayName(array_name));
        }
    }
 
    VarInitAnalysis analysis(all_vars);
    auto [in_sets, out_sets] = analysis.analyze(tokens, cfg_blocks);
 
    Result result;
    result.var_init_in = std::move(in_sets);
    result.var_init_out = std::move(out_sets);
 
    return result;
}

References ArrayAllocDyn, ArrayAllocStatic, ArrayLoad, ArrayStore, analysis::var_naming::getArrayName(), analysis::AnalysisManager::getResult(), analysis::VarInitResult::var_init_in, analysis::VarInitResult::var_init_out, VarLoad, and VarStore.

---

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

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