source: src/SynTree/GcTracer.h @ d318a18

//
// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
//
// The contents of this file are covered under the licence agreement in the
// file "LICENCE" distributed with Cforall.
//
// GcTracer.h --
//
// Author           : Aaron B. Moss
// Created On       : Thu Mar 15 14:47:00 2018
// Last Modified By : Aaron B. Moss
// Last Modified On : Thu Mar 15 14:47:00 2018
// Update Count     : 1
//

#pragma once

#include <list>

#include "BaseSyntaxNode.h"
#include "Expression.h"
#include "Label.h"
#include "Type.h"

#include "Common/GC.h"
#include "Common/PassVisitor.h"
#include "ResolvExpr/TypeEnvironment.h"

/// Implements `trace` method for syntax nodes
class GcTracer final : public WithShortCircuiting, public WithVisitorRef<GcTracer> {
        const GC& gc;

public:
        GcTracer( const GC& gc ) : gc(gc) {}

        template<typename... Args>
        void traceAll(Args&... args) { ::traceAll(gc, args...); }

        // mark node and children

        void previsit( BaseSyntaxNode * node ) {
                // skip tree if already seen
                if ( node->mark == gc.mark ) {
                        visit_children = false;
                        return;
                }

                // mark node
                node->mark = gc.mark;
        }

        // add visits left out by PassVisitor

        void postvisit( Constant* con ) {
                maybeAccept( con->get_type(), *visitor );
        }

        void postvisit( AggregateDecl* decl ) {
                acceptAll( decl->attributes, *visitor );
        }

        void postvisit( DeclarationWithType* decl ) {
                maybeAccept( decl->asmName, *visitor );
        }

private:
        void visit( InferredParams& inferParams ) {
                for ( auto& entry : inferParams ) {
                        maybeAccept( entry.second.actualType, *visitor );
                        maybeAccept( entry.second.formalType, *visitor );
                        maybeAccept( entry.second.expr, *visitor );
                        visit( *entry.second.inferParams );
                }
        }

public:
        void postvisit( Expression* expr ) {
                maybeAccept( expr->env, *visitor );
                visit( expr->inferParams );
        }

        void postvisit( OffsetofExpr* expr ) {
                postvisit( static_cast<Expression*>(expr) );
                maybeAccept( expr->member, *visitor );
        }

        void postvisit( UniqueExpr* expr ) {
                postvisit( static_cast<Expression*>(expr) );
                maybeAccept( expr->object, *visitor );
                maybeAccept( expr->var, *visitor );
        }

        void postvisit( UntypedExpr* expr ) {
                postvisit( static_cast<Expression*>(expr) );
                maybeAccept( expr->function, *visitor );
        }

        void postvisit( VariableExpr* expr ) {
                postvisit( static_cast<Expression*>(expr) );
                maybeAccept( expr->var, *visitor );  // not in PassVisitor because it causes cycle
        }

private:
        void visit( Label& lbl ) {
                acceptAll( lbl.get_attributes(), *visitor );
                // maybeAccept( lbl.get_statement(), *visitor );  // introduces infinite loop in tracer
        }

public:
        void postvisit( Statement* stmt ) {
                for ( Label& l : stmt->labels ) {
                        visit( l );
                }
        }

        void postvisit( BranchStmt* stmt ) {
                postvisit( static_cast<Statement*>(stmt) );
                visit( stmt->target );
                maybeAccept( stmt->computedTarget, *visitor );
        }

        void postvisit( Type* type ) {
                acceptAll( type->attributes, *visitor );
        }

        void postvisit( EnumInstType* type ) {
                postvisit( static_cast<Type*>(type) );
                maybeAccept( type->baseEnum, *visitor );
        }

        void postvisit( PointerType* type ) {
                postvisit( static_cast<Type*>(type) );
                maybeAccept( type->dimension, *visitor );
        }

        void postvisit( StructInstType* type ) {
                postvisit( static_cast<Type*>(type) );
                maybeAccept( type->baseStruct, *visitor );
        }

        void postvisit( TraitInstType* type ) {
                postvisit( static_cast<Type*>(type) );
                maybeAccept( type->baseTrait, *visitor );
        }

        void postvisit( TypeInstType* type ) {
                postvisit( static_cast<Type*>(type) );
                maybeAccept( type->baseType, *visitor );
        }

        void postvisit( UnionInstType* type ) {
                postvisit( static_cast<Type*>(type) );
                maybeAccept( type->baseUnion, *visitor );
        }

private:
        void visit( const ResolvExpr::TypeEnvironment::Classes* c ) {
                typedef ResolvExpr::TypeEnvironment::Classes C;
                // trace all parent classes, short-circuiting at one traced
                while ( gc.notrace_mark( c ) && c->get_mode() != C::BASE ) { c = c->get_base(); }
        }

        void visit( const ResolvExpr::TypeEnvironment::Bindings* b ) {
                typedef ResolvExpr::TypeEnvironment::Bindings B;

                while ( true ) {
                        if ( ! gc.notrace_mark( b ) ) return;  // short-circuit if already traced

                        if ( b->get_mode() == B::BASE ) break; // break if this is a base map
                        
                        if ( b->get_mode() != B::REM ) { // trace bound intermediate elements
                                maybeAccept( b->get_val().type, *visitor );
                        }

                        b = b->get_base();
                }

                // trace bound elements in base binding
                b->for_each( [&](interned_string, const ResolvExpr::BoundType& bound) {
                        maybeAccept( bound.type, *visitor );  // trace bound elements
                } );
        }

public:
        void visit( const ResolvExpr::TypeEnvironment& env ) {
                visit( env.classes );
                visit( env.bindings );
        }
};

/// Traces entire translation unit recursively
static inline const GC& operator<< ( const GC& gc, const std::list<Declaration*>& translationUnit ) {
        PassVisitor<GcTracer> tracer{ gc };
        acceptAll( const_cast<std::list<Declaration*>&>( translationUnit ), tracer );
        return gc;
}

// Local Variables: //
// tab-width: 4 //
// mode: c++ //
// compile-command: "make install" //
// End: //