Goose  Changes On Branch cir-stack-language

    auto result = InvokeOverloadSet( c, c.env()->extDestroyValue(),
        MakeTuple( v ) );

    if( result.isPoison() )
        return false;

    if( !result.isConstant() )
        cfg()->currentBB()->append( result );

    return true;
}

void CodeBuilder::extendValueLifetime( uint32_t index )
{
    // Find the live value.

#ifndef GOOSE_BUILTINS_EXPRHELPERS_H
#define GOOSE_BUILTINS_EXPRHELPERS_H

#include "parse/parse.h"

namespace goose::builtins::exprhelpers
{
    template< typename V >
    Value Not( V&& val )
    {
        auto locId = val.locationId();
        return BuildComputedValue( GetValueType< bool >(),
            forward< V >( val ), cir::Not( locId ) ).setLocationId( locId );
    }

    template< typename L, typename R >
    Value Or( L&& lhs, R&& rhs )
    {
        auto locId = max( lhs.locationId(), rhs.locationId() );
        return BuildComputedValue( GetValueType< bool >(),
            forward< L >( lhs ), forward< R >( rhs ), cir::Or( locId ) ).setLocationId( locId );
    }

    template< typename L, typename R >
    Value And( L&& lhs, R&& rhs )
    {
        auto locId = max( lhs.locationId(), rhs.locationId() );
        return BuildComputedValue( GetValueType< bool >(),
            forward< L >( lhs ), forward< R >( rhs ), cir::And( locId ) ).setLocationId( locId );
    }

    template< typename L, typename R >
    Value Eq( L&& lhs, R&& rhs )
    {
        auto locId = max( lhs.locationId(), rhs.locationId() );
        return BuildComputedValue( GetValueType< bool >(),
            forward< L >( lhs ), forward< R >( rhs ), cir::Eq( locId ) ).setLocationId( locId );
    }

    template< typename L, typename R >
    Value Neq( L&& lhs, R&& rhs )
    {
        auto locId = max( lhs.locationId(), rhs.locationId() );
        return BuildComputedValue( GetValueType< bool >(),
            forward< L >( lhs ), forward< R >( rhs ), cir::Neq( locId ) ).setLocationId( locId );
    }

    template< typename L, typename R >
    Value UGT( L&& lhs, R&& rhs )
    {
        auto locId = max( lhs.locationId(), rhs.locationId() );
        return BuildComputedValue( GetValueType< bool >(),
            forward< L >( lhs ), forward< R >( rhs ), cir::UGT( locId ) ).setLocationId( locId );
    }

    template< typename L, typename R >
    Value UGE( L&& lhs, R&& rhs )
    {
        auto locId = max( lhs.locationId(), rhs.locationId() );
        return BuildComputedValue( GetValueType< bool >(),
            forward< L >( lhs ), forward< R >( rhs ), cir::UGE( locId ) ).setLocationId( locId );
    }

    template< typename L, typename R >
    Value ULT( L&& lhs, R&& rhs )
    {
        auto locId = max( lhs.locationId(), rhs.locationId() );
        return BuildComputedValue( GetValueType< bool >(),
            forward< L >( lhs ), forward< R >( rhs ), cir::ULT( locId ) ).setLocationId( locId );
    }

    template< typename L, typename R >
    Value ULE( L&& lhs, R&& rhs )
    {
        auto locId = max( lhs.locationId(), rhs.locationId() );
        return BuildComputedValue( GetValueType< bool >(),
            forward< L >( lhs ), forward< R >( rhs ), cir::ULE( locId ) ).setLocationId( locId );
    }

    template< typename L, typename R >
    Value SGT( L&& lhs, R&& rhs )
    {
        auto locId = max( lhs.locationId(), rhs.locationId() );
        return BuildComputedValue( GetValueType< bool >(),
            forward< L >( lhs ), forward< R >( rhs ), cir::SGT( locId ) ).setLocationId( locId );
    }

    template< typename L, typename R >
    Value SGE( L&& lhs, R&& rhs )
    {
        auto locId = max( lhs.locationId(), rhs.locationId() );
        return BuildComputedValue( GetValueType< bool >(),
            forward< L >( lhs ), forward< R >( rhs ), cir::SGE( locId ) ).setLocationId( locId );
    }

    template< typename L, typename R >
    Value SLT( L&& lhs, R&& rhs )
    {
        auto locId = max( lhs.locationId(), rhs.locationId() );
        return BuildComputedValue( GetValueType< bool >(),
            forward< L >( lhs ), forward< R >( rhs ), cir::SLT( locId ) ).setLocationId( locId );
    }

    template< typename L, typename R >
    Value SLE( L&& lhs, R&& rhs )
    {
        auto locId = max( lhs.locationId(), rhs.locationId() );
        return BuildComputedValue( GetValueType< bool >(),
            forward< L >( lhs ), forward< R >( rhs ), cir::SLE( locId ) ).setLocationId( locId );
    }
}

#endif

    'types/func/bfunc.cpp',
    'types/func/bintrinsic.cpp',
    'types/func/functype.cpp',
    'types/func/func.cpp',
    'types/func/build.cpp',
    'types/func/compile.cpp',

    'types/func/typecheck.cpp',
    'types/func/lower.cpp',

    'types/func/invocation/beagerfunc.cpp',
    'types/func/invocation/bfunc.cpp',
    'types/func/invocation/bintrinsic.cpp',
    'types/func/invocation/common.cpp',
    'types/func/invocation/func.cpp',
    'types/func/invocation/ghostfunc.cpp',
    'types/func/invocation/intrinsic.cpp',

    'types/template/tvec.cpp',
    'types/template/tvar.cpp',
    'types/template/ttvar.cpp',
    'types/template/tdecl.cpp',
    'types/template/tnameddecl.cpp',
    'types/template/tfunctype.cpp',

            LeftAssInfixOp( "operator_add"_sid, precedence::AddSubOp,
                BuildGenericTupleOperator(),
                ForType< BigInt, Add >(),
                ForType< CustomPattern< IntegerType, IntegerType::Pattern > >(
                []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                {
                    return BuildComputedValue( lhs.type(),
                        lhs, rhs, Add( c.locationId() ) );
                } )
            )
        );

        BuildParseRule( e, "-"_sid,
            PrefixOp( "operator_unary_minus"_sid, precedence::UnaryOps,
                BuildGenericTupleOperator(),
                ForType< BigInt >( []( auto&& c, auto&& operand ) -> Value
                {
                    return BuildComputedValue( GetValueType< BigInt >(),
                        ToValue( BigInt() ), operand, Sub( c.locationId() ) );
                } ),
                ForType< CustomPattern< IntegerType, IntegerType::PatternSigned > >(
                []( auto&& c, auto&& operand ) -> Value
                {
                    auto opTypeVal = *EIRToValue( operand.type() );
                    auto opType = *FromValue< IntegerType >( opTypeVal );
                    return BuildComputedValue( operand.type(),
                        Value( operand.type(), APSInt( opType.m_numBits, false ) ),
                        operand, Sub( c.locationId() ) );
                } )
            ),
            LeftAssInfixOp( "operator_sub"_sid, precedence::AddSubOp,
                BuildGenericTupleOperator(),
                ForType< BigInt, Sub >(),
                ForType< CustomPattern< IntegerType, IntegerType::Pattern > >(
                []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                {
                    return BuildComputedValue( lhs.type(),
                        lhs, rhs, Sub( c.locationId() ) );
                } )
            )
        );

        BuildParseRule( e, "*"_sid,
            LeftAssInfixOp( "operator_multiply"_sid, precedence::MulDivOp,
                BuildGenericTupleOperator(),
                ForType< BigInt, Mul >(),
                ForType< CustomPattern< IntegerType, IntegerType::Pattern > >(
                []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                {
                    return BuildComputedValue( lhs.type(),
                        lhs, rhs, Mul( c.locationId() ) );
                } )
            )
        );

        BuildParseRule( e, "/"_sid,
            LeftAssInfixOp( "operator_divide"_sid, precedence::MulDivOp,
                BuildGenericTupleOperator(),

                    // to construct the assertion expression.
                    auto zeroValue = Value( rhs.type(), APSInt::get( 0 ) );
                    auto cond = Neq( rhs, zeroValue );

                    DiagnosticsManager::GetInstance().defineCustomDiagnostic(
                        cond.locationId(), "assert"_sid, "the divisor may be 0." );

                    cfg->currentBB()->append(
                        move( cond ), cir::Assert( rhs.locationId() )
                    );

                    return BuildComputedValue( lhs.type(),
                        lhs, rhs, SDiv( c.locationId() ) );
                } ),
                ForType< CustomPattern< IntegerType, IntegerType::PatternUnsigned > >(
                []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                {
                    using namespace goose::builtins::exprhelpers;

                    auto cfg = GetCFG( c );
                    assert( cfg );

                    // Build a zero constant of the same type as the denominator
                    // to construct the assertion expression.
                    auto zeroValue = Value( rhs.type(), APSInt::get( 0 ) );
                    auto cond = Neq( rhs, zeroValue );

                    DiagnosticsManager::GetInstance().defineCustomDiagnostic(
                        cond.locationId(), "assert"_sid, "the divisor may be 0." );

                    cfg->currentBB()->append(
                        move( cond ), cir::Assert( rhs.locationId() )
                    );

                    return BuildComputedValue( lhs.type(),
                        lhs, rhs, UDiv( c.locationId() ) );
                } )
            )
        );

        BuildParseRule( e, "%"_sid,
            LeftAssInfixOp( "operator_modulo"_sid, precedence::MulDivOp,
                BuildGenericTupleOperator(),

                    // to construct the assertion expression.
                    auto zeroValue = Value( rhs.type(), APSInt::get( 0 ) );
                    auto cond = Neq( rhs, zeroValue );

                    DiagnosticsManager::GetInstance().defineCustomDiagnostic(
                        cond.locationId(), "assert"_sid, "the divisor may be 0." );

                    cfg->currentBB()->append(
                        move( cond ), cir::Assert( rhs.locationId() )
                    );

                    return BuildComputedValue( lhs.type(),
                        lhs, rhs, SRem( c.locationId() ) );
                } ),
                ForType< CustomPattern< IntegerType, IntegerType::PatternUnsigned > >(
                []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                {
                    using namespace goose::builtins::exprhelpers;

                    auto cfg = GetCFG( c );
                    assert( cfg );

                    // Build a zero constant of the same type as the denominator
                    // to construct the assertion expression.
                    auto zeroValue = Value( rhs.type(), APSInt::get( 0 ) );
                    auto cond = Neq( rhs, zeroValue );

                    DiagnosticsManager::GetInstance().defineCustomDiagnostic(
                        cond.locationId(), "assert"_sid, "the divisor may be 0." );

                    cfg->currentBB()->append(
                        move( cond ), cir::Assert( rhs.locationId() )
                    );

                    return BuildComputedValue( lhs.type(),
                        lhs, rhs, URem( c.locationId() ) );
                } )
            )
        );
    }
}

            auto cfg = GetCFG( c );
            if( !cfg )
            {
                DiagnosticsManager::GetInstance().emitSyntaxErrorMessage( 0, "assignments are not allowed here." );
                return PoisonValue();
            }
            else if( auto bb = cfg->currentBB() )
                bb->append( lhs, rhs, Store( refType.type(), rhs.locationId(), lhs.locationId() ) );

            // Return the ref to support chained assignments, like in c++.
            return Value( lhs );
        };

        // Generic function to assign a value to a decl (local variable declaration)
        auto DeclAssignment = []( auto&& c, auto&& lhs, auto&& rhs ) -> Value

                return PoisonValue();

            return result;
        };

        auto RTTupleAssignment = [assOp]( auto&& c, auto&& lhs, auto&& rhs ) -> Value
        {
            auto cfg = GetCFG( c );
            if( !cfg )
                return PoisonValue();

            auto tupSize = TupleSize( lhs );

            auto tupRefType = *FromValue< ReferenceType >( *EIRToValue( rhs.type() ) );
            auto rhsTupType = *EIRToValue( tupRefType.type() );

            if( tupSize != TupleTypeSize( rhsTupType ) )
            {
                DiagnosticsManager::GetInstance().emitErrorMessage( 0, "incompatible tuple sizes." );
                return PoisonValue();
            }

            // Store the source tuple as a temporary, otherwise we're going to recompute rhs
            // for each member assigned (which is bad)
            auto rhsIndex = cfg->getNewTemporaryIndex();
            cfg->currentBB()->append( rhs, CreateTemporary( rhsIndex, rhs.locationId() ) );
            auto srcTup = BuildComputedValue( rhs.type(), GetTemporary( rhs.type(), rhsIndex, rhs.locationId() ) );

            // Load the values from the rhs tuple into temporary vars.
            vector< Value > tempVars;
            tempVars.reserve( tupSize );

            uint32_t index = 0;

            bool success = true;
            ForEachInTupleType( rhsTupType, [&]( auto&& srcType )
            {
                auto rt = ValueToEIR( ToValue( ReferenceType( srcType, ConstAccessSpecifer() ) ) );
                auto srcVal = BuildComputedValue( rt, srcTup, Select( index++, ( c.locationId() ) ) );

                // We go at very high level to construct the temporary variables by resolving an invocation
                // of the assignment of the rhs value to a TNamedDecl with an empty name.
                // The reason we need to work at such high level is so that the initializer value gets
                // resolved exactly like if it was a regular assignment. In particular, if the value in question
                // is a locvar, we want it to go through the type checking process to be replaced with its content.
                // This is the simplest and most robust way to achieve this, which should honor every relevant

                ForType< BigInt, Eq, bool >(),
                ForType< char32_t, Eq, bool >(),
                ForType< string, Eq, bool >(),
                ForType< CustomPattern< IntegerType, IntegerType::Pattern > >(
                []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                {
                    return BuildComputedValue( GetValueType< bool >(),
                        lhs, rhs, Eq( c.locationId() ) );
                } )
            )
        );

        BuildParseRule( e, "!="_sid,
            LeftAssInfixOp( "operator_not_equals"_sid, precedence::EqualityOp,
                ForType< bool, Neq, bool >(),
                ForType< BigInt, Neq, bool >(),
                ForType< char32_t, Neq, bool >(),
                ForType< string, Neq, bool >(),
                ForType< CustomPattern< IntegerType, IntegerType::Pattern > >(
                []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                {
                    return BuildComputedValue( GetValueType< bool >(),
                        lhs, rhs, Neq( c.locationId() ) );
                } )
            )
        );

        BuildParseRule( e, ">"_sid,
            LeftAssInfixOp( "operator_greater"_sid, precedence::GreaterLesserOp,
                ForType< BigInt, SGT, bool >(),
                ForType< CustomPattern< IntegerType, IntegerType::PatternSigned > >(
                []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                {
                    return BuildComputedValue( GetValueType< bool >(),
                        lhs, rhs, SGT( c.locationId() ) );
                } ),
                ForType< CustomPattern< IntegerType, IntegerType::PatternUnsigned > >(
                []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                {
                    return BuildComputedValue( GetValueType< bool >(),
                        lhs, rhs, UGT( c.locationId() ) );
                } )
            )
        );

        BuildParseRule( e, ">="_sid,
            LeftAssInfixOp( "operator_greater_or_equals"_sid, precedence::GreaterLesserOp,
                ForType< BigInt, SGE, bool >(),
                ForType< CustomPattern< IntegerType, IntegerType::PatternSigned > >(
                []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                {
                    return BuildComputedValue( GetValueType< bool >(),
                        lhs, rhs, SGE( c.locationId() ) );
                } ),
                ForType< CustomPattern< IntegerType, IntegerType::PatternUnsigned > >(
                []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                {
                    return BuildComputedValue( GetValueType< bool >(),
                        lhs, rhs, UGE( c.locationId() ) );
                } )
            )
        );

        BuildParseRule( e, "<"_sid,
            LeftAssInfixOp( "operator_lesser"_sid, precedence::GreaterLesserOp,
                ForType< BigInt, SLT, bool >(),
                ForType< CustomPattern< IntegerType, IntegerType::PatternSigned > >(
                []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                {
                    return BuildComputedValue( GetValueType< bool >(),
                        lhs, rhs, SLT( c.locationId() ) );
                } ),
                ForType< CustomPattern< IntegerType, IntegerType::PatternUnsigned > >(
                []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                {
                    return BuildComputedValue( GetValueType< bool >(),
                        lhs, rhs, ULT( c.locationId() ) );
                } )
            )
        );

        BuildParseRule( e, "<="_sid,
            LeftAssInfixOp( "operator_lesser_or_equals"_sid, precedence::GreaterLesserOp,
                ForType< BigInt, SLE, bool >(),
                ForType< CustomPattern< IntegerType, IntegerType::PatternSigned > >(
                []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                {
                    return BuildComputedValue( GetValueType< bool >(),
                        lhs, rhs, SLE( c.locationId() ) );
                } ),
                ForType< CustomPattern< IntegerType, IntegerType::PatternUnsigned > >(
                []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                {
                    return BuildComputedValue( GetValueType< bool >(),
                        lhs, rhs, ULE( c.locationId() ) );
                } )
            )
        );
    }
}

                    if( index >= TupleTypeSize( tupType ) )
                    {
                        DiagnosticsManager::GetInstance().emitErrorMessage( rhs.locationId(),
                            "the index is out of range." );
                        return PoisonValue();
                    }


                    auto rt = ValueToEIR( ToValue( ReferenceType( GetTupleTypeElement( tupType, index ), refType.behavior() ) ) );
                    return BuildComputedValue( rt, lhs, Select( index, c.locationId() ) );
                } )
            )
        );
    }
}

    auto ForType()
    {
        return []< typename tag >( auto&& e, auto&& pOvlSet, tag t )
        {
            using intrinsicType = Intrinsic< Value ( T, T ) >;
            auto intrinsicFunc = []( const Context& c, const Value& lhs, const Value& rhs )
            {
                return BuildComputedValue( GetValueType< RT >(), lhs, rhs, I( ( c.locationId() ) ) );
            };

            pOvlSet->add( e, ToValue< intrinsicType >( move( intrinsicFunc ) ), GetBuiltinIntrinsicFuncInvocationRule() );
        };
    }

    template< typename T, typename F >
    auto ForType( F&& func )
    {
        return [&]< typename tag >( auto&& e, auto&& pOvlSet, tag t )
        {
            if constexpr( is_same_v< tag, UnaryOpTag > )
            {
                using intrinsicType = Intrinsic< Value ( T ) >;
                pOvlSet->add( e, ToValue< intrinsicType >( forward< F >( func ) ), GetBuiltinIntrinsicFuncInvocationRule() );
            }
            else
            {
                using intrinsicType = Intrinsic< Value ( T, T ) >;
                pOvlSet->add( e, ToValue< intrinsicType >( forward< F >( func ) ), GetBuiltinIntrinsicFuncInvocationRule() );
            }
        };
    }

    template< typename T1, typename T2, typename F >
    auto ForTypes( F&& func )
    {
        return [=]< typename tag >( auto&& e, auto&& pOvlSet, tag t )
        {
            using intrinsicType = Intrinsic< Value ( T1, T2 ) >;
            pOvlSet->add( e, ToValue< intrinsicType >( func ), GetBuiltinIntrinsicFuncInvocationRule() );
        };
    }
}

#endif

        BuildParseRule( e, "!"_sid,
            PrefixOp( "operator_logical_not"_sid, precedence::UnaryOps,
                BuildGenericTupleOperator(),

                ForType< bool >( []( auto&& c, auto&& operand ) -> Value
                {
                    return BuildComputedValue( GetValueType< bool >(),
                        operand, cir::Not( c.locationId() ) );
                } )
            )
        );

        BuildParseRule( e, "~"_sid,
            PrefixOp( "operator_bitwise_not"_sid, precedence::UnaryOps,
                BuildGenericTupleOperator(),

                ForType< CustomPattern< IntegerType, IntegerType::Pattern > >( []( auto&& c, auto&& operand ) -> Value
                {
                    auto opTypeVal = *EIRToValue( operand.type() );
                    auto opType = *FromValue< IntegerType >( opTypeVal );
                    return BuildComputedValue( operand.type(),

                        operand, Value( operand.type(), APSInt::getMaxValue( opType.m_numBits, true ) ),
                        Xor( c.locationId() )
                    );
                } )
            )
        );

        BuildParseRule( e, "^"_sid,
            LeftAssInfixOp( "operator_xor"_sid, precedence::OrOp,
                BuildGenericTupleOperator(),

                // Logical xor
                ForType< bool, Xor >(),

                // ct_int xor
                ForType< BigInt >(
                []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                {
                    if( !lhs.isConstant() || !rhs.isConstant() )
                    {

                        DiagnosticsManager::GetInstance().emitSyntaxErrorMessage( c.locationId(), "bitwise operations between ct_int values are only allowed on constants." );
                        return PoisonValue();
                    }

                    return BuildComputedValue( lhs.type(),
                        lhs, rhs, Xor( c.locationId() ) );
                } ),

                // runtime integer xor, defined to work for any two integers of same
                // bit size and signedness.
                ForType< CustomPattern< IntegerType, IntegerType::Pattern > >(
                []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                {
                    return BuildComputedValue( lhs.type(),
                        lhs, rhs, Xor( c.locationId() ) );
                } )
            )
        );

        BuildParseRule( e, "|"_sid,
            LeftAssInfixOp( "operator_or"_sid, precedence::OrOp,
                BuildGenericTupleOperator(),

                // ct_int or
                ForType< BigInt >(
                []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                {
                    if( !lhs.isConstant() || !rhs.isConstant() )
                    {
                        auto loc = Location::CreateSpanningLocation( lhs.locationId(), rhs.locationId() );
                        DiagnosticsManager::GetInstance().emitSyntaxErrorMessage( loc, "bitwise operations between ct_int values are only allowed on constants." );
                        return PoisonValue();
                    }

                    return BuildComputedValue( lhs.type(),
                        lhs, rhs, Or( c.locationId() ) );
                } ),

                // runtime integer or, defined to work for any two integers of same
                // bit size and signedness.
                ForType< CustomPattern< IntegerType, IntegerType::Pattern > >(
                []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                {
                    return BuildComputedValue( lhs.type(),
                        lhs, rhs, Or( c.locationId() ) );
                } ),

                // bool or
                ForType< bool >( [orOp]< typename L, typename R >( auto&& c, L&& lhs, R&& rhs ) -> Value
                {
                    // Handle the case where lhs is constant, so that
                    // the result gets properly eagerly evaluated (in case

                } )
            )
        );

        RegisterBuiltinFunc< Intrinsic< bool ( Value, bool, bool ) > >( e, orOp,
            []( auto&& c, auto&& b, auto&& lhs, auto&& rhs )
            {
                return BuildComputedValue( GetValueType< bool >(), lhs, rhs, Or( c.locationId() ) );
            } );

        RegisterBuiltinFunc< Intrinsic< bool ( TypeWrapper< ptr< CodeBuilder > >, bool, bool ) > >( e, orOp,
            []( auto&& c, auto&& b, auto&& lhs, auto&& rhs )
            {
                auto cb = *FromValue< TypeWrapper< ptr< CodeBuilder > > >( b );
                const auto& cfg = cb->cfg();

                // Build the control flow for shortcut evaluation.
                const auto& predBB = cfg->currentBB();

                auto pRhsBB = cfg->createBB();
                auto pSuccBB = cfg->createBB();

                // If the lhs is true, skip to the end directly.
                // Otherwise, jump to the BB that computes rhs.
                predBB->append( lhs );
                predBB->setTerminator( CondBranch( pSuccBB, pRhsBB ) );

                auto rhsIndex = cfg->getNewTemporaryIndex();
                pRhsBB->append( rhs, CreateTemporary( rhsIndex, c.locationId() ) );
                pRhsBB->setTerminator( Branch( pSuccBB ) );

                auto resultIndex = cfg->getNewTemporaryIndex();

                // Build the Phi instruction that will collect the final result.
                auto phi = Phi( *EIRToValue( GetValueType< bool >() ), 2,
                    resultIndex, c.locationId() );

                // If coming directly from the lhs BB, we know the result is true.
                phi.setIncoming( predBB, ToValue( true ) );

                // Otherwise, the result is whatever was computed by the rhs block.
                phi.setIncoming( pRhsBB, BuildComputedValue( GetValueType< bool >(),
                    GetTemporary( GetValueType< bool >(), rhsIndex, c.locationId() ) ) );

                pSuccBB->append( move( phi ) );
                cfg->setCurrentBB( pSuccBB );

                // Build the result val which pulls the temporary created above.
                return BuildComputedValue( GetValueType< bool >(),
                    GetTemporary( GetValueType< bool >(), resultIndex, c.locationId() ) );
            } );

        BuildParseRule( e, "&"_sid,
            LeftAssInfixOp( "operator_and"_sid, precedence::AndOp,
                BuildGenericTupleOperator(),

                // ct_int and
                ForType< BigInt >(
                []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                {
                    if( !lhs.isConstant() || !rhs.isConstant() )
                    {

                        DiagnosticsManager::GetInstance().emitSyntaxErrorMessage( c.locationId(), "bitwise operations between ct_int values are only allowed on constants." );
                        return PoisonValue();
                    }

                    return BuildComputedValue( lhs.type(),
                        lhs, rhs, And( c.locationId() ) );
                } ),

                // runtime integer and, defined to work for any two integers of same
                // bit size and signedness.
                ForType< CustomPattern< IntegerType, IntegerType::Pattern > >(
                []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                {
                    return BuildComputedValue( lhs.type(),
                        lhs, rhs, And( c.locationId() ) );
                } ),

                // bool and
                ForType< bool >( [andOp]< typename L, typename R >( auto&& c, L&& lhs, R&& rhs ) -> Value
                {
                    // Handle the case where lhs is constant, so that
                    // the result gets properly eagerly evaluated (in case

                } )
            )
        );

        RegisterBuiltinFunc< Intrinsic< bool ( Value, bool, bool ) > >( e, andOp,
            []( auto&& c, auto&& b, auto&& lhs, auto&& rhs )
            {
                return BuildComputedValue( GetValueType< bool >(), lhs, rhs, And( c.locationId() ) );
            } );

        RegisterBuiltinFunc< Intrinsic< bool ( TypeWrapper< ptr< CodeBuilder > >, bool, bool ) > >( e, andOp,
            []( auto&& c, auto&& b, auto&& lhs, auto&& rhs )
            {
                auto cb = *FromValue< TypeWrapper< ptr< CodeBuilder > > >( b );
                const auto& cfg = cb->cfg();

                // Build the control flow for shortcut evaluation.
                const auto& predBB = cfg->currentBB();

                auto pRhsBB = cfg->createBB();
                auto pSuccBB = cfg->createBB();

                // If the lhs is false, skip to the end directly.
                // Otherwise, jump to the BB that computes rhs.
                predBB->append( lhs );
                predBB->setTerminator( CondBranch( pRhsBB, pSuccBB ) );

                auto rhsIndex = cfg->getNewTemporaryIndex();
                pRhsBB->append( rhs, CreateTemporary( rhsIndex, c.locationId() ) );
                pRhsBB->setTerminator( Branch( pSuccBB ) );

                auto resultIndex = cfg->getNewTemporaryIndex();

                // Build the Phi instruction that will collect the final result.
                auto phi = Phi( *EIRToValue( GetValueType< bool >() ), 2,
                    resultIndex, c.locationId() );

                // If coming directly from the lhs BB, we know the result is false.
                phi.setIncoming( predBB, ToValue( false ) );

                // Otherwise, the result is whatever was computed by the rhs block.
                phi.setIncoming( pRhsBB, BuildComputedValue( GetValueType< bool >(),
                    GetTemporary( GetValueType< bool >(), rhsIndex, c.locationId() ) ) );

                pSuccBB->append( move( phi ) );
                cfg->setCurrentBB( pSuccBB );

                // Build the result val which pulls the temporary created above.
                return BuildComputedValue( GetValueType< bool >(),
                    GetTemporary( GetValueType< bool >(), resultIndex, c.locationId() ) );
            } );

        BuildParseRule( e, "<<"_sid,
            LeftAssInfixOp( "operator_shift_left"_sid, precedence::BitShiftOp,
                BuildGenericTupleOperator(),

                // ct_int left shift
                ForTypes< BigInt, uint32_t >(
                []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                {
                    if( !lhs.isConstant() || !rhs.isConstant() )
                    {
                        auto loc = Location::CreateSpanningLocation( lhs.locationId(), rhs.locationId() );
                        DiagnosticsManager::GetInstance().emitSyntaxErrorMessage( loc, "bitwise operations between ct_int values are only allowed on constants." );
                        return PoisonValue();
                    }

                    return BuildComputedValue( lhs.type(),
                        lhs, rhs, Shl( c.locationId() ) );
                } ),

                // runtime integer left shift.
                ForTypes< CustomPattern< IntegerType, IntegerType::Pattern >,
                    CustomPattern< IntegerType, IntegerType::PatternUnsigned > >(
                []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                {
                    using namespace goose::builtins::exprhelpers;

                    auto cfg = GetCFG( c );
                    assert( cfg );

                    // Shifting for a number of bits equal or larger than the bitsize
                    // of lhs is an undefined behavior, so we require verification that
                    // it won't happen.
                    // Extract the integer type of lhs to retrieve its bit size.
                    auto lhsType = *FromValue< IntegerType >( *EIRToValue( lhs.type() ) );
                    auto bitSizeValue = Value( rhs.type(), APSInt::get( lhsType.m_numBits ) );

                    auto cond = ULT( rhs, bitSizeValue );

                    DiagnosticsManager::GetInstance().defineCustomDiagnostic(
                        cond.locationId(), "assert"_sid, "the shift amount may be equal or greater than the bitsize." );

                    cfg->currentBB()->append(
                        move( cond ), cir::Assert( rhs.locationId() )
                    );

                    return BuildComputedValue( lhs.type(),
                        lhs, rhs, Shl( c.locationId() ) );
                } )
            )
        );

        BuildParseRule( e, ">>"_sid,
            LeftAssInfixOp( "operator_shift_right"_sid, precedence::BitShiftOp,
                BuildGenericTupleOperator(),

                // ct_int right shift
                ForTypes< BigInt, uint32_t >(
                []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                {
                    if( !lhs.isConstant() || !rhs.isConstant() )
                    {

                        DiagnosticsManager::GetInstance().emitSyntaxErrorMessage( c.locationId(), "bitwise operations between ct_int values are only allowed on constants." );
                        return PoisonValue();
                    }

                    return BuildComputedValue( lhs.type(),
                        lhs, rhs, AShr( c.locationId() ) );
                } ),

                // runtime signed integer right shift, defined to work for any two integers of same
                // bit size.
                ForTypes< CustomPattern< IntegerType, IntegerType::PatternSigned >,
                    CustomPattern< IntegerType, IntegerType::PatternUnsigned > >(
                []( auto&& c, auto&& lhs, auto&& rhs ) -> Value

                    auto bitSizeValue = Value( rhs.type(), APSInt::get( lhsType.m_numBits) );

                    auto cond = ULT( rhs, bitSizeValue );

                    DiagnosticsManager::GetInstance().defineCustomDiagnostic(
                        cond.locationId(), "assert"_sid, "the shift amount may be equal or greater than the bitsize." );

                    cfg->currentBB()->append(
                        move( cond ), cir::Assert( rhs.locationId() )
                    );

                    return BuildComputedValue( lhs.type(),
                        lhs, rhs, AShr( c.locationId() ) );
                } ),

                // runtime unsigned integer right shift, defined to work for any two integers of same
                // bit size.
                ForType< CustomPattern< IntegerType, IntegerType::PatternUnsigned > >(
                []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                {
                    using namespace goose::builtins::exprhelpers;

                    auto cfg = GetCFG( c );
                    assert( cfg );

                    // Shifting for a number of bits equal or larger than the bitsize
                    // of lhs is an undefined behavior, so we require verification that
                    // it won't happen.
                    // Extract the integer type of lhs to retreieve its bit size.
                    auto lhsType = *FromValue< IntegerType >( *EIRToValue( lhs.type() ) );
                    auto bitSizeValue = Value( rhs.type(), APSInt::get( lhsType.m_numBits ) );

                    auto cond = ULT( rhs, bitSizeValue );

                    DiagnosticsManager::GetInstance().defineCustomDiagnostic(
                        cond.locationId(), "assert"_sid, "the shift amount may be equal or greater than the bitsize." );

                    cfg->currentBB()->append(
                        move( cond ), cir::Assert( rhs.locationId() )
                    );

                    return BuildComputedValue( lhs.type(),
                        lhs, rhs, LShr( c.locationId() ) );
                } )
            )
        );
    }
}

                        result = AppendToTuple( result, r );
                        return true;
                    } );

                    return result;
                };

                pOvlSet->add( e, ToValue< intrinsicType >( move( intrinsicFunc ) ), GetBuiltinIntrinsicFuncInvocationRule() );
            }
            else
            {
                using intrinsicType = Intrinsic< Value ( CustomPattern< Value, TuplePattern >, CustomPattern< Value, TuplePattern > ) >;
                auto intrinsicFunc = [pOvlSet]( const Context& c, const Value& lhs, const Value& rhs )
                {
                    if( TupleSize( lhs ) != TupleSize( rhs ) )

                        result = AppendToTuple( result, r );
                        return true;
                    } );

                    return result;
                };

                pOvlSet->add( e, ToValue< intrinsicType >( move( intrinsicFunc ) ), GetBuiltinIntrinsicFuncInvocationRule() );
            }
        };
    }
}

#endif

            // If both the then and the else blocks successors exist and are terminated,
            // we don't need a successor block.
            if( !pElseBB || ( pThenSuccBB && !pThenSuccBB->terminator() )
                || ( pElseSuccBB && !pElseSuccBB->terminator() ) )
                pSuccBB = cfg->createBB();

            pPrecBB->append( get< Value >( converted ) );
            pPrecBB->setTerminator( cir::CondBranch(

                pThenBB,
                pElseBB ? pElseBB : pSuccBB ) );

            if( pThenSuccBB && !pThenSuccBB->terminator() )
                pThenSuccBB->setTerminator( cir::Branch( pSuccBB ) );

            if( pElseSuccBB && !pElseSuccBB->terminator() )

            // Emit cleanups (destructor calls) for all currently live values in the function.
            DestroyAllLiveValues( p.context() );

            const auto& context = p.context();

            if( context.returnType() == GetValueType< void >() )
            {
                cfg->emitTerminator( locationId, cir::RetVoid( locationId ) );
                return true;
            }

            auto np = p.makeNestedParser();
            if( !np.parseExpression( precedence::ReturnStmt + 1 ) )
            {
                dm.emitSyntaxErrorMessage( locationId, "expected an expression following the return statement.", 0 );
                cfg->currentBB()->append( PoisonValue() );
                cfg->emitTerminator( locationId, cir::Ret( locationId ) );
                return false;
            }

            auto retVal = np.popValue();
            if( !retVal )
            {
                dm.emitSyntaxErrorMessage( locationId, "expected an expression following the return statement.", 0 );
                cfg->currentBB()->append( PoisonValue() );
                cfg->emitTerminator( locationId, cir::Ret( locationId ) );
                return false;
            }

            auto converted = ConvertValueToType( context, *retVal, *context.returnType() );
            if( holds_alternative< ValUnifyError >( converted ) )
            {
                switch( get< ValUnifyError >( converted ) )
                {
                    case ValUnifyError::NoSolution:
                        dm.emitErrorMessage( retVal->locationId(), "return value type mismatch." );
                        break;

                    case ValUnifyError::Ambiguous:
                        dm.emitErrorMessage( retVal->locationId(), "ambiguous return value conversion." );
                        break;
                }

                // Emit a terminator with a poison value to avoid the function compilation
                // code to complain about a missing return.
                cfg->currentBB()->append( PoisonValue() );
                cfg->emitTerminator( locationId, cir::Ret( locationId ) );
                PoisonBuilder( p.context() );
                return true;
            }

            cfg->currentBB()->append( get< Value >( converted ) );
            cfg->emitTerminator( locationId, cir::Ret( locationId ) );
            return true;
        };

        RegisterRule( e, "return"_sid, Rule( handleReturn ) );
    }
}

                    if( pCont->level() == continueLevel )
                        bb->setTerminator( cir::Branch( pHeaderBB ) );
                    return;
                }
            } );

            // Emit the conditional branch that will either run an iteration of the loop or exit to the succ bb.
            pHeaderBB->append( get< Value >( converted ) );
            pHeaderBB->setTerminator( cir::CondBranch(

                pBodyBB, pSuccBB ) );

            cfg->setCurrentBB( pSuccBB );
            return true;
        };

        RegisterRule( e, "while"_sid, Rule( handleWhile ) );

        // is appended to the current BB of the current parser.
        RegisterBuiltinFunc< Intrinsic< void ( Value, Value ) > >( e, e.extDropValue(),
            []( const Context& c, const Value& b, const Value& v )
            {
                if( v.isConstant() )
                    return;




                if( !DoesInstrSeqHaveSideEffects( *v.cir() ) )
                    return;

                auto cfg = GetCFG( c );
                if( !cfg )
                    return;

                auto bb = cfg->currentBB();
                bb->append( move( *v.cir() ) );
            } );

        using AnyDeclType = CustomPattern< Decl, Decl::Pattern >;

        // DropValue for Decls: declare a local variable with default initialization.
        // TODO: if the invocation to InitializeValue fails, we should have a way to
        // replace the generic "function arguments mismatch" error message with something

#ifndef GOOSE_BUILTINS_TYPES_BFUNC_H
#define GOOSE_BUILTINS_TYPES_BFUNC_H

namespace goose::builtins
{
    class FuncVerificationInfos;

    using BuiltinFuncWrapper = function< Value ( const Term& argVec ) >;

    template< typename FT, typename F >
    ptr< FuncVerificationInfos > RegisterBuiltinFunc( Env& env, StringId name, F&& func );

    template< typename FT, typename F >
    ptr< FuncVerificationInfos > RegisterBuiltinFunc( Env& env, ptr< OverloadSet > pOvlSet, F&& func );

    extern bool IsBuiltinFunc( const Value& func );
    extern bool IsEagerBuiltinFunc( const Value& func );

    }

    template< typename FT, typename F >
    ptr< FuncVerificationInfos > RegisterBuiltinFunc( Env& env, ptr< OverloadSet > pOvlSet, F&& func )
    {
        auto fvi = make_shared< builtins::FuncVerificationInfos >( RootG0Identity() );

        if( !pOvlSet->add( env, ToValue< FT >( forward< F >( func ), fvi ), GetInvocationRule< FT >() ) )
            G_ERROR( "duplicate overload registered for builtin func." );

        return fvi;
    }
}

namespace goose::eir

                // Bind a stand-in value with the parameters name to be used inside of verification expressions.
                auto paramVerificationIdentity = AppendToVectorTerm( verificationIdentity,
                    TERM( decl.name() ) );

                c.env()->storeValue( paramVerificationIdentity, ANYTERM( _ ),
                    ValueToEIR( BuildComputedValue( decl.type(),
                        cir::VarAddr( varId++, decl.type(), param.locationId() ),
                        cir::Load( decl.type(), param.locationId() ) ) ) );
            }
            else if( param.isConstant() )
                tv->append( ValueToEIR( param ) );

            return true;
        } );

        if( failed )
            return nullopt;

        // If the return type is non-void, expose @result under the verification identity as a computed value whose type
        // is the function's return type, and the value is a placeholder cir instruction. This will allow verification
        // expressions to refer to the current function's return value as a value of the correct type.
        auto rtTerm = ValueToEIR( returnType );
        if( rtTerm != GetValueType< void >() )
        {
            auto name = "@result"_sid;
            auto retValVerificationIdentity = AppendToVectorTerm( verificationIdentity, TERM( name ) );

            c.env()->storeValue( retValVerificationIdentity, ANYTERM( _ ),
                ValueToEIR( BuildComputedValue( rtTerm, cir::Placeholder( rtTerm, name, returnType.locationId() ) ) ) );
        }

        auto pVerifInfos = make_shared< FuncVerificationInfos >( move( verificationIdentity ) );
        return FuncType( rtTerm, tv, move( pVerifInfos ) );
    }

    Func BuildExternalFunc( FuncType funcType, const string& symbol, bool varArg )

            // TODO: at some point we'll want to check for reachability in the static verifier,
            // and either emit the implicit return or declare the code unreachable depending on the result.
            // The reachability analysis will have to be done before contract validation, as the
            // calls to DestroyValue() may also have requirements to enforce, so we'll need to emit
            // the eventual implicit return first.
            p.flushValue();
            cb->destroyAllLiveValues( localContext );
            cfg->emitTerminator( r->currentLocation(), cir::RetVoid( r->currentLocation() ) );
        }

        pFuncCIR->body() = cfg;
        verify::Func fv( localContext, f );
        return fv.verify();
    }
}

#include "builtins/builtins.h"
#include "lex/lex.h"
#include "parse/parse.h"
#include "verify/verify.h"

using namespace goose::builtins;
using namespace goose::parse;

namespace goose::builtins
{
    cir::InstrSeq BuildArgsInstrSeq( const Term& args )
    {
        cir::InstrSeq result;

        ForEachInVectorTerm( args, [&]( auto&& arg )
        {
            cir::AppendToInstrSeq( result, *EIRToValue( arg ) );
            return true;
        } );

        return result;
    }

    const Term& FuncPattern::GetPattern()
    {
        static auto pattern = ValueToEIR(
            Value( TypeType(), VEC( TSID( func ), HOLE( "llvmType"_sid ),
            HOLE( "_"_sid ), HOLE( "_"_sid ),
            HOLE( "_"_sid ), HOLE( "_"_sid ) ) ) );

    Term GetFuncSig( const Value& func )
    {
        auto funcType = EIRToValue( func.type() );
        assert( funcType );
        return GetFuncSigFromType( *funcType );
    }

    optional< Term > GetFuncRType( const Value& func )
    {
        auto funcType = EIRToValue( func.type() );
        if( !funcType )
            return nullopt;

        auto typeDecomp = Decompose( funcType->val(),
            Vec(
                Lit( "func"_sid ),
                SubTerm(),  // kind
                SubTerm(),  // return type
                SubTerm(),  // param types
                SubTerm(),  // verif infos
                SubTerm()   // varArg
            )
        );

        if( !typeDecomp )

            return nullopt;

        auto&& [kind, rtype, ptypes, vinf, varArg] = *typeDecomp;
        return rtype;
    }

    const cir::Func* GetFuncCIR( const Value& f )
    {
        if( !f.isConstant() )
            return nullptr;

#ifndef GOOSE_BUILTINS_TYPES_FUNC_H
#define GOOSE_BUILTINS_TYPES_FUNC_H

namespace goose::builtins
{


    extern void SetupFunctionTypeChecking( Env& e );
    extern void SetupFunctionLowering( Env& e );

    // Helper to provide generic param patterns for functions.
    struct FuncPattern
    {
        static const Term& GetPattern();
    };

    extern Term GetFuncSig( const Value& func );
    extern optional< Term > GetFuncRType( const Value& func );
    extern const cir::Func* GetFuncCIR( const Value& func );

    template< typename F >
    void ForEachDeclInTuple( const Value& tup, F&& func );

    extern bool IsExternalFunc( const Value& f );
    extern bool IsIntrinsicFunc( const Value& f );

    };

    extern Value CompileFunc( const Context& c, const Value& f );

    extern bool ParseFuncConstraints( const Context& c, const FuncType& funcType );
    extern bool ParseFuncBody( const Context& c, const Value& f );
    extern bool ParseFuncBody( const Context& c, const Func& f );

    extern cir::InstrSeq BuildArgsInstrSeq( const Term& args );
}

namespace goose::eir
{
    template<>
    struct Bridge< builtins::Func >
    {

        auto result = Decompose( t.val(),
            Vec(
                Lit( "func"_sid ),
                Lit( "intrinsic"_sid ),
                SubTerm(),  // return type
                SubTerm(),  // param types
                SubTerm(),  // verif infos
                SubTerm()   // varArg
            )
        );

        return !!result;
    }

    Term GetFuncSigFromType( const Value& funcType )
    {
        auto typeDecomp = Decompose( funcType.val(),
            Vec(
                Lit( "func"_sid ),
                SubTerm(),  // kind
                SubTerm(),  // return type
                SubTerm(),  // param types
                SubTerm(),  // verif infos
                SubTerm()   // varArg
            )
        );
        assert( typeDecomp );
        auto&& [kind, rtype, ptypes, vinf, varArg] = *typeDecomp;

        return PrependToVectorTerm( *Unquote( ptypes ), rtype );
    }

        bool failed = false;
        ForEachInVectorTerms( ft.params(), unifiedArgs, [&]( auto&& p, auto&& a )
        {
            auto vp = ValuePatternFromEIR( p );
            if( vp->val() == HOLE( "_"_sid ) )
            {
                auto arg = *EIRToValue( a );
                auto convertedArg = InvokeOverloadSet( c, c.env()->extConvertFuncArg(),
                    MakeTuple( arg, *EIRToValue( vp->type() ) ) );
                if( convertedArg.isPoison() )
                {
                    failed = true;
                    return false;
                }

                convertedArg.setLocationId( arg.locationId() );
                av->append( ValueToEIR( convertedArg ) );
            }

            return true;
        } );

        if( failed )

#include "builtins/builtins.h"
#include "common.h"

using namespace goose::sema;

namespace goose::builtins
{
    class BuiltinEagerFuncInvocationRule : public BaseFuncInvocationRule
    {
        public:
            Value invoke( Context& c, LocationId loc, const Value& callee, const Term& args, const Term& typeCheckedCallPat, TypeCheckingContext& tcc ) const final
            {
                auto callDecomp = Decompose( typeCheckedCallPat,
                    Val< pvec >()
                );

                const auto& typeCheckedRType = callDecomp->get()->terms().front();
                auto typeCheckedArgs = DropVectorTerm( typeCheckedCallPat, 1 );
                auto argCount = VecSize( typeCheckedArgs );
                auto argsInstrSeq = BuildArgsInstrSeq( typeCheckedArgs );

                auto call = BuildComputedValue( typeCheckedRType, argsInstrSeq, callee,
                    cir::Call( argCount, loc ) );

                if( !cir::CanValueBeEagerlyEvaluated( call ) )
                    return call;

                execute::VM vm;
                return execute::Evaluate( call, vm );
            }

            Value prepareFunc( const Context& c, LocationId funcValLocation, const Value& callee, const Term& typeCheckedCallPat, TypeCheckingContext& tcc ) const final
            {
                return callee;
            }
    };

    const ptr< InvocationRule >& GetBuiltinEagerFuncInvocationRule()
    {
        static ptr< InvocationRule > pRule = make_shared< BuiltinEagerFuncInvocationRule >();
        return pRule;
    }

    void SetupBuiltinEagerFuncInvocationRule( Env& e )
    {
        e.invocationRuleSet()->addRule(
            ValueToEIR( ValuePattern( ANYTERM( _ ),

                ValueToEIR( Value( TypeType(), VEC( TSID( func ),
                TSID( builtin_eager ),
                ANYTERM( _ ), ANYTERM( _ ),
                ANYTERM( _ ), ANYTERM( _ ) ) ) ),

                ANYTERM( _ ) ) ),
            GetBuiltinEagerFuncInvocationRule() );
    }
}

#include "builtins/builtins.h"
#include "common.h"

using namespace goose::sema;

namespace goose::builtins
{
    class BuiltinFuncInvocationRule : public BaseFuncInvocationRule
    {
        public:
            Value invoke( Context& c, LocationId loc, const Value& callee, const Term& args, const Term& typeCheckedCallPat, TypeCheckingContext& tcc ) const final
            {
                auto callDecomp = Decompose( typeCheckedCallPat,
                    Val< pvec >()
                );

                const auto& typeCheckedRType = callDecomp->get()->terms().front();
                auto typeCheckedArgs = DropVectorTerm( typeCheckedCallPat, 1 );
                auto argCount = VecSize( typeCheckedArgs );
                auto argsInstrSeq = BuildArgsInstrSeq( typeCheckedArgs );

                return BuildComputedValue( typeCheckedRType, argsInstrSeq, callee, cir::Call( argCount, loc ) );
            }

            Value prepareFunc( const Context& c, LocationId funcValLocation, const Value& callee, const Term& typeCheckedCallPat, TypeCheckingContext& tcc ) const final
            {
                return callee;
            }
    };

    const ptr< InvocationRule >& GetBuiltinFuncInvocationRule()
    {
        static ptr< InvocationRule > pRule = make_shared< BuiltinFuncInvocationRule >();
        return pRule;
    }

    void SetupBuiltinFuncInvocationRule( Env& e )
    {
        e.invocationRuleSet()->addRule(
            ValueToEIR( ValuePattern( ANYTERM( _ ),

                ValueToEIR( Value( TypeType(), VEC( TSID( func ),
                TSID( builtin ),
                ANYTERM( _ ), ANYTERM( _ ),
                ANYTERM( _ ), ANYTERM( _ ) ) ) ),

                ANYTERM( _ ) ) ),
            GetBuiltinFuncInvocationRule() );
    }
}

#include "builtins/builtins.h"
#include "common.h"

using namespace goose::sema;

namespace goose::builtins
{
    class BuiltinIntrinsicFuncInvocationRule : public BaseFuncInvocationRule
    {
        public:
            Value invoke( Context& c, LocationId loc, const Value& callee, const Term& args, const Term& typeCheckedCallPat, TypeCheckingContext& tcc ) const final
            {
                auto typeCheckedArgs = DropVectorTerm( typeCheckedCallPat, 1 );
                return GetBuiltinIntrinsicFuncWrapper( callee )( c, move( typeCheckedArgs ) );
            }

            Value prepareFunc( const Context& c, LocationId funcValLocation, const Value& callee, const Term& typeCheckedCallPat, TypeCheckingContext& tcc ) const final
            {
                return callee;
            }
    };

    const ptr< InvocationRule >& GetBuiltinIntrinsicFuncInvocationRule()
    {
        static ptr< InvocationRule > pRule = make_shared< BuiltinIntrinsicFuncInvocationRule >();
        return pRule;
    }

    void SetupBuiltinIntrinsicFuncInvocationRule( Env& e )
    {
        e.invocationRuleSet()->addRule(
            ValueToEIR( ValuePattern( ANYTERM( _ ),

                ValueToEIR( Value( TypeType(), VEC( TSID( func ),
                TSID( intrinsic_builtin ),
                ANYTERM( _ ), ANYTERM( _ ),
                ANYTERM( _ ), ANYTERM( _ ) ) ) ),

                ANYTERM( _ ) ) ),
            GetBuiltinIntrinsicFuncInvocationRule() );
    }
}

#include "builtins/builtins.h"
#include "common.h"

using namespace goose::sema;

namespace goose::builtins
{
    Value BaseFuncInvocationRule::resolveInvocation( Context& c, LocationId loc, const Value& callee, const Term& args ) const
    {
        optional< TypeCheckingContext > bestTCC;
        optional< Term > bestSol;

        auto sig = GetFuncSig( callee );
        auto callPat = PrependToVectorTerm( args, HOLE( "_"_sid ) );

        auto us = FindBestTyping( sig, callPat, c );

        if( holds_alternative< NoUnification >( us ) )
        {
            // TODO display details
            DiagnosticsManager::GetInstance().emitErrorMessage( loc,
                "function arguments mismatch." );
            return PoisonValue();
        }

        if( holds_alternative< AmbiguousTypeCheck >( us ) )
        {
            // TODO display details
            DiagnosticsManager::GetInstance().emitErrorMessage( loc,
                "ambiguous function call." );
            return PoisonValue();
        }

        auto&& [s,tcc] = get< TCSol >( us );

        return invoke( c, loc, callee, args, s, tcc );
    }

    optional< Term > BaseFuncInvocationRule::getSignature( const Value& callee ) const
    {
        return GetFuncSig( callee );
    }
}

#ifndef GOOSE_BUILTINS_TYPES_FUNC_INVOCATION_COMMON_H
#define GOOSE_BUILTINS_TYPES_FUNC_INVOCATION_COMMON_H

namespace goose::builtins
{
    class BaseFuncInvocationRule : public InvocationRule
    {
        public:
            Value resolveInvocation( Context& c, LocationId loc, const Value& callee, const Term& args ) const final;
            optional< Term > getSignature( const Value& callee ) const final;
    };
}

#endif

#include "builtins/builtins.h"
#include "common.h"

using namespace goose::sema;

namespace goose::builtins
{
    class FuncInvocationRule : public BaseFuncInvocationRule
    {
        public:
            Value invoke( Context& c, LocationId loc, const Value& callee, const Term& args, const Term& typeCheckedCallPat, TypeCheckingContext& tcc ) const final
            {
                auto preparedCallee = prepareFunc( c, 0, callee, typeCheckedCallPat, tcc );
                if( preparedCallee.isPoison() )
                    return PoisonValue();

                auto callDecomp = Decompose( typeCheckedCallPat,
                    Val< pvec >()
                );

                const auto& typeCheckedRType = callDecomp->get()->terms().front();
                auto typeCheckedArgs = DropVectorTerm( typeCheckedCallPat, 1 );

                preparedCallee.setLocationId( loc );

                auto ft = *FromValue< FuncType >( *EIRToValue( preparedCallee.type() ) );

                auto argList = BuildArgListForCall( c, ft, typeCheckedArgs );
                if( !argList )
                    return PoisonValue();
                auto argsInstrSeq = BuildArgsInstrSeq( *argList );
                auto argCount = VecSize( *argList );

                auto result = BuildComputedValue( typeCheckedRType, argsInstrSeq, preparedCallee,
                    cir::Call( argCount, loc ) );

                if( result.type() != GetValueType< void >() && !IsExternalFunc( callee ) )
                {
                    if( cir::CanValueBeEagerlyEvaluated( result ) )
                    {
                        if( !verify::VerifyInstrSeq( c, *result.cir() ) )
                            return PoisonValue();

                        execute::VM vm;
                        result = execute::Evaluate( result, vm );
                    }

                    // Register the result for destruction.
                    if( auto cfg = GetCFG( c ) )
                        DeclareValue( c, result, cfg->getNewTemporaryIndex() );
                }

                return result;
            }

            Value prepareFunc( const Context& c, LocationId funcValLocation, const Value& callee, const Term& typeCheckedCallPat, TypeCheckingContext& tcc ) const final
            {
                // TODO better description with the function's name if possible (we may need to explicitely store it in the func)
                DiagnosticsContext dc( 0, true );
                VerbosityContext vc( Verbosity::Normal, true );

                return CompileFunc( c, callee );
            }
    };

    void SetupFuncInvocationRule( Env& e )
    {
        e.invocationRuleSet()->addRule(
            ValueToEIR( ValuePattern( ANYTERM( _ ),

                ValueToEIR( Value( TypeType(), VEC( TSID( func ),
                ANYTERM( _ ), ANYTERM( _ ), ANYTERM( _ ),
                ANYTERM( _ ), ANYTERM( _ ) ) ) ),

                ANYTERM( _ ) ) ),
            make_shared< FuncInvocationRule >() );
    }
}

#include "builtins/builtins.h"
#include "common.h"

using namespace goose::sema;

namespace goose::builtins
{
    class GhostFuncInvocationRule : public BaseFuncInvocationRule
    {
        public:
            Value invoke( Context& c, LocationId loc, const Value& callee, const Term& args, const Term& typeCheckedCallPat, TypeCheckingContext& tcc ) const final
            {
                if( !CanInvokeGhostFuncs( c ) )
                {
                    DiagnosticsManager::GetInstance().emitErrorMessage( loc,
                        "ghost functions can't be called in this context." );
                    return PoisonValue();
                }

                auto callDecomp = Decompose( typeCheckedCallPat,
                    Val< pvec >()
                );

                const auto& typeCheckedRType = callDecomp->get()->terms().front();
                auto typeCheckedArgs = DropVectorTerm( typeCheckedCallPat, 1 );
                auto argCount = VecSize( typeCheckedArgs );

                auto ft = *FromValue< FuncType >( *EIRToValue( callee.type() ) );

                auto argList = BuildArgListForCall( c, ft, typeCheckedArgs );
                if( !argList )
                    return PoisonValue();
                auto argsInstrSeq = BuildArgsInstrSeq( *argList );

                // A ghost call is a mutable reference to a ghost closure, using the special "GhostCall"
                // as the instruction to compute its "address"
                auto rt = ValueToEIR( ToValue( ReferenceType{ typeCheckedRType, MutAccessSpecifer() } ) );
                return BuildComputedValue( rt, argsInstrSeq, callee, cir::GhostCall( argCount, loc ) );
            }

            Value prepareFunc( const Context& c, LocationId funcValLocation, const Value& callee, const Term& typeCheckedCallPat, TypeCheckingContext& tcc ) const final
            {
                return callee;
            }
    };

    void SetupGhostFuncInvocationRule( Env& e )
    {
        e.invocationRuleSet()->addRule(
            ValueToEIR( ValuePattern( ANYTERM( _ ),

                ValueToEIR( Value( TypeType(), VEC( TSID( func ),
                ANYTERM( _ ), ANYTERM( _ ), ANYTERM( _ ),
                ANYTERM( _ ),
                TERM( static_cast< uint64_t >( FuncType::Kind::Ghost ) ) ) ) ),

                ANYTERM( _ ) ) ),
            make_shared< GhostFuncInvocationRule >() );
    }
}

#include "builtins/builtins.h"
#include "common.h"

using namespace goose::sema;

namespace goose::builtins
{
    class IntrinsicFuncInvocationRule : public BaseFuncInvocationRule
    {
        public:
            Value invoke( Context& c, LocationId loc, const Value& callee, const Term& args, const Term& typeCheckedCallPat, TypeCheckingContext& tcc ) const final
            {
                auto preparedCallee = prepareFunc( c, 0, callee, typeCheckedCallPat, tcc );
                if( preparedCallee.isPoison() )
                    return PoisonValue();

                auto typeCheckedArgs = DropVectorTerm( typeCheckedCallPat, 1 );
                preparedCallee.setLocationId( loc );

                auto ft = *FromValue< FuncType >( *EIRToValue( preparedCallee.type() ) );

                // Intrinsic call: we insert the context wrapper as first param,
                // wrap all args with TypeWrapper< Value >, and execute the function directly.
                auto argList = BuildArgListForIntrinsicCall( c, ft, typeCheckedArgs );
                if( !argList )
                    return PoisonValue();
                auto argsInstrSeq = BuildArgsInstrSeq( *argList );
                auto argCount = VecSize( *argList );

                execute::VM vm;
                cir::InstrSeq is;
                AppendToInstrSeq( is, argsInstrSeq, preparedCallee, cir::Call( argCount, loc ) );
                if( !vm.execute( is ) )
                    return PoisonValue();
                if( ft.returnType() == GetValueType< void >() )
                    return Value( GetValueType< void >(), 0U );

                auto result = vm.pop();
                if( !result )
                    return PoisonValue();

                // Unwrap the returned value
                auto unwrapped = FromValue< TypeWrapper< Value > >( *result );
                return unwrapped ? *unwrapped : PoisonValue();
            }

            Value prepareFunc( const Context& c, LocationId funcValLocation, const Value& callee, const Term& typeCheckedCallPat, TypeCheckingContext& tcc ) const final
            {
                // TODO better description with the function's name if possible (we may need to explicitely store it in the func)
                DiagnosticsContext dc( 0, true );
                VerbosityContext vc( Verbosity::Normal, true );

                return CompileFunc( c, callee );
            }
    };

    void SetupIntrinsicFuncInvocationRule( Env& e )
    {
        e.invocationRuleSet()->addRule(
            ValueToEIR( ValuePattern( ANYTERM( _ ),

                ValueToEIR( Value( TypeType(), VEC( TSID( func ),
                ANYTERM( _ ), ANYTERM( _ ), ANYTERM( _ ),
                ANYTERM( _ ),
                TERM( static_cast< uint64_t >( FuncType::Kind::Intrinsic ) ) ) ) ),

                ANYTERM( _ ) ) ),
            make_shared< IntrinsicFuncInvocationRule >() );
    }
}

#ifndef GOOSE_BUILTINS_TYPES_FUNC_INVOCATION_H
#define GOOSE_BUILTINS_TYPES_FUNC_INVOCATION_H

namespace goose::builtins
{
    extern void SetupBuiltinEagerFuncInvocationRule( Env& e );
    extern void SetupBuiltinFuncInvocationRule( Env& e );
    extern void SetupBuiltinIntrinsicFuncInvocationRule( Env& e );
    extern void SetupFuncInvocationRule( Env& e );
    extern void SetupGhostFuncInvocationRule( Env& e );
    extern void SetupIntrinsicFuncInvocationRule( Env& e );

    extern const ptr< InvocationRule >& GetBuiltinFuncInvocationRule();
    extern const ptr< InvocationRule >& GetBuiltinEagerFuncInvocationRule();
    extern const ptr< InvocationRule >& GetBuiltinIntrinsicFuncInvocationRule();

    template< typename F >
    struct InvocationRuleSelector
    {
        static const auto& Get() { return GetBuiltinFuncInvocationRule(); }
    };

    template< typename R, typename... T >
    struct InvocationRuleSelector< Eager< R >( T... ) >
    {
        static const auto& Get() { return GetBuiltinEagerFuncInvocationRule(); }
    };

    template< typename F >
    struct InvocationRuleSelector< Intrinsic< F > >
    {
        static const auto& Get() { return GetBuiltinIntrinsicFuncInvocationRule(); }
    };

    template< typename F >
    const ptr< InvocationRule >& GetInvocationRule()
    {
        return InvocationRuleSelector< F >::Get();
    }

    static inline void SetupFuncInvocationRules( Env& e )
    {
        SetupBuiltinEagerFuncInvocationRule( e );
        SetupBuiltinFuncInvocationRule( e );
        SetupBuiltinIntrinsicFuncInvocationRule( e );
        SetupFuncInvocationRule( e );
        SetupGhostFuncInvocationRule( e );
        SetupIntrinsicFuncInvocationRule( e );
    }
}

#endif

    {
        // When a boolean is dropped into a ghost code block, it is appended as an assertion check.
        RegisterBuiltinFunc< Intrinsic< void ( TypeWrapper< ptr< GhostCode > >, bool ) > >( e, e.extDropValue(),
            []( const Context& c, const Value& gcv, const Value& b )
            {
                auto gc = *FromValue< TypeWrapper< ptr< GhostCode > > >( gcv );

                gc->cfg()->currentBB()->append(
                    b, cir::Assert( b.locationId() )
                );
            } );

        // When a ghost code block is dropped into a code builder, we append it using a GhostBranch terminator.
        RegisterBuiltinFunc< Intrinsic< void ( TypeWrapper< ptr< CodeBuilder > >, TypeWrapper< ptr< GhostCode > > ) > >( e, e.extDropValue(),
            []( const Context& c, const Value& cbv, const Value& gcv )
            {

        // binary runtime code.
        RegisterBuiltinFunc< Intrinsic< Value ( MutRefOfTypeT, ValueOfTypeT ) > >( e, e.extInitialize(),
            []( auto&& c, const Value& r, const Value& initVal )
            {
                G_VAL_ASSERT( r, !r.isConstant() );
                auto refType = *FromValue< ReferenceType >( *EIRToValue( r.type() ) );
                return BuildComputedValue( GetValueType< void >(),
                    r, initVal, Store( refType.type(), initVal.locationId(), r.locationId() ) );
            } );

        // Default initialization for ct_int vars
        RegisterBuiltinFunc< Intrinsic< Value ( CTIntMutRefType ) > >( e, e.extInitialize(),
            []( auto&& c, const Value& r )
            {
                G_VAL_ASSERT( r, !r.isConstant() );
                auto refType = *FromValue< ReferenceType >( *EIRToValue( r.type() ) );
                return BuildComputedValue( GetValueType< void >(),
                    r, ToValue( BigInt() ), Store( refType.type(), {}, r.locationId() ) );
            } );

        // Default initialization for ct_string vars
        RegisterBuiltinFunc< Intrinsic< Value ( CTStringMutRefType ) > >( e, e.extInitialize(),
            []( auto&& c, const Value& r )
            {
                G_VAL_ASSERT( r, !r.isConstant() );
                auto refType = *FromValue< ReferenceType >( *EIRToValue( r.type() ) );
                return BuildComputedValue( GetValueType< void >(),
                    r, ToValue( ""s ), Store( refType.type(), {}, r.locationId() ) );
            } );
    }
}

    {
        public:
            bool canBeInvoked( const Context& c, const Value& callee ) const final
            {
                auto lv = *FromValue< LocalVar >( callee );

                auto val = BuildComputedValue( lv.type(),
                    GetAddrFromLocalVar( lv ),
                    cir::Load( lv.type(), {} ) );

                return sema::CanBeInvoked( c, val );
            }

            Value resolveInvocation( Context& c, LocationId locationId, const Value& callee, const Term& args ) const final
            {
                auto lv = *FromValue< LocalVar >( callee );

                auto val = BuildComputedValue( lv.type(),
                    GetAddrFromLocalVar( lv ),
                    cir::Load( lv.type(), locationId ) );

                return sema::GetInvocationRule( *c.env(), val )->resolveInvocation( c, locationId, val, args );
            }
    };

    void SetupLocalVarInvocationRule( Env& e )
    {

        if( !typeVal.isType() )
            typeVal = ToType( c, typeVal );

        if( !ParseTypePredicates( c, typeVal ) )
            return PoisonValue();

        LocalVar lv( name, ValueToEIR( typeVal ), index );
        bb->append( AllocVar( typeVal, index, locId ) );

        Value initResult;

        {
            DiagnosticsContext dc( 0, "When invoking Initialize." );

            if( initializer )

        // Retrieve the texpr's location and set it on the inferred type. This way if an
        // error occurs later with it, for instance when calling LowerTypeForRuntime on it during codegen,
        // it will have a meaningful location for the error message to attach itself on.
        auto typeLoc = EIRToValue( typeTExpr )->locationId();
        LocalVar lv( name, type, index );

        bb->append( AllocVar( EIRToValue( lv.type() )->setLocationId( typeLoc ), index, locId ) );

        DiagnosticsContext dc( 0, "When invoking Initialize." );

        auto initResult = InvokeOverloadSet( c,
            c.env()->extInitialize(),
            MakeTuple( ToValue( lv ).setLocationId( locId ), initVal ) );

            } );

        // Default implementation of LowerConstantForVerification():
        // Do nothing.
        RegisterBuiltinFunc< Intrinsic< Value ( Value ) > >( e, e.extLowerConstantForVerification(),
            []( const Context& c, const Value& v )
            {
                return v;
            } );

        // Default implementation of LowerConstantForRuntime():
        // Do nothing.
        RegisterBuiltinFunc< Intrinsic< Value ( Value ) > >( e, e.extLowerConstantForRuntime(),
            []( const Context& c, const Value& v )
            {
                return v;
            } );
    }
}

            {
                auto v = *EIRToValue( t );
                auto ty = EIRToValue( v.type() );
                out << "value[ ";
                pp.print( out, ty ? ty->val() : v.type() );
                out << " ]";
                if( v.cir() )
                {
                    out << "{ ";
                    for( const auto& instr : *v.cir() )
                        out << instr << ' ';
                    out << "}";
                }
                return true;
            } );

        pp.addRule( ValueToEIR( ValuePattern( TSID( constant ),
            ValueToEIR( Value( TypeType(), VEC( TSID( decl ), ANYTERM( _ ) ) ) ),
                ANYTERM( _ ) ) ),
            [&]( auto&& out, auto&& t )

#include "builtins/builtins.h"

namespace goose::builtins
{
    size_t Propositions::hash() const
    {
        if( !m_hash )
        {
            auto g1 = ContainerHashGenerator( m_propositions );
            m_hash = llvm::hash_combine_range( g1.begin(), g1.end() );
        }
        return *m_hash;
    }

    bool Propositions::parse( const Context& c )
    {

            ReferenceType::PatternMutableOf< ReferenceType::PatternXOfTypeT > >,
            CustomPattern< Value, ReferenceType::PatternXOfTypeT > ) > >( e, e.extInitialize(),
            []( auto&& c, const Value& r, const Value& initVal )
            {
                G_VAL_ASSERT( r, !r.isConstant() );
                auto refType = *FromValue< ReferenceType >( *EIRToValue( r.type() ) );
                return BuildComputedValue( GetValueType< void >(),
                    r, initVal, Store( refType.type(), initVal.locationId(), r.locationId() ) );
            } );
    }
}

    const Term& ReferenceType::PatternXOfTypeT::GetPattern()
    {
        static auto pattern = ValueToEIR( ToValue( ReferenceType( HOLE( "T"_sid, TSID( ttvar ) ), HOLE( "X"_sid ) ) ) );
        return pattern;
    }

    // Returns an instruction that computes the address of whatever's contained in the locvar.
    cir::Instruction GetAddrFromLocalVar( const LocalVar& lv )
    {
        // TODO LOC: may need loc in LocalVar
        return cir::VarAddr( lv.index(), lv.type(), {} );
    }

    Value BuildLocalVarMutRef( const LocalVar& lv )
    {
        // TODO LOC: may need loc in LocalVar
        auto rt = ValueToEIR( ToValue( ReferenceType{ lv.type(), MutAccessSpecifer() } ) );
        return BuildComputedValue( move( rt ), cir::VarAddr( lv.index(), lv.type(), {} ) );
    }

    const Term& MutAccessSpecifer()
    {
        static auto al = ValueToEIR( ToValue( AccessSpecifier( "mut"_sid ) ) );
        return al;
    }

            // Not an enum because we want to be able
            // to have holes there and it's a pain in
            // the ass
            Term m_behavior;
    };

    extern cir::Instruction GetAddrFromLocalVar( const LocalVar& lv );
    extern Value BuildLocalVarMutRef( const LocalVar& lv );
}

namespace goose::eir
{
    template<>
    struct Bridge< builtins::ReferenceType >

        if( !refval )
            co_return;

        auto refType = FromValue< ReferenceType >( *EIRToValue( refval->type() ) );
        if( !refType )
            co_return;

        auto loc = refval->locationId() ;
        auto content = ValueToEIR( BuildComputedValue( refType->type(),
            *refval, cir::Load( refType->type(), loc ) )
            .setLocationId( loc ) );

        // TypeCheck the param with the ref's content
        co_yield TypeCheck( lhs, content, tcc );
    }

    TCGen TypeCheckingBuildTempRef( const Term& lhs, const Term& rhs, const TypeCheckingContext& tcc )
    {

                auto rhsVal = *EIRToValue( rhs );

                auto cfg = GetCFG( tcc.context() );
                if( !cfg )
                    return nullopt;

                // TODO create an ext point for this
                auto loc = rhsVal.locationId();
                auto tempIndex = cfg->getNewTemporaryIndex();
                return ValueToEIR( BuildComputedValue( ValueToEIR( ToValue( rt ) ), rhsVal,
                    TempAddr( tempIndex, loc ) ).setLocationId( loc ) );
            } );

            // Override the weight because we don't want
            // this solution to count more than directly using
            // the value without wrapping it into a tempref
            SetWeight( wrapped, GetWeight( rhs ) - 1 );
            co_yield { move( wrapped ), tcc };

            auto ltype = ValuePatternFromEIR( lhs )->type();

            auto rrefVal = *EIRToValue( rhs );
            auto rrType = FromValue< ReferenceType >( *EIRToValue( rrefVal.type() ) );
            if( !rrType )
                co_return;

            auto loc = rrefVal.locationId();
            auto content = ValueToEIR( BuildComputedValue( rrType->type(),
                rrefVal, cir::Load( rrType->type(), loc ) ).setLocationId( loc ) );

            co_yield TypeCheck( lhs, content, tcc );
        } );

        // Implicit referencing of non-variables against a non mutable ref: build a tempref
        e.typeCheckingRuleSet()->addTypeCheckingRule( TCRINFOS,

        // Initialization for integer vars
        RegisterBuiltinFunc< Intrinsic< Value ( IntegerMutRefType, IntegerType ) > >( e, e.extInitialize(),
            []( auto&& c, const Value& r, const Value& initVal )
            {
                G_VAL_ASSERT( r, !r.isConstant() );
                auto refType = *FromValue< ReferenceType >( *EIRToValue( r.type() ) );
                return BuildComputedValue( GetValueType< void >(),
                    r, initVal, Store( refType.type(), initVal.locationId(), r.locationId() ) );
            } );
    }
}

            {
                DiagnosticsContext dc( loc, loc.invalid() ? "" : "Called here.", false );

                auto instanceFunc = InstantiateTFunc( c, callee, checkedCallPat, tcc );
                if( instanceFunc.isPoison() )
                    return PoisonValue();

                auto pIR = GetInvocationRule( *c.env(), instanceFunc );
                G_VAL_ASSERT( callee, pIR );
                G_VAL_ASSERT( callee, pIR->canBeInvoked( c, instanceFunc ) );

                return pIR->resolveInvocation( c, loc, instanceFunc, args );
            }

            optional< Term > getSignature( const Value& callee ) const final
            {
                auto tfuncVal = FromValue< TFunc >( callee );
                assert( tfuncVal );
                return tfuncVal->signature();

            DiagnosticsManager::GetInstance().emitErrorMessage( 0, "Incompatible tuple sizes." );
            return;
        }

        ForEachInTupleType( tupType, [&]( auto&& t )
        {
            auto elemType = *EIRToValue( t );
            auto loc = elemType.locationId();

            // Create a mutable reference to the element to initialize
            ReferenceType rt( t, MutAccessSpecifer() );
            auto elemRef = BuildComputedValue( ValueToEIR( ToValue( rt ) ),
                tupRef, Select( index, loc ) ).setLocationId( loc );

            auto elemInit = *EIRToValue( GetTupleElement( initTup, index++ ) );

            DiagnosticsContext dc( elemType.locationId(), "When invoking Initialize." );
            auto init = InvokeOverloadSet( c, c.env()->extInitialize(),
                MakeTuple( elemRef, move( elemInit ) ) );

                uint32_t index = 0;
                auto tupType = *EIRToValue( refType.type() );

                ForEachInTupleType( tupType, [&]( auto&& t )
                {
                    auto elemType = *EIRToValue( t );
                    auto loc = elemType.locationId();

                    // Create a mutable reference to the element to initialize
                    ReferenceType rt( t, MutAccessSpecifer() );
                    auto elemRef = BuildComputedValue( ValueToEIR( ToValue( rt ) ),
                        tupRef, Select( index++, loc ) ).setLocationId( loc );

                    DiagnosticsContext dc( elemType.locationId(), "When invoking Initialize." );
                    auto init = InvokeOverloadSet( c, c.env()->extInitialize(),
                        MakeTuple( elemRef ) );

                    DiagnosticsContext dc2( elemType.locationId(), "When invoking DropValue." );
                     InvokeOverloadSet( c, c.env()->extDropValue(),

    {
        auto param = ParamPat( GetTupleTypeElement( tupType, index ) );

        auto argType = GetTupleElementType( tupArg, index );
        ReferenceType rt( argType, ConstAccessSpecifer() );

        G_VAL_ASSERT( tupArgRef, !tupArgRef.isConstant() );


        auto argRef = ValueToEIR( BuildComputedValue( ValueToEIR( ToValue( rt ) ),
            tupArgRef, cir::Select( index, tupArg.locationId() ) ) );

        auto tupSize = TupleTypeSize( tupType );

        for( auto&& [s,tcc] : TypeCheck( param, argRef, tcc ) )
        {
            auto val = ValuePatternFromEIR( s );
            assert( val );

            auto tupType = *EIRToValue( ltup->type() );
            assert( TupleTypeSize( tupType ) == TupleTypeSize( *EIRToValue( rtup->type() ) ) );

            // TODO create an ext point for this instead of going directly thru cfg
            auto tempIndex = cfg->getNewTemporaryIndex();

            auto rtupref = BuildComputedValue( ValueToEIR( ToValue( ReferenceType{ rtup->type(), ConstAccessSpecifer() } ) ),
                *rtup, cir::TempAddr( tempIndex, rtup->locationId() ) );

            co_yield TypeCheckComputedTuple( tcc, tupType, *rtup, rtupref, 0, EmptyTuple() );
        } );

        // Single element tuple unwrapping rules: if we encounter such a tuple, attempt to typecheck
        // its contained value with whatever's on the other side.
        e.typeCheckingRuleSet()->addTypeCheckingRule( TCRINFOS,

        SetupPredicatesTypeChecking( e );

        SetupBasicTypes( e );
        SetupBasicTypesPrettyPrinting();

        SetupTupleTypeChecking( e );

        SetupFuncInvocationRules( e );
        SetupFunctionTypeChecking( e );
        SetupFunctionLowering( e );

        SetupTemplateRules( e );
        SetupTemplateFunctionInvocationRule( e );
        SetupTemplateFunctionTypeChecking( e );
        SetupTDeclTypeChecking( e );

#include "ghostcode/ghostcode.h"

#include "func/bfunc.h"
#include "func/bintrinsic.h"
#include "func/functype.h"
#include "func/func.h"
#include "func/build.h"
#include "func/invocation/invocation.h"

#include "basic.h"
#include "decl.h"
#include "runtime/runtime.h"
#include "wrapper.h"

#include "template/tvar.h"

#ifndef GOOSE_CIR_ALLOCVAR_H
#define GOOSE_CIR_ALLOCVAR_H

namespace goose::cir
{
    class AllocVar : public BaseInstr< 0, false >
    {
        public:
            template< typename T >
            AllocVar( T&& type, uint32_t index, LocationId loc ) :
                BaseInstr( loc ),
                m_type( forward< T >( type ) ),
                m_index( index )
            {}

            const auto& type() const { return m_type; }
            const auto& index() const { return m_index; }

            bool canBeExecuted() const { return true; }
            bool canBeEagerlyEvaluated() const { return false; }
            bool haveSideEffects() const { return true; }

            bool operator<( const AllocVar& rhs ) const
            {
                if( m_index != rhs.m_index )
                    return m_index < rhs.m_index;
                return m_type < rhs.m_type;
            }

#ifndef GOOSE_CIR_ARITH_H
#define GOOSE_CIR_ARITH_H

namespace goose::cir
{
    class Add : public BinaryOp
    {
        public:
            Add( LocationId loc ) :
                BinaryOp( loc )
            {}

            friend ostream& operator<<( ostream& out, const Add& ins )
            {
                return out << "ADD";
            }
    };

    class Sub : public BinaryOp
    {
        public:
            Sub( LocationId loc ) :
                BinaryOp( loc )
            {}

            friend ostream& operator<<( ostream& out, const Sub& ins )
            {
                return out << "SUB";
            }
    };

    class Mul : public BinaryOp
    {
        public:
            Mul( LocationId loc ) :
                BinaryOp( loc )
            {}

            friend ostream& operator<<( ostream& out, const Mul& ins )
            {
                return out << "MUL";
            }
    };

    class UDiv : public BinaryOp
    {
        public:
            UDiv( LocationId loc ) :
                BinaryOp( loc )
            {}

            friend ostream& operator<<( ostream& out, const UDiv& ins )
            {
                return out << "UDIV";
            }
    };

    class SDiv : public BinaryOp
    {
        public:
            SDiv( LocationId loc ) :
                BinaryOp( loc )
            {}

            friend ostream& operator<<( ostream& out, const SDiv& ins )
            {
                return out << "SDIV";
            }
    };

    class URem : public BinaryOp
    {
        public:
            URem( LocationId loc ) :
                BinaryOp( loc )
            {}

            friend ostream& operator<<( ostream& out, const URem& ins )
            {
                return out << "UREM";
            }
    };

    class SRem : public BinaryOp
    {
        public:
            SRem( LocationId loc ) :
                BinaryOp( loc )
            {}

            friend ostream& operator<<( ostream& out, const SRem& ins )
            {
                return out << "SREM";
            }
    };
}

#endif

#ifndef GOOSE_CIR_ASS_H
#define GOOSE_CIR_ASS_H

// This file is not called "assert.h" because that fucks the cassert header up
// when it tries to include assert.h.
// "ass" is both a good shorthand and an accurate description of the problem

namespace goose::cir
{
    class Assert : public BaseInstr< 1, false >
    {
        public:

            Assert( LocationId loc ) :

                BaseInstr( loc )
            {}



            bool canBeExecuted() const { return true; }
            bool canBeEagerlyEvaluated() const { return false; }
            bool haveSideEffects() const { return true; }

            bool operator<( const Assert& rhs ) const
            {
                return false;
            }

            friend ostream& operator<<( ostream& out, const Assert& ins )
            {
                return out << "ASSERT";
            }



    };
}

#endif

            const auto& loopEdges() const { return m_loopEdges; }

            uint32_t loopId() const { return m_loopId; }
            bool isLoopHeader() const { return m_isLoopHeader; }
            void setLoopId( uint32_t id ) { m_loopId = id; }
            void setLoopHeader() { m_isLoopHeader = true; }




            auto* llvmBB() { return m_llvmBB; }
            void setLLVMBB( llvm::BasicBlock* pBB ) { m_llvmBB = pBB; }

            auto empty() const { return m_instructions.empty(); }

            const auto& instructions() const { return m_instructions; }

            using RunnableInstructions = llvm::SmallVector< Instruction, 16 >;
            const RunnableInstructions* runnableInstructions() const
            {
                if( m_dirty )
                {
                    m_dirty = false;

                    m_runnableInstructions.clear();
                    if( !FilterVerificationInstructions( m_instructions, m_runnableInstructions ) )
                        return nullptr;
                }

                return &m_runnableInstructions;
            }


            void clear()
            {
                m_instructions.clear();
                m_dirty = true;
            }

            template< typename... I >
            void append( I&&... instrs )
            {
                AppendToInstrSeq( m_instructions, forward< I >( instrs )... );
                m_dirty = true;

            }

            template< typename T >
            void setTerminator( T&& terminator );

            const auto& terminator() const { return m_terminator; }

            bool canBeExecuted() const

            bool codeGenStarted() const { return m_codeGenStarted; }
            void setCodeGenStarted( bool b = true ) { m_codeGenStarted = b; }

            template< typename F >
            void forEachSuccessor( F&& func ) const;

        private:
            InstrSeq                m_instructions;
            mutable RunnableInstructions m_runnableInstructions;
            optional< Terminator >  m_terminator;

            weak_ptr< CFG >         m_owner;

            llvm::SmallVector< uint32_t, 8 >    m_backEdges;
            llvm::SmallVector< uint32_t, 8 >    m_loopEdges;

            llvm::BasicBlock*       m_llvmBB = nullptr;

            uint32_t                m_index = 0;

            uint32_t                m_loopId = 0;           // Id of the header of the loop that this block belongs to, or 0.

            eir::LocationId         m_locId = 0;            // An optional location id. Used by the verifier on loop headers
                                                            // to indicate the location of a loop that it failed to verify.

            bool                    m_isLoopHeader = false;

            bool                    m_canBeExecuted = true;
            bool                    m_canBeEagerlyEvaluated = true;

            mutable bool            m_dirty = false;
            mutable bool            m_codeGenStarted = false;
    };
}

#endif

#ifndef GOOSE_CIR_BASICBLOCK_INL
#define GOOSE_CIR_BASICBLOCK_INL

namespace goose::cir
{



















    template< typename T >
    void BasicBlock::setTerminator( T&& terminator )
    {
        m_terminator = forward< T >( terminator );
        m_terminator->addCFGEdges( m_owner.lock(), index() );
    }

#ifndef GOOSE_CIR_BINARYINSTR_H
#define GOOSE_CIR_BINARYINSTR_H

namespace goose::cir
{
    class BinaryOp : public BaseInstr< 2, true >
    {
        public:

            BinaryOp( LocationId loc ) :
                BaseInstr( loc )

            {}




            bool canBeExecuted() const { return true; }
            bool canBeEagerlyEvaluated() const { return true; }
            bool haveSideEffects() const { return false; }

            bool operator<( const BinaryOp& rhs ) const
            {

                return false;






















            }
    };
}

#endif

#ifndef GOOSE_CIR_BITWISE_H
#define GOOSE_CIR_BITWISE_H

namespace goose::cir
{
    class Shl : public BinaryOp
    {
        public:
            Shl( LocationId loc ) :
                BinaryOp( loc )
            {}

            friend ostream& operator<<( ostream& out, const Shl& ins )
            {
                return out << "SHL";
            }
    };

    class LShr : public BinaryOp
    {
        public:
            LShr( LocationId loc ) :
                BinaryOp( loc )
            {}

            friend ostream& operator<<( ostream& out, const LShr& ins )
            {
                return out << "LSHR";
            }
    };

    class AShr : public BinaryOp
    {
        public:
            AShr( LocationId loc ) :
                BinaryOp( loc )
            {}

            friend ostream& operator<<( ostream& out, const AShr& ins )
            {
                return out << "ASHR";
            }
    };
}

#endif

        private:
            wptr< BasicBlock > m_dest;
    };

    class CondBranch
    {
        public:
            template< typename BT, typename BF >
            CondBranch( BT&& trueDest, BF&& falseDest ) :

                m_trueDest( forward< BT >( trueDest ) ),
                m_falseDest( forward< BF >( falseDest ) )
            {}


            const auto& trueDest() const { return m_trueDest; }
            const auto& falseDest() const { return m_falseDest; }

            bool canBeExecuted() const { return true; }




            bool canBeEagerlyEvaluated() const { return true; }




            void addCFGEdges( const ptr< CFG >& cfg, uint32_t srcBBIndex );

        private:

            wptr< BasicBlock > m_trueDest;
            wptr< BasicBlock > m_falseDest;
    };

    // A special terminator that points to a basic block to use only
    // during verification (containing "ghost code") and to a continuation
    // basic block

#ifndef GOOSE_CIR_CALL_H
#define GOOSE_CIR_CALL_H

namespace goose::cir
{
    class Call : public BaseInstr< 1, true >   // Can pop more depending on arg count
    {
        public:

            Call( uint32_t numArgs, LocationId loc ) :
                BaseInstr( loc ),
                m_numArgs( numArgs )
            {}


            const auto& numArgs() const { return m_numArgs; }

            bool canBeExecuted() const { return true; }
            bool canBeEagerlyEvaluated() const { return true; }
            bool haveSideEffects() const { return true; }

            bool operator<( const Call& rhs ) const
            {


                return m_numArgs < rhs.m_numArgs;
            }

            friend ostream& operator<<( ostream& out, const Call& ins )
            {
                return out << "CALL";
            }

        private:
            uint32_t m_numArgs = 0;

    };
}

#endif

    {
        public:
            CFG( uint32_t numParams ) :
                m_temporariesCount( numParams )
            {}

            bool isPoisoned() const { return m_poisoned; }
            void poison()
            {
                m_poisoned = true;
            }

            const auto& entryBB() const { return m_basicBlocks.front(); }
            const auto& lastBB() const { return m_basicBlocks.back(); }

            const auto& currentBB() const { return m_currentBB; }
            template< typename T >
            void setCurrentBB( T&& pBB )

            const auto& getBB( uint32_t index ) const { return m_basicBlocks[index - 1]; }

            auto count() const { return m_basicBlocks.size(); }

            const ptr< BasicBlock >& createBB();

            auto getNewTemporaryIndex() { return m_temporariesCount++; }
            auto temporariesCount() const { return m_temporariesCount; }

            // Clear the llvm basic block pointers from the entire cfg.
            void unbindFromLLVM();

            bool canBeExecuted() const;
            bool canBeEagerlyEvaluated() const;

            template< typename F >
            void forEachBB( F&& func )
            {
                for( auto&& bb : m_basicBlocks )
                    func( bb );
            }

            void setStorageLocationModifiedByLoop( uint32_t loopId, const eir::Term& type, const StorageLocation& sloc )
            {
                m_loopModifiedStorageLocations.emplace( make_pair( loopId, sloc ), type );
            }

            template< typename F >
            void forEachStorageLocationModifiedByLoop( uint32_t loopId, F&& func ) const
            {
                auto begin = m_loopModifiedStorageLocations.lower_bound( { loopId, Address{ Address::Origin::Stack, 0, 0 } } );
                auto end = m_loopModifiedStorageLocations.upper_bound( { loopId, monostate() } );

                for( auto it = begin; it != end; ++it )
                    func( it->second, it->first.second );
            }

            template< typename F >
            void forEachReachableBlock( const ptr< BasicBlock >& bb, F&& func ) const

            // All the edges of the CFG in SrcBBIndex, DestBBIndex form
            unordered_multimap< uint32_t, uint32_t > m_edges;

            // For each BB, store the index of its immediate dominator.
            // May be be empty if it has not (yet) been computed.
            vector< uint32_t > m_idoms;

            // For each loop, store all of the storage locations modified
            // during that loop.
            // May be be empty if it has not (yet) been computed.
            multimap< pair< uint32_t, StorageLocation >, eir::Term > m_loopModifiedStorageLocations;

            // The number of temporary indices used by this CFG.
            uint32_t m_temporariesCount = 0;

            uint32_t m_loopCount = 0;

            bool m_poisoned = false;

#include "cir/cir.h"
#include "builtins/builtins.h"

using namespace goose::builtins;

namespace goose::cir
{
    void CfgViz( GraphVizBuilder& builder, const Func& func )
    {
        if( func.body() )
            CfgViz( builder, *func.body() );
    }

    void CfgViz( GraphVizBuilder& builder, const CFG& cfg )
    {
        CfgViz( builder, cfg.entryBB() );
    }

    void CfgViz( GraphVizBuilder& builder, const ptr< BasicBlock >& bb )
    {

            sstr << ", L" << bb->loopId();

        if( bb->isLoopHeader() )
            sstr << ", LH";

        GraphVizBuilder::Node n( builder, bb.get(), sstr.str().c_str() );

        for( auto&& instr : bb->instructions() )
            CfgViz( builder, instr );

        if( bb->terminator() )
            CfgViz( builder, *bb->terminator() );
    }

    void CfgViz( GraphVizBuilder& builder, const eir::Value& val )

            GraphVizBuilder::Color col( builder );
            builder.output() << val;
            return;
        }

        CfgViz( builder, *val.cir() );
    }

    void CfgViz( GraphVizBuilder& builder, const InstrSeq& is )
    {
        for( const auto& instr : is )
            CfgViz( builder, instr );
    }

    void CfgViz( GraphVizBuilder& builder, const Instruction& instr )
    {
        visit( [&]( auto&& ins )
        {
            CfgViz( builder, ins );
        }, instr.content() );

    void CfgViz( GraphVizBuilder& builder, const Call& instr )
    {
        GraphVizBuilder::Row row( builder );
        GraphVizBuilder::Cell cell( builder );
        GraphVizBuilder::Color col( builder );

        builder.output() << "Call " << instr.numArgs();
    }

    void CfgViz( GraphVizBuilder& builder, const Constant& instr )
    {
        GraphVizBuilder::Row row( builder );
        GraphVizBuilder::Cell cell( builder );
        GraphVizBuilder::Color col( builder );

        stringstream sstr;
        sstr << instr.value();
        for( auto c : sstr.str() )
        {
            switch( c )
            {
                case '<':
                    builder.output() << "&lt;";
                    break;

                case '>':
                    builder.output() << "&gt;";
                    break;

                default:
                    builder.output() << c;
            }
        }
    }

    void CfgViz( GraphVizBuilder& builder, const VarAddr& instr )
    {
        GraphVizBuilder::Row row( builder );
        GraphVizBuilder::Cell cell( builder );
        GraphVizBuilder::Color col( builder );

        builder.output() << "VarAddr " << instr.varIndex();
    }

    void CfgViz( GraphVizBuilder& builder, const TempAddr& instr )
    {
        GraphVizBuilder::Row row( builder );
        GraphVizBuilder::Cell cell( builder );
        GraphVizBuilder::Color col( builder );

        builder.output() << "TempAddr " << instr.tempIndex();
    }

    void CfgViz( GraphVizBuilder& builder, const Select& instr )
    {
        GraphVizBuilder::Row row( builder );
        GraphVizBuilder::Cell cell( builder );
        GraphVizBuilder::Color col( builder );

        builder.output() << "Select " << instr.memberIndex();
    }

    void CfgViz( GraphVizBuilder& builder, const CreateTemporary& instr )
    {






        GraphVizBuilder::Row row( builder );
        GraphVizBuilder::Cell cell( builder );
        GraphVizBuilder::Color col( builder );

        builder.output() << "CreateTemporary " << instr.index();

    }

    void CfgViz( GraphVizBuilder& builder, const GetTemporary& instr )
    {
        GraphVizBuilder::Row row( builder );
        GraphVizBuilder::Cell cell( builder );
        GraphVizBuilder::Color col( builder );

            auto id = builder.getNodeId( pBB.get() );
            GraphVizBuilder::Color col( builder, GraphVizBuilder::GetNodeColor( id ) );

            builder.output() << "BB #" << id << ", " << index;
            return true;
        } );
    }

    void CfgViz( GraphVizBuilder& builder, const RetVoid& t )
    {
        GraphVizBuilder::Row row( builder );
        GraphVizBuilder::Cell cell( builder );
        GraphVizBuilder::Color col( builder );
        builder.output() << "RetVoid";
    }

    void CfgViz( GraphVizBuilder& builder, const Ret& t )
    {
        GraphVizBuilder::Row row( builder );
        GraphVizBuilder::Cell cell( builder );















        GraphVizBuilder::Color col( builder );
        builder.output() << "Ret";

    }

    void CfgViz( GraphVizBuilder& builder, const Not& instr )
    {
        GraphVizBuilder::Row row( builder );
        GraphVizBuilder::Cell cell( builder );
        GraphVizBuilder::Color col( builder );

        builder.output() << "BinaryOp";
    }

    void CfgViz( GraphVizBuilder& builder, const Assert& instr )
    {
        GraphVizBuilder::Row row( builder );
        GraphVizBuilder::Cell cell( builder );






        GraphVizBuilder::Color col( builder );

        builder.output() << "Assert";

    }

    void CfgViz( GraphVizBuilder& builder, const Placeholder& instr )
    {
        GraphVizBuilder::Row row( builder );
        GraphVizBuilder::Cell cell( builder );
        builder.output() << '@' << instr.name();
    }

    void CfgViz( GraphVizBuilder& builder, const PHOverrideSet& instr )
    {
        GraphVizBuilder::Row row( builder );
        GraphVizBuilder::Cell cell( builder );
        GraphVizBuilder::Color col( builder );
        builder.output() << "PHOverrideSet";
    }

    void CfgViz( GraphVizBuilder& builder, const PHOverrideClear& instr )
    {
        GraphVizBuilder::Row row( builder );
        GraphVizBuilder::Cell cell( builder );
        GraphVizBuilder::Color col( builder );
        builder.output() << "PHOverrideClear";
    }

    void CfgViz( GraphVizBuilder& builder, const GhostCall& instr )
    {
        GraphVizBuilder::Row row( builder );
        GraphVizBuilder::Cell cell( builder );
        GraphVizBuilder::Color col( builder );

            CfgViz( builder, t.trueDest().lock() );
            CfgViz( builder, t.falseDest().lock() );
        } );

        {
            GraphVizBuilder::Row row( builder );
            GraphVizBuilder::Cell cell( builder );

            GraphVizBuilder::Color col( builder );

            builder.output() << "CondBranch";
        }

        GraphVizBuilder::Row row( builder );

        {
            GraphVizBuilder::Cell cell( builder );

            CfgViz( builder, t.ghostCode().lock() );
            CfgViz( builder, t.continuation().lock() );
        } );

        {
            GraphVizBuilder::Row row( builder );
            GraphVizBuilder::Cell cell( builder );
            GraphVizBuilder::Color col( builder );

            builder.output() << "GhostBranch";
        }

        GraphVizBuilder::Row row( builder );

        {

#ifndef GOOSE_CIR_CFGVIZ_H
#define GOOSE_CIR_CFGVIZ_H

namespace goose::cir
{
    template< typename T >
    void CfgViz( const char* pFilename, const T& x )
    {
        ofstream file( pFilename );
        GraphVizBuilder builder( file, true );
        CfgViz( builder, x );
    }

    extern void CfgViz( GraphVizBuilder& builder, const Func& func );
    extern void CfgViz( GraphVizBuilder& builder, const CFG& cfg );
    extern void CfgViz( GraphVizBuilder& builder, const ptr< BasicBlock >& bb );
    extern void CfgViz( GraphVizBuilder& builder, const eir::Value& val );

    extern void CfgViz( GraphVizBuilder& builder, const InstrSeq& is );
    extern void CfgViz( GraphVizBuilder& builder, const Instruction& instr );
    extern void CfgViz( GraphVizBuilder& builder, const Terminator& t );

    extern void CfgViz( GraphVizBuilder& builder, const monostate& );
    extern void CfgViz( GraphVizBuilder& builder, const Call& instr );

    extern void CfgViz( GraphVizBuilder& builder, const Constant& instr );
    extern void CfgViz( GraphVizBuilder& builder, const VarAddr& instr );
    extern void CfgViz( GraphVizBuilder& builder, const TempAddr& instr );
    extern void CfgViz( GraphVizBuilder& builder, const Select& instr );
    extern void CfgViz( GraphVizBuilder& builder, const CreateTemporary& instr );
    extern void CfgViz( GraphVizBuilder& builder, const GetTemporary& instr );
    extern void CfgViz( GraphVizBuilder& builder, const AllocVar& instr );
    extern void CfgViz( GraphVizBuilder& builder, const Load& instr );
    extern void CfgViz( GraphVizBuilder& builder, const Store& instr );
    extern void CfgViz( GraphVizBuilder& builder, const Phi& instr );

    extern void CfgViz( GraphVizBuilder& builder, const Not& instr );
    extern void CfgViz( GraphVizBuilder& builder, const BinaryOp& instr );

    extern void CfgViz( GraphVizBuilder& builder, const Assert& instr );
    extern void CfgViz( GraphVizBuilder& builder, const Placeholder& instr );
    extern void CfgViz( GraphVizBuilder& builder, const PHOverrideSet& instr );
    extern void CfgViz( GraphVizBuilder& builder, const PHOverrideClear& instr );
    extern void CfgViz( GraphVizBuilder& builder, const GhostCall& instr );

    extern void CfgViz( GraphVizBuilder& builder, const RetVoid& t );
    extern void CfgViz( GraphVizBuilder& builder, const Ret& t );
    extern void CfgViz( GraphVizBuilder& builder, const Branch& t );
    extern void CfgViz( GraphVizBuilder& builder, const CondBranch& t );
    extern void CfgViz( GraphVizBuilder& builder, const GhostBranch& t );
    extern void CfgViz( GraphVizBuilder& builder, const Break& t );
    extern void CfgViz( GraphVizBuilder& builder, const Continue& t );
}

#endif

    static constexpr uint32_t InvalidVarId = numeric_limits< uint32_t >::max();

    class CFG;
}

#include "helpers.h"

#include "storagelocation.h"

#include "constant.h"
#include "varaddr.h"
#include "tempaddr.h"
#include "select.h"
#include "call.h"
#include "createtemporary.h"
#include "gettemporary.h"
#include "allocvar.h"

#include "ass.h"
#include "placeholder.h"
#include "phoverride.h"
#include "ghostcall.h"

#include "instruction.h"
#include "terminator.h"
#include "verifinstrfilter.h"
#include "basicblock.h"
#include "cfg.h"
#include "func.h"
#include "hash.h"
#include "decorator.h"
#include "cfgviz.h"

#include "basicblock.inl"

#endif

#ifndef GOOSE_CIR_COMPARISON_H
#define GOOSE_CIR_COMPARISON_H

namespace goose::cir
{
    class Eq : public BinaryOp
    {
        public:
            Eq( LocationId loc ) :
                BinaryOp( loc )
            {}

            friend ostream& operator<<( ostream& out, const Eq& ins )
            {
                return out << "EQ";
            }
    };

    class Neq : public BinaryOp
    {
        public:
            Neq( LocationId loc ) :
                BinaryOp( loc )
            {}

            friend ostream& operator<<( ostream& out, const Neq& ins )
            {
                return out << "NEQ";
            }
    };

    class UGT : public BinaryOp
    {
        public:
            UGT( LocationId loc ) :
                BinaryOp( loc )
            {}

            friend ostream& operator<<( ostream& out, const UGT& ins )
            {
                return out << "UGT";
            }
    };

    class UGE : public BinaryOp
    {
        public:
            UGE( LocationId loc ) :
                BinaryOp( loc )
            {}

            friend ostream& operator<<( ostream& out, const UGE& ins )
            {
                return out << "UGE";
            }
    };

    class ULT : public BinaryOp
    {
        public:
            ULT( LocationId loc ) :
                BinaryOp( loc )
            {}

            friend ostream& operator<<( ostream& out, const ULT& ins )
            {
                return out << "ULT";
            }
    };

    class ULE : public BinaryOp
    {
        public:
            ULE( LocationId loc ) :
                BinaryOp( loc )
            {}

            friend ostream& operator<<( ostream& out, const ULE& ins )
            {
                return out << "ULE";
            }
    };

    class SGT : public BinaryOp
    {
        public:
            SGT( LocationId loc ) :
                BinaryOp( loc )
            {}

            friend ostream& operator<<( ostream& out, const SGT& ins )
            {
                return out << "SGT";
            }
    };

    class SGE : public BinaryOp
    {
        public:
            SGE( LocationId loc ) :
                BinaryOp( loc )
            {}

            friend ostream& operator<<( ostream& out, const SGE& ins )
            {
                return out << "SGE";
            }
    };

    class SLT : public BinaryOp
    {
        public:
            SLT( LocationId loc ) :
                BinaryOp( loc )
            {}

            friend ostream& operator<<( ostream& out, const SLT& ins )
            {
                return out << "SLT";
            }
    };

    class SLE : public BinaryOp
    {
        public:
            SLE( LocationId loc ) :
                BinaryOp( loc )
            {}

            friend ostream& operator<<( ostream& out, const SLE& ins )
            {
                return out << "SLE";
            }
    };
}

#endif

#ifndef GOOSE_CIR_CONSTANT_H
#define GOOSE_CIR_CONSTANT_H

namespace goose::cir
{
    class Constant : public BaseInstr< 0, true >
    {
        public:
            template< typename V >
            Constant( V&& val ) :
                BaseInstr( val.locationId() ),
                m_value( forward< V >( val ) )
            {}

            const auto& value() const { return m_value; }

            bool canBeExecuted() const { return true; }
            bool canBeEagerlyEvaluated() const { return true; }
            bool haveSideEffects() const { return false; }

            bool operator<( const Constant& rhs ) const
            {
                return m_value < rhs.m_value;
            }

            friend ostream& operator<<( ostream& out, const Constant& ins )
            {
                return out << "CONSTANT(" << ins.m_value << ')';
            }

        private:
            eir::Value m_value;
    };
}

#endif

#ifndef GOOSE_CIR_CREATETEMPORARY_H
#define GOOSE_CIR_CREATETEMPORARY_H

namespace goose::cir
{
    class CreateTemporary : public BaseInstr< 1, false >
    {
        public:

            CreateTemporary( uint32_t index, LocationId loc ) :
                BaseInstr( loc ),
                m_index( index )

            {}

            const auto& index() const { return m_index; }


            bool canBeExecuted() const { return true; }




            bool canBeEagerlyEvaluated() const { return true; }

            bool haveSideEffects() const { return true; }


            bool operator<( const CreateTemporary& rhs ) const
            {

                return m_index < rhs.m_index;

            }

            friend ostream& operator<<( ostream& out, const CreateTemporary& ins )
            {
                return out << "CREATETEMP(" << ins.m_index << ')';
            }

        private:
            uint32_t m_index = 0;

    };
}

#endif

#include "cir.h"

using namespace goose::cir;

void Decorator::appendTo( BasicBlock& bb ) &&
{


    bb.append( move( m_prologue ) );


    bb.append( move( m_operation ) );


    bb.append( move( m_epilogue) );

}

            {
                m_epilogue.emplace_back( forward< I >( instr ) );
            }

            void appendTo( BasicBlock& bb ) &&;

        private:
            InstrSeq m_prologue;
            InstrSeq m_operation;
            InstrSeq m_epilogue;
    };
}

#endif

#ifndef GOOSE_CIR_GETTEMPORARY_H
#define GOOSE_CIR_GETTEMPORARY_H

namespace goose::cir
{
    class GetTemporary : public BaseInstr< 0, true >
    {
        public:
            template< typename T >
            GetTemporary( T&& type, uint32_t index, LocationId loc ) :
                BaseInstr( loc ),
                m_type( forward< T >( type ) ),
                m_index( index )
            {}

            const auto& type() const { return m_type; }
            const auto& index() const { return m_index; }

            bool canBeExecuted() const { return true; }
            bool canBeEagerlyEvaluated() const { return true; }
            bool haveSideEffects() const { return false; }

            bool operator<( const GetTemporary& rhs ) const
            {
                if( m_index != rhs.m_index )
                    return m_index < rhs.m_index;
                return m_type < rhs.m_type;
            }

#ifndef GOOSE_CIR_GHOSTCALL_H
#define GOOSE_CIR_GHOSTCALL_H

namespace goose::cir
{
    class GhostCall : public BaseInstr< 1, true >   // Can pop more depending on arg count
    {
        public:

            GhostCall( uint32_t numArgs, LocationId loc ) :
                BaseInstr( loc ),
                m_numArgs( numArgs )
            {}


            const auto& numArgs() const { return m_numArgs; }

            bool canBeExecuted() const { return false; }
            bool canBeEagerlyEvaluated() const { return false; }
            bool haveSideEffects() const { return true; }

            bool operator<( const GhostCall& rhs ) const
            {


                return m_numArgs < rhs.m_numArgs;
            }

            friend ostream& operator<<( ostream& out, const GhostCall& ins )
            {
                return out << "GHOSTCALL";
            }

        private:
            uint32_t m_numArgs = 0;

    };
}

#endif

#include "cir/cir.h"

namespace std
{
    size_t hash< goose::cir::InstrSeq >::operator()( const goose::cir::InstrSeq& is ) const
    {
        auto g = goose::util::ContainerHashGenerator( is );
        return llvm::hash_combine_range( g.begin(), g.end() );
    }

    size_t hash< goose::cir::Instruction >::operator()( const goose::cir::Instruction& x ) const
    {
        return goose::util::ComputeHash( x.content() );
    }

    size_t hash< goose::cir::Call >::operator()( const goose::cir::Call& x ) const
    {
        return goose::util::ComputeHash( x.numArgs() );
    }

    size_t hash< goose::cir::Constant >::operator()( const goose::cir::Constant& x ) const
    {
        return goose::util::ComputeHash( x.value() );
    }

    size_t hash< goose::cir::VarAddr >::operator()( const goose::cir::VarAddr& x ) const
    {
        return llvm::hash_combine( goose::util::ComputeHash( x.varIndex() ), goose::util::ComputeHash( x.type() ) );
    }

    size_t hash< goose::cir::TempAddr >::operator()( const goose::cir::TempAddr& x ) const
    {
        return goose::util::ComputeHash( x.tempIndex() );
    }

    size_t hash< goose::cir::Select >::operator()( const goose::cir::Select& x ) const
    {
        return goose::util::ComputeHash( x.memberIndex() );
    }

    size_t hash< goose::cir::CreateTemporary >::operator()( const goose::cir::CreateTemporary& x ) const
    {
        return goose::util::ComputeHash( x.index() );
    }

    size_t hash< goose::cir::GetTemporary >::operator()( const goose::cir::GetTemporary& x ) const
    {
        return llvm::hash_combine( goose::util::ComputeHash( x.type() ), goose::util::ComputeHash( x.index() ) );
    }

    size_t hash< goose::cir::AllocVar >::operator()( const goose::cir::AllocVar& x ) const
    {
        return llvm::hash_combine( goose::util::ComputeHash( x.type() ), goose::util::ComputeHash( x.index() ) );
    }

    size_t hash< goose::cir::Load >::operator()( const goose::cir::Load& x ) const
    {
        return goose::util::ComputeHash( x.type() );
    }

    size_t hash< goose::cir::Store >::operator()( const goose::cir::Store& x ) const
    {
        return goose::util::ComputeHash( x.type() );
    }

    size_t hash< goose::cir::Phi >::operator()( const goose::cir::Phi& x ) const
    {
        // Note: we don't bother hashing the incomings here, and we don't really care because we only really need hashing for the
        // predicates and phi doesn't make sense there
        return llvm::hash_combine( goose::util::ComputeHash( x.type() ), goose::util::ComputeHash( x.numIncomings() ), goose::util::ComputeHash( x.destIndex() ) );
    }

    size_t hash< goose::cir::Not >::operator()( const goose::cir::Not& x ) const
    {
        return 0;
    }

    size_t hash< goose::cir::And >::operator()( const goose::cir::And& x ) const
    {
        return 0;
    }

    size_t hash< goose::cir::Or >::operator()( const goose::cir::Or& x ) const
    {
        return 0;
    }

    size_t hash< goose::cir::Xor >::operator()( const goose::cir::Xor& x ) const
    {
        return 0;
    }

    size_t hash< goose::cir::Implies >::operator()( const goose::cir::Implies& x ) const
    {
        return 0;
    }

    size_t hash< goose::cir::Shl >::operator()( const goose::cir::Shl& x ) const
    {
        return 0;
    }

    size_t hash< goose::cir::LShr >::operator()( const goose::cir::LShr& x ) const
    {
        return 0;
    }

    size_t hash< goose::cir::AShr >::operator()( const goose::cir::AShr& x ) const
    {
        return 0;
    }

    size_t hash< goose::cir::Add >::operator()( const goose::cir::Add& x ) const
    {
        return 0;
    }

    size_t hash< goose::cir::Sub >::operator()( const goose::cir::Sub& x ) const
    {
        return 0;
    }

    size_t hash< goose::cir::Mul >::operator()( const goose::cir::Mul& x ) const
    {
        return 0;
    }

    size_t hash< goose::cir::UDiv >::operator()( const goose::cir::UDiv& x ) const
    {
        return 0;
    }

    size_t hash< goose::cir::SDiv >::operator()( const goose::cir::SDiv& x ) const
    {
        return 0;
    }

    size_t hash< goose::cir::URem >::operator()( const goose::cir::URem& x ) const
    {
        return 0;
    }

    size_t hash< goose::cir::SRem >::operator()( const goose::cir::SRem& x ) const
    {
        return 0;
    }

    size_t hash< goose::cir::Eq >::operator()( const goose::cir::Eq& x ) const
    {
        return 0;
    }

    size_t hash< goose::cir::Neq >::operator()( const goose::cir::Neq& x ) const
    {
        return 0;
    }

    size_t hash< goose::cir::UGT >::operator()( const goose::cir::UGT& x ) const
    {
        return 0;
    }

    size_t hash< goose::cir::UGE >::operator()( const goose::cir::UGE& x ) const
    {
        return 0;
    }

    size_t hash< goose::cir::ULT >::operator()( const goose::cir::ULT& x ) const
    {
        return 0;
    }

    size_t hash< goose::cir::ULE >::operator()( const goose::cir::ULE& x ) const
    {
        return 0;
    }

    size_t hash< goose::cir::SGT >::operator()( const goose::cir::SGT& x ) const
    {
        return 0;
    }

    size_t hash< goose::cir::SGE >::operator()( const goose::cir::SGE& x ) const
    {
        return 0;
    }

    size_t hash< goose::cir::SLT >::operator()( const goose::cir::SLT& x ) const
    {
        return 0;
    }

    size_t hash< goose::cir::SLE >::operator()( const goose::cir::SLE& x ) const
    {
        return 0;
    }

    size_t hash< goose::cir::Assert >::operator()( const goose::cir::Assert& x ) const
    {
        return 0;
    }

    size_t hash< goose::cir::Placeholder >::operator()( const goose::cir::Placeholder& x ) const
    {
        return llvm::hash_combine( goose::util::ComputeHash( x.type() ), goose::util::ComputeHash( x.name() ) );
    }

    size_t hash< goose::cir::PHOverrideSet >::operator()( const goose::cir::PHOverrideSet& x ) const
    {
        return goose::util::ComputeHash( x.name() );
    }

    size_t hash< goose::cir::PHOverrideClear >::operator()( const goose::cir::PHOverrideClear& x ) const
    {
        return goose::util::ComputeHash( x.name() );
    }

    size_t hash< goose::cir::GhostCall >::operator()( const goose::cir::GhostCall& x ) const
    {
        return goose::util::ComputeHash( x.numArgs() );
    }
}

#ifndef GOOSE_CIR_HASH_H
#define GOOSE_CIR_HASH_H

namespace std
{
    template<> struct hash< goose::cir::InstrSeq >
    {
        size_t operator()( const goose::cir::InstrSeq& is ) const;
    };

    template<> struct hash< goose::cir::Instruction >
    {
        size_t operator()( const goose::cir::Instruction& x ) const;
    };

    template<> struct hash< goose::cir::Call >
    {
        size_t operator()( const goose::cir::Call& x ) const;
    };

    template<> struct hash< goose::cir::Constant >
    {
        size_t operator()( const goose::cir::Constant& x ) const;
    };

    template<> struct hash< goose::cir::VarAddr >
    {
        size_t operator()( const goose::cir::VarAddr& x ) const;
    };

    template<> struct hash< goose::cir::TempAddr >

    };

    template<> struct hash< goose::cir::Placeholder >
    {
        size_t operator()( const goose::cir::Placeholder& x ) const;
    };

    template<> struct hash< goose::cir::PHOverrideSet >
    {
        size_t operator()( const goose::cir::PHOverrideSet& x ) const;
    };

    template<> struct hash< goose::cir::PHOverrideClear >
    {
        size_t operator()( const goose::cir::PHOverrideClear& x ) const;
    };

    template<> struct hash< goose::cir::GhostCall >
    {
        size_t operator()( const goose::cir::GhostCall& x ) const;
    };
}

#endif

#include "cir/cir.h"

namespace goose::cir
{
    void AppendInstrSeq( InstrSeq& is, InstrSeq&& isToAppend )
    {
        is.splice( is.end(), isToAppend );

        // TODO update canBeExecuted, store it in InstrSeq?
    }

    void AppendInstrSeq( InstrSeq& is, const InstrSeq& isToAppend )
    {
        for( auto&& instr : isToAppend )
            AppendToInstrSeq( is, instr );
    }

    void AppendValue( InstrSeq& is, Value&& v )
    {
        if( v.cir() )
            AppendToInstrSeq( is, move( *v.cir() ) );
        else
            is.emplace_back( Constant( move( v ) ) );
    }

    void AppendValue( InstrSeq& is, const Value& v )
    {
        if( v.cir() )
            AppendToInstrSeq( is, *v.cir() );
        else
            is.emplace_back( Constant( v ) );
    }

    bool IsValueConstantOrExecutable( const eir::Value& val )
    {
        if( val.isConstant() )
            return true;

        for( const auto& instr : *val.cir() )
        {
            if( !instr.canBeExecuted() )
                return false;
        }

        return true;
    }

    bool CanValueBeEagerlyEvaluated( const eir::Value& val )
    {
        if( val.isConstant() )
            return true;

        for( const auto& instr : *val.cir() )
        {
            if( !instr.canBeEagerlyEvaluated() )
                return false;
        }

        return true;
    }

    bool DoesInstrSeqHaveSideEffects( const InstrSeq& is )
    {
        for( auto&& instr : is )
        {
            if( instr.haveSideEffects() )
                return true;
        }

        return false;
    }
}

#ifndef GOOSE_CIR_HELPERS_H
#define GOOSE_CIR_HELPERS_H

namespace goose::cir
{
    class Instruction;
    using InstrSeq = list< Instruction >;

    extern bool IsValueConstantOrExecutable( const eir::Value& val );
    extern bool CanValueBeEagerlyEvaluated( const eir::Value& val );

    extern bool DoesInstrSeqHaveSideEffects( const InstrSeq& is );

    extern void AppendInstrSeq( InstrSeq& is, InstrSeq&& isToAppend );
    extern void AppendInstrSeq( InstrSeq& is, const InstrSeq& isToAppend );

    extern void AppendValue( InstrSeq& is, Value&& v );
    extern void AppendValue( InstrSeq& is, const Value& v );

    template< typename I >
    void AppendToInstrSeq( InstrSeq& is, I&& instr )
    {
        using II = remove_cvref_t< I >;

        if constexpr( is_same_v< II, InstrSeq > )
        {
            AppendInstrSeq( is, forward< I >( instr ) );
        }
        else if constexpr( is_same_v< II, Value > )
        {
            AppendValue( is, forward< I >( instr ) );
        }
        else
        {
            is.emplace_back( Instruction( forward< I >( instr ) ) );
        }
    }

    static inline void AppendToInstrSeq( InstrSeq& is, const ptr< InstrSeq >& instr )
    {
        AppendToInstrSeq( is, *instr );
    }

    static inline void AppendToInstrSeq( InstrSeq& is, ptr< InstrSeq >&& instr )
    {
        AppendToInstrSeq( is, move( *instr ) );
    }

    template< typename HI, typename... TI >
    void AppendToInstrSeq( InstrSeq& is, HI&& headInstr, TI&&... tailInstrs )
    {
        AppendToInstrSeq( is, forward< HI >( headInstr ) );
        AppendToInstrSeq( is, forward< TI >( tailInstrs )... );
    }

    template< typename T, typename... I >
    auto BuildComputedValue( T&& type, I&&... instrs )
    {
        auto is = make_shared< InstrSeq >();
        AppendToInstrSeq( *is, forward< I >( instrs )... );

        return eir::Value( forward< T >( type ), move( is ) );
    }

    template< size_t popCount, bool pushesResult >
    class BaseInstr
    {
        public:
            BaseInstr( LocationId loc ) :
                m_loc( loc )
            {}

            void setLocationId( LocationId loc ) { m_loc = loc; }

            auto locationId() const { return m_loc; }

            static constexpr size_t PopCount = popCount;
            static constexpr bool PushesResult = pushesResult;

        private:
            LocationId m_loc;
    };

    template< typename T >
    class TempStorage
    {
        public:
            TempStorage( size_t size ) :
                m_storage( size )
            {}

            template< typename TT >
            T& set( uint32_t index, TT&& x )
            {
                if( index >= m_storage.size() )
                    m_storage.resize( index + 1 );
                m_storage[index] = forward< TT >( x );
                return m_storage[index];
            }

            const T* get( uint32_t index ) const
            {
                if( index < m_storage.size() )
                    return &m_storage[index];
                return nullptr;


            }

            T* get( uint32_t index )
            {
                if( index < m_storage.size() )
                    return &m_storage[index];
                return nullptr;


            }

        private:
            llvm::SmallVector< T, 16 > m_storage;
    };
}

#endif

#include "cir/cir.h"

namespace goose::cir
{
    bool Instruction::canBeExecuted() const
    {
        return visit( []< typename ET >( const ET& e )
        {
            if constexpr( is_same_v< ET, monostate > )
                return false;


            else
                return e.canBeExecuted();
        }, m_content );
    }

    bool Instruction::canBeEagerlyEvaluated() const
    {
        return visit( []< typename ET >( const ET& e )
        {
            if constexpr( is_same_v< ET, monostate > )
                return false;


            else
                return e.canBeEagerlyEvaluated();
        }, m_content );
    }

    bool Instruction::haveSideEffects() const
    {
        return visit( []< typename ET >( const ET& e )
        {
            if constexpr( is_same_v< ET, monostate > )
                return false;
            else
                return e.haveSideEffects();
        }, m_content );
    }

    ostream& operator<<( ostream& out, const Instruction& inst )
    {
        return visit( [&]< typename ET >( const ET& e ) -> ostream&
        {
            if constexpr( is_same_v< ET, monostate > )
                return out << "NIL";


            else
                return out << e;
        }, inst.m_content );
    }

    ostream& operator<<( ostream& out, const Select& ins )
    {
        out << "SELECT(" << ins.m_memberIndex;




        return out << ')';
    }

    ostream& operator<<( ostream& out, const Load& ins )
    {
        out << "LOAD(";




        return out << ins.m_type << ')';
    }

    ostream& operator<<( ostream& out, const Store& ins )
    {





        return out << "STORE";
    }

    ostream& operator<<( ostream& out, const PHOverrideSet& ins )
    {
        return out << "PHOVERRIDESET(" << ins.m_name << ')';
    }

    ostream& operator<<( ostream& out, const PHOverrideClear& ins )
    {
        return out << "PHOVERRIDECLEAR(" << ins.m_name << ')';
    }

    bool Select::operator<( const Select& rhs ) const
    {

        return m_memberIndex < rhs.m_memberIndex;

    }

    bool Load::operator<( const Load& rhs ) const
    {

        return m_type < rhs.m_type;

    }

    bool Store::operator<( const Store& rhs ) const
    {

        return m_type < rhs.m_type;
    }

    bool PHOverrideSet::operator<( const PHOverrideSet& rhs ) const
    {
        return m_name < rhs.m_name;
    }

    bool PHOverrideClear::operator<( const PHOverrideClear& rhs ) const
    {

        return m_name < rhs.m_name;



    }
}

            Instruction( TempAddr&& tad ) :
                m_content( move( tad ) )
            {}

            Instruction( Select&& sel ) :
                m_content( move( sel ) )
            {}

            Instruction( Constant&& cst ) :
                m_content( move( cst ) )
            {}

            Instruction( CreateTemporary&& ct ) :
                m_content( move( ct ) )
            {}

            Instruction( GetTemporary&& gt ) :
                m_content( move( gt ) )

                m_content( move( x ) )
            {}

            Instruction( Placeholder&& x ) :
                m_content( move( x ) )
            {}

            Instruction( PHOverrideSet&& x ) :
                m_content( move( x ) )
            {}

            Instruction( PHOverrideClear&& x ) :
                m_content( move( x ) )
            {}

            Instruction( GhostCall&& x ) :
                m_content( move( x ) )
            {}

            using Content = variant
            <
                monostate,

                Call,

                VarAddr,
                TempAddr,
                Select,

                Constant,
                CreateTemporary,
                GetTemporary,
                AllocVar,
                Load,
                Store,
                Phi,

                SGT,
                SGE,
                SLT,
                SLE,

                Assert,
                GhostCall,
                PHOverrideSet,
                PHOverrideClear,
                Placeholder




            >;

            const auto& content() const { return m_content; }

            bool canBeExecuted() const;
            bool canBeEagerlyEvaluated() const;
            bool haveSideEffects() const;

            friend ostream& operator<<( ostream& out, const Instruction& inst );

            bool operator<( const Instruction& rhs ) const
            {
                return m_content < rhs.m_content;
            }

#ifndef GOOSE_CIR_LOAD_H
#define GOOSE_CIR_LOAD_H

namespace goose::cir
{
    class Load : public BaseInstr< 1, true >
    {
        public:
            template< typename T >
            Load( T&& type, LocationId loc ) :
                BaseInstr( loc ),
                m_type( forward< T >( type ) )
            {}


            const auto& type() const { return m_type; }

            bool canBeExecuted() const { return true; }
            bool canBeEagerlyEvaluated() const { return true; }
            bool haveSideEffects() const { return false; }

            bool operator<( const Load& rhs ) const;
            friend ostream& operator<<( ostream& out, const Load& ins );

        private:

            eir::Term m_type;
    };
}

#endif

#ifndef GOOSE_CIR_LOGIC_H
#define GOOSE_CIR_LOGIC_H

namespace goose::cir
{
    class And : public BinaryOp
    {
        public:
            And( LocationId loc ) :
                BinaryOp( loc )
            {}

            friend ostream& operator<<( ostream& out, const And& ins )
            {
                return out << "AND";
            }
    };

    class Or : public BinaryOp
    {
        public:
            Or( LocationId loc ) :
                BinaryOp( loc )
            {}

            friend ostream& operator<<( ostream& out, const Or& ins )
            {
                return out << "OR";
            }
    };

    class Xor : public BinaryOp
    {
        public:
            Xor( LocationId loc ) :
                BinaryOp( loc )
            {}

            friend ostream& operator<<( ostream& out, const Xor& ins )
            {
                return out << "XOR";
            }
    };

    // Logical implication (to be used only for verification expression)
    class Implies : public BinaryOp
    {
        public:
            Implies( LocationId loc ) :
                BinaryOp( loc )
            {}

            friend ostream& operator<<( ostream& out, const Implies& ins )
            {
                return out << "IMPLIES";
            }
    };
}

#endif

#include "cir.h"

namespace goose::cir
{
    // EvalStores is a tiny CIR InstrSeq evaluator that only considers store instructions
    // to addresses whose path can be calculated entirely at compilation time

    class AddrEvalStack
    {
        public:
            template< typename T >
            void push( T&& x )
            {
                m_stack.push( forward< T >( x ) );
            }

            bool pop()
            {
                if( m_stack.empty() )
                    return false;

                m_stack.pop();
                return true;
            }

            template< typename T >
            optional< T > pop()
            {
                if( m_stack.empty() )
                    return nullopt;

                if( !holds_alternative< T >( m_stack.top() ) )
                    return nullopt;

                optional< T > result = move( get< T >( m_stack.top() ) );
                m_stack.pop();
                return result;
            }

            bool empty() const { return m_stack.empty(); }

        private:
            stack< variant< monostate, StorageLocation, Value > > m_stack;
    };

    template< typename I, typename F >
    bool EvalStores( AddrEvalStack& stack, const I& instr, F&& storeHandler )
    {
        // For all the instructions we don't care about here,
        // push/pop mock values on the stack to keep the stack layout
        // as intended by the instruction sequence.
        for( size_t i = 0; i < I::PopCount; ++i )
        {
            if( !stack.pop() )
                return false;
        }

        if( I::PushesResult )
            stack.push( monostate() );

        return true;
    }

    template< typename F >
    bool EvalStores( AddrEvalStack& stack, const monostate&, F&& storeHandler )
    {
        return true;
    }

    template< typename F >
    bool EvalStores( AddrEvalStack& stack, const Constant& instr, F&& storeHandler )
    {
        stack.push( instr.value() );
        return true;
    }

    template< typename F >
    bool EvalStores( AddrEvalStack& stack, const Call& instr, F&& storeHandler )
    {
        if( !stack.pop() )
            return false;

        for( size_t i = 0; i < instr.numArgs(); ++i )
        {
            if( !stack.pop() )
                return false;
        }

        stack.push( monostate() );
        return true;
    }

    template< typename F >
    bool EvalStores( AddrEvalStack& stack, const GhostCall& instr, F&& storeHandler )
    {
        auto gfunc = stack.pop< Value >();
        if( !gfunc )
            return false;

        auto argCount = instr.numArgs();
        GhostFuncApplication gfa( move( *gfunc ), instr.locationId() );

        auto& args = gfa.args();
        args.resize( argCount );
        for( size_t i = 0; i < argCount; ++i )
        {
            variant< Value, Address > arg;
            auto a = stack.pop< Value >();
            if( a )
                arg = move( *a );
            else
            {
                auto a = stack.pop< StorageLocation >();
                if( !a || holds_alternative< Address >( *a ) )
                    return false;

                arg = move( get< Address >( *a ) );
            }

            args[argCount - i - 1] = move( arg );
        }

        stack.push( StorageLocation { move( gfa ) } );
        return true;
    }

    template< typename F >
    bool EvalStores( AddrEvalStack& stack, const VarAddr& instr, F&& storeHandler )
    {
        stack.push( Address( Address::Origin::Stack, instr.varIndex(), instr.locationId() ) );
        return true;
    }

    template< typename F >
    bool EvalStores( AddrEvalStack& stack, const TempAddr& instr, F&& storeHandler )
    {
        if( !stack.pop() )
            return false;

        stack.push( Address( Address::Origin::Stack, instr.tempIndex(), instr.locationId() ) );
        return true;
    }

    template< typename F >
    bool EvalStores( AddrEvalStack& stack, const Select& instr, F&& storeHandler )
    {
        if( stack.empty() )
            return false;

        auto baseAddr = stack.pop< StorageLocation >();
        if( !baseAddr )
        {
            // Not an error, just means the base address comes from an indrection,
            // or a function call and we don't handle this case here.
            //
            // TODO:
            // Later we might either outright emit an error right here if this occurs
            // inside of a loop because it means we can't verify it and risk a false
            // positive. Or we could try and go the extra mile to represent
            // the indirection in a way that can be verified.
            return true;
        }

        if( !holds_alternative< Address >( *baseAddr ) )
            return false;

        stack.push( StorageLocation{
            Address::Select( move( get< Address >( *baseAddr ) ),
            instr.memberIndex(), instr.locationId() ) } );
        return true;
    }

    template< typename F >
    bool EvalStores( AddrEvalStack& stack, const Store& instr, F&& storeHandler )
    {
        if( !stack.pop() )
            return false;

        if( stack.empty() )
            return false;

        auto sloc = stack.pop< StorageLocation >();
        if( !sloc )
        {
            // Not an error, see comment in the function above
            return true;
        }

        storeHandler( instr.type(), *sloc );
        return true;
    }

    template< typename F >
    bool EvalStores( AddrEvalStack& stack, const Instruction& instr, F&& storeHandler )
    {
        return visit( [&]( auto&& i )
        {
            return EvalStores( stack, i, forward< F >( storeHandler ) );
        }, instr.content() );
    }

    template< typename F >
    bool EvalStores( const BasicBlock& bb, F&& storeHandler )
    {
        AddrEvalStack stack;

        for( auto&& instr : bb.instructions() )
        {
            if( !EvalStores( stack, instr, storeHandler ) )
                return false;
        }

        return true;
    }

    void MarkSLocChangedByLoop( const ptr< CFG >& cfg, uint32_t loopId, const eir::Term& type, const StorageLocation& sloc )
    {
        cfg->setStorageLocationModifiedByLoop( loopId, type, sloc );

        const auto& pHeader = cfg->getBB( loopId );

        if( pHeader->loopId() )
            MarkSLocChangedByLoop( cfg, pHeader->loopId(), type, sloc );
    }

    void ComputeLoopModifiedAddrs( const ptr< CFG >& cfg )
    {
        cfg->forEachBB( [&]( auto&& bb )
        {
            if( !bb->loopId() )
                return;






            EvalStores( *bb, [&]( auto&& type, auto&& sloc )



            {
                MarkSLocChangedByLoop( cfg, bb->loopId(), type, sloc );
            } );
        } );
    }
}

goose_cir = library( 'goose-cir',
    'cfg.cpp',
    'dominators.cpp',
    'loops.cpp',
    'loopaddrs.cpp',
    'instruction.cpp',

    'terminator.cpp',

    'func.cpp',
    'helpers.cpp',
    'verifinstrfilter.cpp',
    'hash.cpp',
    'decorator.cpp',
    'cfgviz.cpp',

    include_directories: bsinc,
    dependencies: [tracy_dep]
)

#ifndef GOOSE_CIR_NOT_H
#define GOOSE_CIR_NOT_H

namespace goose::cir
{
    class Not : public BaseInstr< 1, true >
    {
        public:

            Not( LocationId loc ) :

                BaseInstr( loc )
            {}



            bool canBeExecuted() const { return true; }




            bool canBeEagerlyEvaluated() const { return true; }

            bool haveSideEffects() const { return false; }


            bool operator<( const Not& rhs ) const
            {
                return false;
            }

            friend ostream& operator<<( ostream& out, const Not& ins )
            {
                return out << "NOT";
            }



    };
}

#endif

#ifndef GOOSE_CIR_PHI_H
#define GOOSE_CIR_PHI_H

namespace goose::cir
{
    class BasicBlock;

    class Phi : public BaseInstr< 0, false >
    {
        public:
            template< typename T >
            Phi( T&& type, uint32_t numIncomings, uint32_t destIndex, LocationId loc ) :
                BaseInstr( loc ),
                m_type( forward< T >( type ) ),
                m_destIndex( destIndex )
            {
                m_incomings.reserve( numIncomings );
            }

            const auto& type() const { return m_type; }

                    if( !func( bb.lock(), val ) )
                        return;
                }
            }

            bool canBeExecuted() const { return true; }
            bool canBeEagerlyEvaluated() const { return true; }
            bool haveSideEffects() const { return true; }

            bool operator<( const Phi& rhs ) const
            {
                if( m_type != rhs.m_type )
                    return m_type < rhs.m_type;

                return m_destIndex < rhs.m_destIndex;

#ifndef GOOSE_CIR_PHOVERRIDE_H
#define GOOSE_CIR_PHOVERRIDE_H

namespace goose::cir
{
    // A pseudo instruction that defines an override value for a placeholder

    class PHOverrideSet : public BaseInstr< 1, false >
    {
        public:
            template< typename S >
            PHOverrideSet( S&& name, LocationId loc ) :
                BaseInstr( loc ),
                m_name( forward< S >( name ) )


            {}

            const auto& name() const { return m_name; }

            // This can't be executed, it's only meant to appear
            // in expressions handled by the verifier.
            bool canBeExecuted() const { return false; }
            bool canBeEagerlyEvaluated() const { return false; }
            bool haveSideEffects() const { return false; }

            bool operator<( const PHOverrideSet& rhs ) const;
            friend ostream& operator<<( ostream& out, const PHOverrideSet& ins );

        private:
            StringId    m_name;
    };

    // A pseudo instruction that clears an override value for a placeholder
    class PHOverrideClear : public BaseInstr< 0, 0 >
    {
        public:
            template< typename S >
            PHOverrideClear( S&& name, LocationId loc ) :
                BaseInstr( loc ),
                m_name( forward< S >( name ) )
            {}

            const auto& name() const { return m_name; }

            // This can't be executed, it's only meant to appear
            // in expressions handled by the verifier.
            bool canBeExecuted() const { return false; }
            bool canBeEagerlyEvaluated() const { return false; }
            bool haveSideEffects() const { return false; }

            bool operator<( const PHOverrideClear& rhs ) const;
            friend ostream& operator<<( ostream& out, const PHOverrideClear& ins );

        private:
            StringId    m_name;


    };
}

#endif

#ifndef GOOSE_CIR_PLACEHOLDER_H
#define GOOSE_CIR_PLACEHOLDER_H

namespace goose::cir
{
    // A placeholder value with a name, to be replaced with something else.
    // Intended to represent the @ return value placeholder in functions'
    // post conditions.
    class Placeholder : public BaseInstr< 0, true >
    {
        public:
            template< typename T, typename S >
            Placeholder( T&& type, S&& name, LocationId loc ) :
                BaseInstr( loc ),
                m_type( forward< T >( type ) ),
                m_name( forward< S >( name ) )
            {}

            const auto& type() const { return m_type; }
            const auto& name() const { return m_name; }

            // This can't be executed, it's only meant to appear
            // in expressions handled by the verifier.
            bool canBeExecuted() const { return false; }
            bool canBeEagerlyEvaluated() const { return false; }
            bool haveSideEffects() const { return false; }

            bool operator<( const Placeholder& rhs ) const
            {
                if( m_name != rhs.m_name )
                    return m_name < rhs.m_name;
                return m_type < rhs.m_type;
            }

#ifndef GOOSE_CIR_RET_H
#define GOOSE_CIR_RET_H

namespace goose::cir
{
    class RetVoid
    {
        public:
            RetVoid( LocationId loc ) :
                m_loc( loc )



            {}

            bool canBeExecuted() const { return true; }
            bool canBeEagerlyEvaluated() const { return true; }

            void addCFGEdges( const ptr< CFG >& cfg, uint32_t srcBBIndex )  {}

            const auto& locationId() const { return m_loc; }

        private:
            LocationId m_loc;
    };


    class Ret
    {

        public:
            Ret( LocationId loc ) :
                m_loc( loc )
            {}

            bool canBeExecuted() const { return true; }
            bool canBeEagerlyEvaluated() const { return true; }

            void addCFGEdges( const ptr< CFG >& cfg, uint32_t srcBBIndex )  {}

            const auto& locationId() const { return m_loc; }

        private:
            LocationId m_loc;
    };
}

#endif

#ifndef GOOSE_CIR_SELECT_H
#define GOOSE_CIR_SELECT_H

namespace goose::cir
{
    class Select : public BaseInstr< 1, true >
    {
        public:

            Select( uint32_t memberIndex, LocationId loc ) :
                BaseInstr( loc ),
                m_memberIndex( memberIndex )
            {}






            uint32_t memberIndex() const
            {
                return m_memberIndex;
            }

            bool canBeExecuted() const { return true; }
            bool canBeEagerlyEvaluated() const { return false; }
            bool haveSideEffects() const { return false; }

            bool operator<( const Select& rhs ) const;
            friend ostream& operator<<( ostream& out, const Select& ins );

        private:

            uint32_t m_memberIndex = 0;
    };
}

#endif

#ifndef GOOSE_CIR_STORAGELOCATION_H
#define GOOSE_CIR_STORAGELOCATION_H

namespace goose::cir
{
    using SelectPath = llvm::SmallVector< uint32_t, 4 >;

    class Address
    {
        public:
            enum class Origin
            {
                Stack,
                Heap
            };

            Address() {}

            Address( Address&& ) = default;
            Address( const Address& ) = default;

            Address& operator=( Address&& ) = default;
            Address& operator=( const Address& ) = default;

            Address( Origin o, uint32_t originIndex, LocationId loc ) :
                m_origin( o ),
                m_loc( loc )
            {
                m_path.emplace_back( originIndex );
            }

            auto origin() const { return m_origin; }
            const auto& path() const { return m_path; }
            auto locationId() const { return m_loc; }

            static Address Select( Address&& baseAddr, uint32_t index, LocationId loc )
            {
                baseAddr.m_path.emplace_back( index );
                baseAddr.m_loc = loc;
                return baseAddr;
            }

            bool operator<( const Address& rhs ) const
            {
                if( m_origin != rhs.m_origin )
                    return  m_origin < rhs.m_origin;

                return m_path < rhs.m_path;
            }

        private:
            SelectPath m_path;
            Origin m_origin = Origin::Stack;
            LocationId m_loc;
    };

    class GhostFuncApplication
    {
        public:
            GhostFuncApplication( cir::Value&& func, LocationId loc ) :
                m_func( move( func ) ),
                m_loc( loc )
            {}

            const auto& func() const { return m_func; }
            const auto& args() const { return m_args; }
            auto& args() { return m_args; }

            auto locationId() const { return m_loc; }

            bool operator<( const GhostFuncApplication& rhs ) const
            {
                if( m_func != rhs.m_func )
                    return  m_func < rhs.m_func;

                return m_args < rhs.m_args;
            }

        private:
            eir::Value m_func;
            llvm::SmallVector< variant< eir::Value, Address >, 4 > m_args;
            LocationId m_loc;
    };

    using StorageLocation = variant< Address, GhostFuncApplication, monostate >;
}

#endif

#ifndef GOOSE_CIR_STORE_H
#define GOOSE_CIR_STORE_H

namespace goose::cir
{
    class Store
    {
        public:
            template< typename T >
            Store( T&& type, eir::LocationId srcLocId, eir::LocationId destLocId ) :

                m_type( forward< T >( type ) ),

                m_srcLocId( srcLocId ),
                m_destLocId( destLocId )
            {}


            const auto& type() const { return m_type; }
            const auto& srcLocId() const { return m_srcLocId; }
            const auto& destLocId() const { return m_destLocId; }

            bool canBeExecuted() const { return true; }

            bool canBeEagerlyEvaluated() const { return true; }
            bool haveSideEffects() const { return true; }

            static constexpr size_t PopCount = 2;
            static constexpr bool PushesResult = false;

            bool operator<( const Store& rhs ) const;
            friend ostream& operator<<( ostream& out, const Store& ins );

        private:

            eir::Term m_type;
            eir::LocationId m_srcLocId = 0;
            eir::LocationId m_destLocId = 0;
    };
}

#endif

#ifndef GOOSE_CIR_TEMPADDR_H
#define GOOSE_CIR_TEMPADDR_H

namespace goose::cir
{
    class TempAddr : public BaseInstr< 1, true >
    {
        public:

            TempAddr( uint32_t i, LocationId loc ) :

                BaseInstr( loc ),
                m_tempIndex( i )
            {}

            uint32_t tempIndex() const
            {
                return m_tempIndex;
            }






            bool canBeExecuted() const { return true; }
            bool canBeEagerlyEvaluated() const { return false; }
            bool haveSideEffects() const { return false; }

            bool operator<( const TempAddr& rhs ) const
            {

                return m_tempIndex < rhs.m_tempIndex;

            }

            friend ostream& operator<<( ostream& out, const TempAddr& ins )
            {
                return out << "TEMPADDR(" << ins.m_tempIndex << ')';
            }

        private:

            uint32_t m_tempIndex = 0;
    };
}

#endif

#ifndef GOOSE_CIR_TERMINATOR_H
#define GOOSE_CIR_TERMINATOR_H

namespace goose::cir
{
    class BasicBlock;

    class Terminator
    {
        public:
            Terminator( RetVoid&& r ) :
                m_content( move( r ) )
            {}

            Terminator( Ret&& r ) :
                m_content( move( r ) )
            {}

            Terminator( Branch&& b ) :
                m_content( move( b ) )

            Terminator( Continue&& c ) :
                m_content( move( c ) )
            {}

            using Content = variant
            <
                RetVoid,
                Ret,
                Branch,
                CondBranch,
                GhostBranch,
                Break,
                Continue
            >;

        auto bb2 = cfg->createBB();
        auto bb3 = cfg->createBB();
        auto bb4 = cfg->createBB();
        auto bb5 = cfg->createBB();
        auto bb6 = cfg->createBB();

        bb1->setTerminator( Branch( bb2 ) );
        bb2->setTerminator( CondBranch( bb3, bb4 ) );
        bb3->setTerminator( Branch( bb5 ) );
        bb4->setTerminator( Branch( bb5 ) );
        bb5->setTerminator( CondBranch( bb2, bb6 ) );

        ComputeDominators( cfg );

        THEN( "We get the expected result" )
        {
            const auto& idoms = cfg->idoms();

        auto bb8 = cfg->createBB();
        auto bb9 = cfg->createBB();
        auto bba = cfg->createBB();
        auto bbb = cfg->createBB();
        auto bbc = cfg->createBB();
        auto bbd = cfg->createBB();

        bb1->setTerminator( CondBranch( bb2, bb3 ) );

        bb2->setTerminator( CondBranch( bb4, bb7 ) );
        bb4->setTerminator( Branch( bb5 ) );
        bb5->setTerminator( Branch( bb6 ) );
        bb6->setTerminator( Branch( bb8 ) );
        bb7->setTerminator( Branch( bb8 ) );
        bb8->setTerminator( CondBranch( bb7, bbd ) );

        bb3->setTerminator( CondBranch( bb9, bba ) );
        bba->setTerminator( CondBranch( bbb, bbc ) );
        bb9->setTerminator( Branch( bbc ) );
        bbb->setTerminator( Branch( bbc ) );
        bbc->setTerminator( Branch( bbd ) );

        ComputeDominators( cfg );

        THEN( "We get the expected result" )

            goose_builtins,
            goose_sema,
            goose_lex,
            goose_parse,
            goose_diagnostics,
            goose_execute,
            goose_codegen,

            goose_compile
        ],
        include_directories: bsinc,
        dependencies: [catch2_dep, llvm_dep, lld_deps, tracy_dep]
    )
    test( 'cir-' + t, exe )
endforeach

#ifndef GOOSE_CIR_VARADDR_H
#define GOOSE_CIR_VARADDR_H

namespace goose::cir
{
    class VarAddr : public BaseInstr< 0, true >
    {
        public:
            template< typename T >
            VarAddr( uint32_t varIndex, T&& type, LocationId loc ) :
                BaseInstr( loc ),
                m_type( forward< T >( type ) ),
                m_varIndex( varIndex )
            {}

            const auto& type() const { return m_type; }

            uint32_t varIndex() const
            {
                return m_varIndex;
            }

            bool canBeExecuted() const { return true; }
            bool canBeEagerlyEvaluated() const { return false; }
            bool haveSideEffects() const { return false; }

            bool operator<( const VarAddr& rhs ) const
            {
                if( m_varIndex != rhs.m_varIndex )
                    return m_varIndex < rhs.m_varIndex;

                return m_type < rhs.m_type;

#include "cir/cir.h"

namespace goose::cir
{
    void VerifInstrFilter::push( int32_t instrCount )
    {
        m_stack.push( instrCount );
    }

    int32_t VerifInstrFilter::pop()
    {
        if( m_stack.empty() )
            return 0;

        auto result = m_stack.top();
        m_stack.pop();
        return result;
    }

    void VerifInstrFilter::retire()
    {
        auto count = pop();

        auto end = m_pendingInstrs.end();
        auto begin = end - abs( count );

        if( count < 0 )
        {
            m_discardCount -= count;
            for( auto it = begin; it != end; ++it )
                m_instrDiscardFlags[*it] = true;
        }

        m_pendingInstrs.erase( begin, end );
    }

    bool VerifInstrFilter::processInstr( const Call& instr )
    {
        size_t count = 1;

        auto c = pop();
        if( c <= 0 )
            return false;

        count += c;

        for( uint32_t i = 0; i < instr.numArgs(); ++i )
        {
            auto c = pop();
            if( c <= 0 )
                return false;

            count += c;
        }

        push( count );
        return true;
    }

    bool VerifInstrFilter::processInstr( const GhostCall& instr )
    {
        size_t count = 1;

        auto c = pop();
        if( c == 0 )
            return false;

        count += abs( c );

        for( uint32_t i = 0; i < instr.numArgs(); ++i )
        {
            auto c = pop();
            if( c == 0 )
                return false;

            count += abs( c );
        }

        push( -count );
        return true;
    }

    bool VerifInstrFilter::processInstr( const Store& instr )
    {
        size_t count = 1;
        bool isVerifCode = false;

        auto c = pop();
        if( c == 0 )
            return false;

        if( c < 0 )
            isVerifCode = true;

        count += abs( c );

        c = pop();
        if( c == 0 )
            return false;

        if( c < 0 )
            isVerifCode = true;

        count += abs( c );

        push( isVerifCode ? -count : count );
        retire();
        return true;
    }

    bool VerifInstrFilter::processInstr( const Assert& instr )
    {
        size_t count = 1;

        auto c = pop();
        if( c == 0 )
            return false;

        count += abs( c );
        push( -count );
        retire();
        return true;
    }

    bool VerifInstrFilter::processInstr( const Placeholder& instr )
    {
        push( -1 );
        retire();
        return true;
    }

    bool VerifInstrFilter::processInstr( const PHOverrideSet& instr )
    {
        size_t count = 1;

        auto c = pop();
        if( c == 0 )
            return false;

        count += abs( c );
        push( -count );
        retire();
        return true;
    }

    bool VerifInstrFilter::processInstr( const PHOverrideClear& instr )
    {
        push( -1 );
        retire();
        return true;
    }

    template< typename T >
    bool VerifInstrFilter::processInstr( const T& instr )
    {
        size_t count = 1;
        bool isVerifCode = false;

        for( uint32_t i = 0; i < T::PopCount; ++i )
        {
            auto c = pop();
            if( !c )
                return false;

            if( c < 0 )
                isVerifCode = true;

            count += abs( c );
        }

        if( T::PushesResult )
            push( isVerifCode ? -count : count );

        return true;
    }

    bool VerifInstrFilter::processInstr( const Instruction& instr )
    {
        m_pendingInstrs.emplace_back( m_instrCount++ );

        return visit( [&]< typename T >( const T& instr )
        {
            if constexpr( is_same_v< T, monostate > )
                return false;
            else
                return VerifInstrFilter::processInstr( instr );
        }, instr.content() );
    }
}

#ifndef GOOSE_CIR_VERIFINSTRFILTER_H
#define GOOSE_CIR_VERIFINSTRFILTER_H

namespace goose::cir
{
    struct VerifInstrFilter
    {
        public:
            VerifInstrFilter( size_t inputInstrCount ) :
                m_instrDiscardFlags( inputInstrCount )
            {
                m_pendingInstrs.reserve( inputInstrCount );
            }

            bool processInstr( const Instruction& instr );

            template< typename T >
            void filter( const InstrSeq& input, T& output )
            {
                assert( input.size() == m_instrDiscardFlags.size() );

                output.reserve( input.size() - m_discardCount );
                auto fit = m_instrDiscardFlags.begin();

                for( const auto& instr : input )
                {
                    if( !*fit )
                        output.emplace_back( instr );
                    ++fit;
                }
            }

        private:
            void push( int32_t instrCount );
            int32_t pop();

            void retire();

            bool processInstr( const Call& instr );
            bool processInstr( const GhostCall& instr );
            bool processInstr( const Store& instr );
            bool processInstr( const Assert& instr );
            bool processInstr( const Placeholder& instr );
            bool processInstr( const PHOverrideSet& instr );
            bool processInstr( const PHOverrideClear& instr );

            template< typename T >
            bool processInstr( const T& instr );

            llvm::SmallVector< size_t, 16 > m_pendingInstrs;
            vector< bool > m_instrDiscardFlags;
            stack< int32_t > m_stack;

            size_t m_instrCount = 0;
            size_t m_discardCount = 0;
    };

    template< typename T >
    bool FilterVerificationInstructions( const InstrSeq& is, T& destination )
    {
        VerifInstrFilter f( is.size() );

        for( const auto& instr : is )
        {
            if( !f.processInstr( instr ) )
                return false;
        }

        f.filter( is, destination );
        return true;
    }
}

#endif

#include "codegen.h"
#include "builtins/builtins.h"

using namespace goose;
using namespace goose::codegen;
using namespace goose::builtins;




llvm::Value* codegen::AddressToGEP( llvm::IRBuilder<>& builder, const codegen::Address& addr )



{


    if( addr.path().empty() )















        return addr.originAddr();



























    llvm::SmallVector< llvm::Value*, 8 > idxs;
    idxs.push_back( llvm::ConstantInt::get( llvm::Type::getInt32Ty( GetLLVMContext() ), 0 ) );

    for( auto it = addr.path().rbegin(); it != addr.path().rend(); ++it )
        idxs.push_back( llvm::ConstantInt::get( llvm::Type::getInt32Ty( GetLLVMContext() ), *it ) );

    return builder.CreateGEP( addr.originAddr()->getType()->getScalarType()->getPointerElementType(), addr.originAddr(), idxs );
}

bool Module::buildInstruction( State& st, const VarAddr& va )
{
    auto* ppVal = st.temporaries->get( va.varIndex() );

    assert( ppVal );
    if( !ppVal )
        return false;

    st.stack.push( Address( *ppVal ) );
    return true;
}

bool Module::buildInstruction( State& st, const TempAddr& ta )
{
    auto initVal = st.stack.pop( m_llvmBuilder );
    if( !initVal )
        return false;

    auto* ppVal = st.temporaries->get( ta.tempIndex() );

    if( !ppVal )
    {
        st.temporaries->set( ta.tempIndex(), *initVal );
        ppVal = st.temporaries->get( ta.tempIndex() );
    }

    if( llvm::isa< llvm::AllocaInst >( **ppVal ) )
    {
        st.stack.push( Address( *ppVal ) );
        return true;
    }

    auto* pAlloca = buildAlloca( st, ( *ppVal )->getType() );
    m_llvmBuilder.CreateStore( *ppVal, pAlloca );
    st.temporaries->set( ta.tempIndex(), pAlloca );

    st.stack.push( Address( pAlloca ) );
    return true;
}

bool Module::buildInstruction( State& st, const Select& s )
{
    auto baseAddr = st.stack.pop();
    if( !baseAddr )
        return false;

    if( holds_alternative< Address >( *baseAddr ) )
        st.stack.push( Address::Select( move( get< Address >( *baseAddr ) ), s.memberIndex() ) );
    else
        st.stack.push( Address::Select( Address( get< llvm::Value* >( *baseAddr ) ), s.memberIndex() ) );
    return true;
}

bool Module::buildInstruction( State& st, const cir::GhostCall& gc )
{
    // We should never encounter this during codegen, since it's a construct only
    // intended to be used in verification expressions.
    return false;
}

#ifndef GOOSE_CODEGEN_ADDRESS_H
#define GOOSE_CODEGEN_ADDRESS_H

namespace goose::codegen
{
    class Address
    {
        public:
            Address( llvm::Value* originAddr ) :
                m_originAddr( originAddr )
            {}

            auto originAddr() const { return m_originAddr; }
            const auto& path() const { return m_path; }

            static Address Select( Address&& baseAddr, uint32_t index )
            {
                baseAddr.m_path.emplace_back( index );
                return baseAddr;
            }

        private:
            SelectPath m_path;
            llvm::Value* m_originAddr = nullptr;
    };

    extern llvm::Value* AddressToGEP( llvm::IRBuilder<>& builder, const codegen::Address& addr );
}

#endif