source: src/ControlStruct/ExceptDecl.cc @ 6ece306

//
// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
//
// The contents of this file are covered under the licence agreement in the
// file "LICENCE" distributed with Cforall.
//
// ExceptDecl.cc -- Handles declarations of exception types.
//
// Author           : Henry Xue
// Created On       : Tue Jul 20 04:10:50 2021
// Last Modified By : Andrew Beach
// Last Modified On : Wed May 25 16:43:00 2022
// Update Count     : 5
//

#include "ExceptDecl.h"

#include <cassert>               // for assert
#include <string>                // for string
#include <sstream>               // for stringstream

#include "Common/PassVisitor.h"  // for PassVisitor
#include "Common/utility.h"      // for cloneAll
#include "SynTree/Mutator.h"     // for mutateAll
#include "Virtual/Tables.h"      // for helpers

namespace ControlStruct {

const std::list< Expression *> & makeParameters(
        const std::list< TypeDecl *> & forallClause
) {
        auto parameters = new std::list< Expression *>();
        for ( auto it = forallClause.begin(); it != forallClause.end(); it++ ) {
                parameters->emplace_back( new TypeExpr(
                        new TypeInstType( noQualifiers, ( *it )->get_name(), false )
                ) );
        }
        return *parameters;
}

StructInstType * makeExceptInstType(
        const std::string & exceptionName,
        const std::list< Expression *> & parameters
) {
        StructInstType * exceptInstType = new StructInstType(
                noQualifiers,
                exceptionName
        );
        cloneAll( parameters, exceptInstType->parameters );
        return exceptInstType;
}

// void (*copy)(exception_name parameters * this, exception_name parameters * that);
FunctionType * makeCopyFnType(
        const std::string & exceptionName,
        const std::list< Expression *> & parameters
) {
        FunctionType * copyFnType = new FunctionType( noQualifiers, false );
        copyFnType->get_parameters().push_back( new ObjectDecl(
                "this",
                noStorageClasses,
                LinkageSpec::Cforall,
                nullptr,
                new PointerType( noQualifiers,
                        makeExceptInstType( exceptionName, parameters ) ),
                nullptr
        ) );
        copyFnType->get_parameters().push_back( new ObjectDecl(
                "that",
                noStorageClasses,
                LinkageSpec::Cforall,
                nullptr,
                new PointerType( noQualifiers,
                        makeExceptInstType( exceptionName, parameters ) ),
                nullptr
        ) );
        copyFnType->get_returnVals().push_back( new ObjectDecl(
                "",
                noStorageClasses,
                LinkageSpec::Cforall,
                nullptr,
                new VoidType( noQualifiers ),
                nullptr
        ) );
        return copyFnType;
}

// void (*^?{})(exception_name parameters & this);
FunctionType * makeDtorFnType(
        const std::string & exceptionName,
        const std::list< Expression *> & parameters
) {
        FunctionType * dtorFnType = new FunctionType( noQualifiers, false );
        dtorFnType->get_parameters().push_back( new ObjectDecl(
                "this",
                noStorageClasses,
                LinkageSpec::Cforall,
                nullptr,
                new ReferenceType( noQualifiers,
                        makeExceptInstType( exceptionName, parameters ) ),
                nullptr
        ) );
        dtorFnType->get_returnVals().push_back( new ObjectDecl(
                "",
                noStorageClasses,
                LinkageSpec::Cforall,
                nullptr,
                new VoidType( noQualifiers ),
                nullptr
        ) );
        return dtorFnType;
}

// const char * (*msg)(exception_name parameters * this);
FunctionType * makeMsgFnType(
        const std::string & exceptionName,
        const std::list< Expression *> & parameters
) {
        FunctionType * msgFnType = new FunctionType( noQualifiers, false );
        msgFnType->get_parameters().push_back( new ObjectDecl(
                "this",
                noStorageClasses,
                LinkageSpec::Cforall,
                nullptr,
                new PointerType( noQualifiers,
                        makeExceptInstType( exceptionName, parameters ) ),
                nullptr
        ) );
        msgFnType->get_returnVals().push_back( new ObjectDecl(
                "",
                noStorageClasses,
                LinkageSpec::Cforall,
                nullptr,
                new PointerType( noQualifiers,
                        new BasicType( Type::Const, BasicType::Char ) ),
                nullptr
        ) );
        return msgFnType;
}

StructDecl * ehmTypeIdStruct(
        const std::string & exceptionName,
        const std::list< TypeDecl *> & forallClause
) {
        StructDecl * structDecl = new StructDecl( Virtual::typeIdType( exceptionName ) );
        structDecl->members.push_back( new ObjectDecl(
                "parent",
                noStorageClasses,
                LinkageSpec::Cforall,
                nullptr,
                new PointerType( noQualifiers,
                        new StructInstType( Type::Const, "__cfavir_type_info" ) ),
                nullptr
        ) );
        structDecl->set_body( true );
        cloneAll( forallClause, structDecl->parameters );
        return structDecl;
}

ObjectDecl * ehmTypeIdValue(
        const std::string & exceptionName,
        const std::list< Expression *> & parameters
) {
        StructInstType * typeIdType = new StructInstType(
                Type::Const,
                Virtual::typeIdType( exceptionName )
        );
        cloneAll( parameters, typeIdType->parameters );
        return new ObjectDecl(
                Virtual::typeIdName( exceptionName ),
                noStorageClasses,
                LinkageSpec::Cforall,
                nullptr,
                typeIdType,
                new ListInit( { new SingleInit(
                        new AddressExpr( new NameExpr( "__cfatid_exception_t" ) )
                        ) }, {}, true ),
                { new Attribute( "cfa_linkonce" ) }
        );
}

StructDecl * ehmExceptionStructDecl(
        const std::string & exceptionName,
        const std::list< TypeDecl *> & forallClause
) {
        StructDecl * structDecl = new StructDecl( exceptionName );
        cloneAll( forallClause, structDecl->parameters );
        return structDecl;
}

StructDecl * ehmVirtualTableStruct(
        const std::string & exceptionName,
        const std::list< TypeDecl *> & forallClause,
        const std::list< Expression *> & parameters
) {
        StructInstType * typeIdType = new StructInstType(
                Type::Const,
                Virtual::typeIdType( exceptionName )
        );
        cloneAll( parameters, typeIdType->parameters );
        ObjectDecl * typeId = new ObjectDecl(
                "__cfavir_typeid",
                noStorageClasses,
                LinkageSpec::Cforall,
                nullptr,
                new PointerType( noQualifiers, typeIdType ),
                nullptr
        );
        ObjectDecl * size = new ObjectDecl(
                "size",
                noStorageClasses,
                LinkageSpec::Cforall,
                nullptr,
                new TypeInstType( noQualifiers, "size_t", false ),
                nullptr
        );
        ObjectDecl * copy = new ObjectDecl(
                "copy",
                noStorageClasses,
                LinkageSpec::Cforall,
                nullptr,
                new PointerType( noQualifiers,
                        makeCopyFnType( exceptionName, parameters ) ),
                nullptr
        );
        ObjectDecl * dtor = new ObjectDecl(
                "^?{}",
                noStorageClasses,
                LinkageSpec::Cforall,
                nullptr,
                new PointerType( noQualifiers,
                        makeDtorFnType( exceptionName, parameters ) ),
                nullptr
        );
        ObjectDecl * msg = new ObjectDecl(
                "msg",
                noStorageClasses,
                LinkageSpec::Cforall,
                nullptr,
                new PointerType( noQualifiers,
                        makeMsgFnType( exceptionName, parameters ) ),
                nullptr
        );
        StructDecl * structDecl = new StructDecl( Virtual::vtableTypeName( exceptionName ) );
        structDecl->members.push_back( typeId );
        structDecl->members.push_back( size );
        structDecl->members.push_back( copy );
        structDecl->members.push_back( dtor );
        structDecl->members.push_back( msg );
        structDecl->set_body( true );
        cloneAll( forallClause, structDecl->parameters );
        return structDecl;
}

StructDecl * ehmExceptionStruct(
        const std::string & exceptionName,
        const std::list< TypeDecl *> & forallClause,
        const std::list< Expression *> & parameters,
        const std::list< Declaration *> & members
) {
        StructInstType * vtableType = new StructInstType(
                Type::Const,
                Virtual::vtableTypeName( exceptionName )
        );
        cloneAll( parameters, vtableType->parameters );
        StructDecl * structDecl = new StructDecl( exceptionName );
        structDecl->members = members;
        structDecl->members.push_front( new ObjectDecl(
                "virtual_table",
                noStorageClasses,
                LinkageSpec::Cforall,
                nullptr,
                new PointerType( noQualifiers, vtableType ),
                nullptr
        ) );
        structDecl->set_body( true );
        cloneAll( forallClause, structDecl->parameters );
        return structDecl;
}

ObjectDecl * ehmTypeIdExtern(
        const std::string & exceptionName,
        const std::list< Expression *> & parameters
) {
        StructInstType * typeIdType = new StructInstType(
                Type::Const,
                Virtual::typeIdType( exceptionName )
        );
        cloneAll( parameters, typeIdType->parameters );
        return new ObjectDecl(
                Virtual::typeIdName( exceptionName ),
                Type::Extern,
                LinkageSpec::Cforall,
                nullptr,
                typeIdType,
                nullptr,
                { new Attribute( "cfa_linkonce" ) }
        );
}

ObjectDecl * ehmExternVtable(
        const std::string & exceptionName,
        const std::list< Expression *> & parameters,
        const std::string & tableName
) {
        StructInstType * vtableType = new StructInstType(
                Type::Const,
                Virtual::vtableTypeName( exceptionName )
        );
        cloneAll( parameters, vtableType->parameters );
        return new ObjectDecl(
                tableName,
                Type::Extern,
                LinkageSpec::Cforall,
                nullptr,
                vtableType,
                nullptr
        );
}

FunctionDecl * ehmDefineCopy(
        const std::string & exceptionName,
        const std::list< Expression *> & parameters
) {
        return new FunctionDecl(
                "copy",
                noStorageClasses,
                LinkageSpec::Cforall,
                makeCopyFnType( exceptionName, parameters ),
                new CompoundStmt( {
                        new ExprStmt( new UntypedExpr( new NameExpr( "?=?" ), {
                                new UntypedExpr( new NameExpr( "*?" ), { new NameExpr( "this" ) } ),
                                new UntypedExpr( new NameExpr( "*?" ), { new NameExpr( "that" ) } )
                        } ) )
                } )
        );
}

FunctionDecl * ehmDefineMsg(
        const std::string & exceptionName,
        const std::list< Expression *> & parameters
) {
        std::stringstream msg;
        msg << exceptionName;
        if ( !parameters.empty() ) { // forall variant, add parameters
                msg << "(";
                for ( auto it = parameters.begin(); it != parameters.end(); it++ ) {
                        ( *it )->print( msg );
                        if ( it + 1 == parameters.end() ) {
                                msg << ")"; // end of list, close bracket
                        } else {
                                msg << ", "; // otherwise use comma as separator
                        }
                }
        }
        return new FunctionDecl(
                "msg",
                noStorageClasses,
                LinkageSpec::Cforall,
                makeMsgFnType( exceptionName, parameters ),
                new CompoundStmt( {
                        new ReturnStmt( new ConstantExpr( Constant::from_string( msg.str() ) ) )
                } )
        );
}

ObjectDecl * ehmVirtualTable(
        const std::string & exceptionName,
        const std::list< Expression *> & parameters,
        const std::string & tableName
) {
        StructInstType * sizeofType = new StructInstType( noQualifiers, exceptionName );
        cloneAll( parameters, sizeofType->parameters );
        std::list< Initializer *> inits {
                new SingleInit( new AddressExpr(
                        new NameExpr( Virtual::typeIdName( exceptionName ) ) ) ),
                new SingleInit( new SizeofExpr( sizeofType ) ),
                new SingleInit( new NameExpr( "copy" ) ),
                new SingleInit( new NameExpr( "^?{}" ) ),
                new SingleInit( new NameExpr( "msg" ) )
        };
        std::list< Designation *> desig {
                new Designation( { new NameExpr( "__cfavir_typeid" ) } ),
                new Designation( { new NameExpr( "size" ) } ),
                new Designation( { new NameExpr( "copy" ) } ),
                new Designation( { new NameExpr( "^?{}" ) } ),
                new Designation( { new NameExpr( "msg" ) } )
        };
        StructInstType * vtableType = new StructInstType(
                Type::Const,
                Virtual::vtableTypeName( exceptionName )
        );
        cloneAll( parameters, vtableType->parameters );
        return new ObjectDecl(
                tableName,
                noStorageClasses,
                LinkageSpec::Cforall,
                nullptr,
                vtableType,
                new ListInit( inits, desig )
        );
}

class ExceptDeclCore : public WithDeclsToAdd {
public:
        // translates exception decls
        Declaration * postmutate( StructDecl * structDecl );

        // translates vtable decls
        DeclarationWithType * postmutate( ObjectDecl * objectDecl );
};

Declaration * ExceptDeclCore::postmutate( StructDecl * structDecl ) {
        if ( structDecl->is_exception() ) {
                const std::string & exceptionName = structDecl->get_name();
                const std::list< TypeDecl *> & forallClause = structDecl->get_parameters();
                const std::list< Expression *> & parameters = makeParameters( forallClause );
                const std::list< Declaration *> & members = structDecl->get_members();

                declsToAddBefore.push_back( ehmTypeIdStruct( exceptionName, forallClause ) );
                if ( forallClause.empty() ) { // non-forall variant
                        declsToAddBefore.push_back( ehmTypeIdValue( exceptionName, parameters ) );
                }
                declsToAddBefore.push_back( ehmExceptionStructDecl( exceptionName, forallClause ) );
                declsToAddBefore.push_back( ehmVirtualTableStruct( exceptionName, forallClause, parameters ) );
                return ehmExceptionStruct( exceptionName, forallClause, parameters, members );
        }
        return structDecl;
}

DeclarationWithType * ExceptDeclCore::postmutate( ObjectDecl * objectDecl ) {
        // Check if it is VTableType
        VTableType * vtableType = dynamic_cast< VTableType *>( objectDecl->get_type() );
        if ( vtableType ) {
                TypeInstType * base = dynamic_cast< TypeInstType *>( vtableType->get_base() );
                assert( base ); // should be a TypeInstType
                const std::string & exceptionName = base->get_name();
                const std::string & tableName = objectDecl->get_name();
                const std::list< Expression *> parameters = base->get_parameters();

                if ( objectDecl->get_storageClasses().is_extern ) { // if extern
                        if ( !parameters.empty() ) { // forall variant
                                declsToAddBefore.push_back( ehmTypeIdExtern( exceptionName, parameters ) );
                        }
                        return ehmExternVtable( exceptionName, parameters, tableName );
                }
                // else, non-extern
                if ( !parameters.empty() ) { // forall variant
                        declsToAddBefore.push_back( ehmTypeIdValue( exceptionName, parameters ) );
                }
                declsToAddBefore.push_back( ehmDefineCopy( exceptionName, parameters ) );
                declsToAddBefore.push_back( ehmDefineMsg( exceptionName, parameters ) );
                return ehmVirtualTable( exceptionName, parameters, tableName );
        }
        return objectDecl;
}

class VTableCore : public WithDeclsToAdd {
public:
        // Remove any remaining vtable type nodes in the tree.
        Type * postmutate( VTableType * vtableType );
};

Type * VTableCore::postmutate( VTableType * vtableType ) {
        auto inst = strict_dynamic_cast<ReferenceToType *>( vtableType->base );

        std::string vtableName = Virtual::vtableTypeName( inst->name );
        StructInstType * newType = new StructInstType( noQualifiers, vtableName );
        cloneAll( inst->parameters, newType->parameters );

        delete vtableType;
        return newType;
}

void translateExcept( std::list< Declaration *> & translationUnit ) {
        PassVisitor<ExceptDeclCore> translator;
        mutateAll( translationUnit, translator );
        PassVisitor<VTableCore> typeTranslator;
        mutateAll( translationUnit, typeTranslator );
}

}