analysis::ValidationPass Class Reference

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

Inheritance diagram for analysis::ValidationPass:

Collaboration diagram for analysis::ValidationPass:

Public Types
using	Result = ValidationResult
Public Types inherited from analysis::AnalysisPass< ValidationPass, ValidationResult >
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

Validates that:

1. Variables are not used before initialization
2. Arrays are not accessed before allocation
3. Statically allocated arrays are not re-allocated Throws AnalysisError on validation failures. Depends on: VarInitPass, StaticAllocReachabilityPass, BlockAnalysisPass

Definition at line 37 of file ValidationPass.hpp.

Member Typedef Documentation

Result

using analysis::ValidationPass::Result = ValidationResult

Definition at line 40 of file ValidationPass.hpp.

Member Function Documentation

getName()

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

inlinenodiscardoverridevirtual

Implements analysis::Pass.

Definition at line 42 of file ValidationPass.hpp.

{ return "Validation Pass"; }

run()

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

overridevirtual

Implements analysis::AnalysisPass< ValidationPass, ValidationResult >.

Definition at line 32 of file ValidationPass.cpp.

                                                                {
    // Depend on required analysis passes
    const auto& block_result = am.getResult<BlockAnalysisPass>();
    const auto& cfg_blocks = block_result.cfg_blocks;
 
    const auto& var_init_result = am.getResult<VarInitPass>();
    const auto& var_init_in = var_init_result.var_init_in;
 
    const auto& static_alloc_result =
        am.getResult<StaticAllocReachabilityPass>();
    const auto& static_alloc_in = static_alloc_result.static_alloc_in;
 
    for (size_t i = 0; i < cfg_blocks.size(); ++i) {
        std::set<std::string> defined_in_block = var_init_in[i];
        std::set<std::string> static_in_block = static_alloc_in[i];
 
        for (int j = cfg_blocks[i].start_token_idx;
             j < cfg_blocks[i].end_token_idx; ++j) {
            const auto& token = tokens[j];
 
            if (token.type == TokenType::VarLoad) {
                const auto& payload = std::get<TokenPayloadVar>(token.payload);
                if (!defined_in_block.contains(payload.name)) {
                    throw AnalysisError(
                        std::format("Variable is uninitialized: {}",
                                    payload.name),
                        j);
                }
            } else if (token.type == TokenType::VarStore) {
                defined_in_block.insert(
                    std::get<TokenPayloadVar>(token.payload).name);
            } else if (token.type == TokenType::ArrayLoad ||
                       token.type == TokenType::ArrayStore) {
                const auto& payload =
                    std::get<TokenPayloadArrayOp>(token.payload);
                std::string array_name = var_naming::getArrayName(payload.name);
                if (!defined_in_block.contains(array_name)) {
                    throw AnalysisError(
                        std::format("Array is uninitialized: {}", payload.name),
                        j);
                }
            } else if (token.type == TokenType::ArrayAllocStatic ||
                       token.type == TokenType::ArrayAllocDyn) {
                const auto& payload =
                    std::get<TokenPayloadArrayOp>(token.payload);
                std::string array_name = var_naming::getArrayName(payload.name);
 
                if (static_in_block.contains(array_name)) {
                    throw AnalysisError(
                        std::format("Statically allocated array cannot be "
                                    "reallocated: {}",
                                    payload.name),
                        j);
                }
 
                if (token.type == TokenType::ArrayAllocStatic) {
                    static_in_block.insert(array_name);
                }
                defined_in_block.insert(array_name);
            }
        }
    }
 
    return Result{};
}

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

---

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

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