source: src/ControlStruct/ExceptDecl.cpp@ 42cd67b8

//
// Cforall Version 1.0.0 Copyright (C) 2018 University of Waterloo
//
// The contents of this file are covered under the licence agreement in the
// file "LICENCE" distributed with Cforall.
//
// ExceptDecl.cpp -- Translate "exception" and exception related declarations.
//
// Author           : Andrew Beach
// Created On       : Tue Jul 12 15:50:00 2022
// Last Modified By : Andrew Beach
// Last Modified On : Fri Jan 10 15:35:55 2024
// Update Count     : 2
//

#include "ExceptDecl.hpp"

#include <sstream>

#include "AST/Copy.hpp"
#include "AST/Decl.hpp"
#include "AST/Pass.hpp"
#include "AST/Print.hpp"
#include "AST/Type.hpp"
#include "Virtual/Tables.hpp"

namespace ControlStruct {

namespace {

std::vector<ast::ptr<ast::Expr>> forallToParams(
                std::vector<ast::ptr<ast::TypeDecl>> const & forall ) {
        return map_range<std::vector<ast::ptr<ast::Expr>>>( forall,
                []( ast::ptr<ast::TypeDecl> const & decl ) {
                        return new ast::TypeExpr( decl->location,
                                new ast::TypeInstType( decl->name, decl->kind ) );
                }
        );
}

// A slightly argumented extra constructor, adds a deepCopy.
ast::StructInstType * namedStructInstType(
                std::string const & name, ast::CV::Qualifiers qualifiers,
                std::vector<ast::ptr<ast::Expr>> const & params ) {
        ast::StructInstType * type = new ast::StructInstType( name, qualifiers );
        for ( ast::ptr<ast::Expr> const & param : params ) {
                type->params.push_back( ast::deepCopy( param ) );
        }
        return type;
}

ast::StructInstType * createExceptionInstType(
                std::string const & exceptionName,
                std::vector<ast::ptr<ast::Expr>> const & params ) {
        return namedStructInstType( exceptionName, ast::CV::Qualifiers(), params );
}

ast::StructInstType * createVTableInstType(
                std::string const & exceptionName,
                std::vector<ast::ptr<ast::Expr>> const & params ) {
        std::string name = Virtual::vtableTypeName( exceptionName );
        return namedStructInstType( name, ast::CV::Const, params );
}

ast::StructInstType * createTypeIdInstType(
                std::string const & exceptionName,
                std::vector<ast::ptr<ast::Expr>> const & params ) {
        std::string name = Virtual::typeIdType( exceptionName );
        return namedStructInstType( name, ast::CV::Const, params );
}

ast::FunctionType const * createCopyFuncType(
                std::string const & exceptionName,
                std::vector<ast::ptr<ast::Expr>> const & params ) {
        ast::FunctionType * type = new ast::FunctionType( ast::FixedArgs );
        type->params.push_back( new ast::PointerType(
                createExceptionInstType( exceptionName, params ) ) );
        type->params.push_back( new ast::PointerType(
                createExceptionInstType( exceptionName, params ) ) );
        type->returns.push_back( new ast::VoidType() );
        return type;
}

ast::FunctionType const * createDtorFuncType(
                std::string const & exceptionName,
                std::vector<ast::ptr<ast::Expr>> const & params ) {
        ast::FunctionType * type = new ast::FunctionType( ast::FixedArgs );
        type->params.push_back( new ast::ReferenceType(
                createExceptionInstType( exceptionName, params ) ) );
        type->returns.push_back( new ast::VoidType() );
        return type;
}

ast::FunctionType const * createMsgFuncType(
                std::string const & exceptionName,
                std::vector<ast::ptr<ast::Expr>> const & params ) {
        ast::FunctionType * type = new ast::FunctionType( ast::FixedArgs );
        type->params.push_back( new ast::PointerType(
                createExceptionInstType( exceptionName, params ) ) );
        type->returns.push_back( new ast::PointerType(
                new ast::BasicType( ast::BasicKind::Char, ast::CV::Const ) ) );
        return type;
}

ast::StructDecl const * createTypeIdStruct(
                CodeLocation const & location,
                std::string const & exceptionName,
                std::vector<ast::ptr<ast::TypeDecl>> const & forallClause ) {
        ast::StructDecl * decl = new ast::StructDecl( location,
                        Virtual::typeIdType( exceptionName ) );
        decl->members.push_back( new ast::ObjectDecl(
                location,
                "parent",
                new ast::PointerType(
                        new ast::StructInstType( "__cfavir_type_info", ast::CV::Const ) )
        ) );
        decl->body = true;
        for ( ast::ptr<ast::TypeDecl> const & param : forallClause ) {
                // Create an unsized and assertionless copy of the parameter.
                decl->params.push_back( new ast::TypeDecl(
                        param->location,
                        param->name,
                        param->storage,
                        param->base ? ast::deepCopy( param->base ) : nullptr,
                        ast::TypeDecl::Dtype,
                        false,
                        nullptr
                ) );
        }
        return decl;
}

ast::ObjectDecl const * createTypeIdValue(
                CodeLocation const & location,
                std::string const & exceptionName,
                std::vector<ast::ptr<ast::Expr>> const & params ) {
        ast::StructInstType * typeIdType =
                createTypeIdInstType( exceptionName, params );
        return new ast::ObjectDecl(
                location,
                Virtual::typeIdName( exceptionName ),
                typeIdType,
                new ast::ListInit( location, {
                        new ast::SingleInit( location,
                                new ast::AddressExpr( location,
                                        new ast::NameExpr( location, "__cfatid_exception_t" ) ),
                                ast::MaybeConstruct ),
                }, {}, ast::MaybeConstruct ),
                ast::Storage::Classes(),
                ast::Linkage::Cforall,
                nullptr,
                { new ast::Attribute( "cfa_linkonce" ) }
        );
}

ast::StructDecl const * createExceptionStructForward(
                CodeLocation const & location,
                std::string const & exceptionName,
                std::vector<ast::ptr<ast::TypeDecl>> const & forall ) {
        ast::StructDecl * decl = new ast::StructDecl( location, exceptionName );
        for ( ast::ptr<ast::TypeDecl> const & param : forall ) {
                decl->params.push_back( ast::deepCopy( param ) );
        }
        return decl;
}

ast::StructDecl const * createVirtualTableStruct(
                CodeLocation const & location,
                std::string const & exceptionName,
                std::vector<ast::ptr<ast::TypeDecl>> const & forall,
                std::vector<ast::ptr<ast::Expr>> const & params ) {
        ast::StructInstType * typeIdType =
                createTypeIdInstType( exceptionName, params );
        ast::ObjectDecl * typeId = new ast::ObjectDecl(
                location,
                "__cfavir_typeid",
                new ast::PointerType( typeIdType )
        );
        ast::ObjectDecl * size = new ast::ObjectDecl(
                location,
                "size",
                new ast::TypeInstType( "size_t", ast::TypeDecl::Dtype )
        );
        ast::ObjectDecl * copy = new ast::ObjectDecl(
                location,
                "copy",
                new ast::PointerType( createCopyFuncType( exceptionName, params ) )
        );
        ast::ObjectDecl * dtor = new ast::ObjectDecl(
                location,
                "^?{}",
                new ast::PointerType( createDtorFuncType( exceptionName, params ) )
        );
        ast::ObjectDecl * msg = new ast::ObjectDecl(
                location,
                "msg",
                new ast::PointerType( createMsgFuncType( exceptionName, params ) )
        );
        ast::StructDecl * decl = new ast::StructDecl(
                location,
                Virtual::vtableTypeName( exceptionName ) );
        decl->members.push_back( typeId );
        decl->members.push_back( size );
        decl->members.push_back( copy );
        decl->members.push_back( dtor );
        decl->members.push_back( msg );
        decl->body = true;
        for ( ast::ptr<ast::TypeDecl> const & param : forall ) {
                decl->params.push_back( param );
        }
        return decl;
}

ast::StructDecl const * createExceptionStruct(
                CodeLocation const & location,
                std::string const & exceptionName,
                std::vector<ast::ptr<ast::TypeDecl>> const & forallClause,
                std::vector<ast::ptr<ast::Expr>> const & params,
                std::vector<ast::ptr<ast::Decl>> const & members ) {
        ast::StructDecl * decl = new ast::StructDecl( location, exceptionName );
        decl->members.push_back( new ast::ObjectDecl(
                location,
                "virtual_table",
                new ast::PointerType(
                        createVTableInstType( exceptionName, params ) )
        ) );
        for ( ast::ptr<ast::Decl> const & member : members ) {
                decl->members.push_back( ast::deepCopy( member ) );
        }
        decl->body = true;
        for ( ast::ptr<ast::TypeDecl> const & param : forallClause ) {
                decl->params.push_back( ast::deepCopy( param ) );
        }
        return decl;
}

ast::ObjectDecl const * createExternTypeId(
                CodeLocation const & location,
                std::string const & exceptionName,
                std::vector<ast::ptr<ast::Expr>> const & params ) {
        return new ast::ObjectDecl(
                location,
                Virtual::typeIdName( exceptionName ),
                createVTableInstType( exceptionName, params ),
                nullptr,
                ast::Storage::Extern,
                ast::Linkage::Cforall,
                nullptr,
                { new ast::Attribute( "cfa_linkonce" ) }
        );
}

ast::ObjectDecl * createExternVTable(
                CodeLocation const & location,
                std::string const & exceptionName,
                std::vector<ast::ptr<ast::Expr>> const & params,
                std::string const & tableName ) {
        return new ast::ObjectDecl(
                location,
                tableName,
                createVTableInstType( exceptionName, params ),
                nullptr,
                ast::Storage::Extern,
                ast::Linkage::Cforall
        );
}

ast::FunctionDecl const * createCopy(
                CodeLocation const & location,
                std::string const & exceptionName,
                std::vector<ast::ptr<ast::Expr>> const & params ) {
        return new ast::FunctionDecl(
                location,
                "copy",
                {/* forall */},
                {/* assertions */},
                {
                        new ast::ObjectDecl(
                                location,
                                "this",
                                new ast::PointerType(
                                        createExceptionInstType( exceptionName, params ) )
                        ),
                        new ast::ObjectDecl(
                                location,
                                "that",
                                new ast::PointerType(
                                        createExceptionInstType( exceptionName, params ) )
                        ),
                },
                {
                        new ast::ObjectDecl( location, "", new ast::VoidType() ),
                },
                new ast::CompoundStmt( location, {
                        new ast::ExprStmt( location,
                                new ast::UntypedExpr( location,
                                        new ast::NameExpr( location, "?{}" ),
                                        {
                                                new ast::UntypedExpr( location,
                                                        new ast::NameExpr( location, "*?" ),
                                                        { new ast::NameExpr( location, "this" ) } ),
                                                new ast::UntypedExpr( location,
                                                        new ast::NameExpr( location, "*?" ),
                                                        { new ast::NameExpr( location, "that" ) } ),
                                        }
                                )
                        ),
                } ),
                ast::Storage::Classes(),
                ast::Linkage::Cforall,
                { new ast::Attribute( "cfa_linkonce" ) }
        );
}

ast::FunctionDecl const * createMsg(
                CodeLocation const & location,
                std::string const & exceptionName,
                std::vector<ast::ptr<ast::Expr>> const & params ) {
        std::stringstream msg;
        msg << exceptionName;
        // The forall variant, add parameters to the string.
        if ( !params.empty() ) {
                msg << "(";
                bool first = true;
                for ( auto & param : params ) {
                        // Seperator Logic: A comma proceeds all but the first object.
                        if ( first ) {
                                first = false;
                        } else {
                                msg << ", ";
                        }

                        ast::print( msg, param.get() );
                }
                msg << ")";
        }
        return new ast::FunctionDecl(
                location,
                "msg",
                {/* forall */},
                {/* assertions */},
                {
                        new ast::ObjectDecl(
                                location,
                                "", // "this," though unused in the body
                                new ast::PointerType(
                                        createExceptionInstType( exceptionName, params ) )
                        ),
                },
                {
                        new ast::ObjectDecl(
                                location,
                                "",
                                new ast::PointerType(
                                        new ast::BasicType( ast::BasicKind::Char, ast::CV::Const ) )
                        ),
                },
                new ast::CompoundStmt( location, {
                        new ast::ReturnStmt( location,
                                ast::ConstantExpr::from_string( location, msg.str() )
                        ),
                } ),
                ast::Storage::Classes(),
                ast::Linkage::Cforall,
                { new ast::Attribute( "cfa_linkonce" ) }
        );
}

ast::ObjectDecl * createVirtualTable(
                CodeLocation const & location,
                std::string const & exceptionName,
                std::vector<ast::ptr<ast::Expr>> const & params,
                std::string const & tableName ) {
        ast::StructInstType * sizeType = new ast::StructInstType( exceptionName );
        for ( ast::ptr<ast::Expr> const & param : params ) {
                sizeType->params.push_back( ast::deepCopy( param ) );
        }
        std::vector<ast::ptr<ast::Init>> inits {
                new ast::SingleInit( location,
                        new ast::AddressExpr( location,
                                new ast::NameExpr( location,
                                        Virtual::typeIdName( exceptionName ) ) ) ),
                new ast::SingleInit( location,
                        new ast::SizeofExpr( location, sizeType )  ),
                new ast::SingleInit( location,
                        new ast::NameExpr( location, "copy" ) ),
                new ast::SingleInit( location,
                        new ast::NameExpr( location, "^?{}" ) ),
                new ast::SingleInit( location,
                        new ast::NameExpr( location, "msg" ) ),
        };
        std::vector<ast::ptr<ast::Designation>> dsigs {
                new ast::Designation( location, {
                        new ast::NameExpr( location, "__cfavir_typeid" ) } ),
                new ast::Designation( location, {
                        new ast::NameExpr( location, "size" ) } ),
                new ast::Designation( location, {
                        new ast::NameExpr( location, "copy" ) } ),
                new ast::Designation( location, {
                        new ast::NameExpr( location, "^?{}" ) } ),
                new ast::Designation( location, {
                        new ast::NameExpr( location, "msg" ) } ),
        };
        return new ast::ObjectDecl(
                location,
                tableName,
                createVTableInstType( exceptionName, params ),
                new ast::ListInit( location, std::move( inits ), std::move( dsigs ) )
        );
}

struct ExceptDeclCore : public ast::WithDeclsToAdd {
        ast::StructDecl const * transformExcept( ast::StructDecl const * decl );
        ast::ObjectDecl const * transformVTable(
                ast::ObjectDecl const * decl, ast::VTableType const * type );

        ast::StructDecl const * postvisit( ast::StructDecl const * decl ) {
                // Exceptions don't get their own node type, so filter that.
                if ( ast::AggregateDecl::Exception == decl->kind ) {
                        return transformExcept( decl );
                }
                return decl;
        }

        ast::ObjectDecl const * postvisit( ast::ObjectDecl const * decl ) {
                // Modify remaining objects that have a vtable type.
                if ( auto * type = decl->type.as<ast::VTableType>() ) {
                        return transformVTable( decl, type );
                }
                return decl;
        }
};

ast::StructDecl const * ExceptDeclCore::transformExcept(
                ast::StructDecl const * decl ) {
        CodeLocation const & location = decl->location;
        std::string const & exceptionName = decl->name;
        std::vector<ast::ptr<ast::TypeDecl>> const & forall = decl->params;
        std::vector<ast::ptr<ast::Expr>> params = forallToParams( forall );
        std::vector<ast::ptr<ast::Decl>> const & members = decl->members;

        declsToAddBefore.push_back(
                createTypeIdStruct( location, exceptionName, forall ) );
        if ( forall.empty() ) {
                // Non-forall variant.
                declsToAddBefore.push_back(
                        createTypeIdValue( location, exceptionName, params ) );
        }
        declsToAddBefore.push_back(
                createExceptionStructForward( location, exceptionName, forall ) );
        declsToAddBefore.push_back(
                createVirtualTableStruct( location, exceptionName, forall, params ) );
        return createExceptionStruct( location, exceptionName, forall, params, members );
}

ast::NameExpr const * designatedName( ast::Designation const * des ) {
        if ( des && 1 == des->designators.size() ) {
                return des->designators.front().as<ast::NameExpr>();
        }
        return nullptr;
}

ast::ObjectDecl const * ExceptDeclCore::transformVTable(
                ast::ObjectDecl const * decl, ast::VTableType const * type ) {
        CodeLocation const & location = decl->location;
        auto base = type->base.strict_as<ast::TypeInstType>();
        std::string const & exceptionName = base->name;
        std::vector<ast::ptr<ast::Expr>> const & params = base->params;
        std::string const & tableName = decl->name;

        ast::ObjectDecl * retDecl;
        if ( decl->storage.is_extern ) {
                // Unique type-ids are only needed for polymorphic instances.
                if ( !params.empty() ) {
                        declsToAddBefore.push_back(
                                createExternTypeId( location, exceptionName, params ) );
                }
                retDecl = createExternVTable( location, exceptionName, params, tableName );
        } else {
                // Unique type-ids are only needed for polymorphic instances.
                if ( !params.empty() ) {
                        declsToAddBefore.push_back(
                                createTypeIdValue( location, exceptionName, params ) );
                }
                retDecl = createVirtualTable(
                        location, exceptionName, params, tableName );
                // There is quite a bit of work to pull over any initializers and
                // decide if we want to insert the default functions.
                bool foundCopy = false;
                bool foundMsg = false;
                ast::ListInit const * init = decl->init.as<ast::ListInit>();
                if ( init ) {
                        for ( size_t i = 0 ; i < init->initializers.size() ; ++i ) {
                                ast::Designation const * des = init->designations.at(i);
                                auto name = designatedName( des );
                                if ( nullptr == name ) continue;
                                if ( "copy" == name->name ) {
                                        foundCopy = true;
                                } else if ( "msg" == name->name ) {
                                        foundMsg = true;
                                }
                                auto retInit = retDecl->init.as<ast::ListInit>();
                                for ( size_t j = 0 ; j < retInit->initializers.size() ; ++j ) {
                                        ast::Designation const * des = retInit->designations.at(j);
                                        auto retName = designatedName( des );
                                        if ( retName && name->name == retName->name ) {
                                                retInit = ast::mutate_field_index( retInit,
                                                        &ast::ListInit::initializers, j,
                                                        init->initializers.at(i) );
                                        }
                                }
                                retDecl->init = retInit;
                        }
                }
                if ( !foundCopy ) {
                        declsToAddBefore.push_back(
                                createCopy( location, exceptionName, params ) );
                }
                if ( !foundMsg ) {
                        declsToAddBefore.push_back(
                                createMsg( location, exceptionName, params ) );
                }
        }

        for ( ast::ptr<ast::Attribute> const & attr : decl->attributes ) {
                retDecl->attributes.push_back( attr );
        }

        return retDecl;
}

struct VTableCore {
        ast::StructInstType const * postvisit( ast::VTableType const * type ) {
                auto inst = type->base.as<ast::BaseInstType>();

                std::string vtableName = Virtual::vtableTypeName( inst->name );

                auto newType = new ast::StructInstType( vtableName );
                for ( ast::ptr<ast::Expr> const & param : inst->params ) {
                        newType->params.push_back( param );
                }

                return newType;
        }
};

} // namespace

void translateExcept( ast::TranslationUnit & translationUnit ) {
        // Can I combine these?
        // Second pass really only covers what the first has missed.
        // Maybe if the first one is all previsits and the second all postvisit.
        ast::Pass<ExceptDeclCore>::run( translationUnit );
        ast::Pass<VTableCore>::run( translationUnit );
}

} // namespace ControlStruct

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