source: src/CodeGen/LinkOnce.cpp@ d8a3073

//
// Cforall Version 1.0.0 Copyright (C) 2021 University of Waterloo
//
// The contents of this file are covered under the licence agreement in the
// file "LICENCE" distributed with Cforall.
//
// LinkOnce.cpp -- Translate the cfa_linkonce attribute.
//
// Author           : Andrew Beach
// Created On       : Thur May 13 10:10:00 2021
// Last Modified By : Andrew Beach
// Last Modified On : Wed Oct  4 10:52:00 2023
// Update Count     : 1
//

#include "LinkOnce.hpp"

#include <algorithm>

#include "AST/Attribute.hpp"
#include "AST/Decl.hpp"
#include "AST/Expr.hpp"
#include "AST/Pass.hpp"
#include "CompilationState.hpp"
#include "InitTweak/InitTweak.hpp"

namespace CodeGen {

namespace {

bool is_cfa_linkonce( ast::Attribute const * attr ) {
        return "cfa_linkonce" == attr->name;
}

bool is_section_attribute( ast::Attribute const * attr ) {
        return "section" == attr->name;
}

bool is_visibility_attribute( ast::Attribute const * attr ) {
        return "visibility" == attr->name;
}

struct LinkOnceCore : public ast::WithShortCircuiting {
        void previsit( ast::Decl const * ) {
                visit_children = false;
        }

        ast::DeclWithType const * postvisit( ast::DeclWithType const * decl ) {
                // Check to see if we have to mutate, because should be uncommon.
                {
                        auto & attributes = decl->attributes;
                        auto found = std::find_if( attributes.begin(), attributes.end(),
                                        is_cfa_linkonce );
                        if ( attributes.end() == found ) return decl;
                }
                auto mutDecl = mutate( decl );
                auto & attributes = mutDecl->attributes;

                // Remove all conflicting section attributes.
                erase_if( attributes, is_section_attribute );

                // Get the attribute, and overwrite it as a section attribute.
                auto found = std::find_if( attributes.begin(), attributes.end(),
                                is_cfa_linkonce );
                assert( attributes.end() != found );
                ast::Attribute * attribute = found->get_and_mutate();
                assert( attribute->params.empty() );

                attribute->name = "section";
                attribute->params.push_back(
                        ast::ConstantExpr::from_string( mutDecl->location,
                                ".gnu.linkonce." + decl->mangleName
                        )
                );

                attributes.push_back( new ast::Attribute( "visibility", {
                        ast::ConstantExpr::from_string( mutDecl->location, "default" )
                } ) );

                // Mark as used so GCC does not warn about unused definitions
                // in translation units that include but don't call the function.
                attributes.push_back( new ast::Attribute( "used" ) );

                return mutDecl;
        }
};

/// Adds visibility("default") to autogen CFA autogen function definitions so they
/// are exported from shared libraries compiled with -fvisibility=hidden.
struct AutogenDefaultVisibility {
        int funcDepth = 0;

        void previsit( ast::FunctionDecl const * ) {
                funcDepth++;
        }

        ast::FunctionDecl const * postvisit( ast::FunctionDecl const * decl ) {
                funcDepth--;
                // Only top-level function definitions (not nested).
                if ( funcDepth > 0 ) return decl;
                // Only CFA-mangled, non-builtin, non-static, non-inline functions.
                if ( !decl->linkage.is_mangled ) return decl;
                if ( decl->linkage.is_builtin ) return decl;
                if ( decl->storage.is_static || decl->funcSpec.is_inline ) return decl;

                // Only definitions (functions with bodies).
                if ( !decl->stmts ) return decl;

                // Only constructors, destructors, and assignment operators —
                // the functions that cfa_linkonce autogen functions call on member types.
                if ( !InitTweak::isDefaultConstructor( decl )
                                && !InitTweak::isCopyConstructor( decl )
                                && !InitTweak::isDestructor( decl )
                                && !InitTweak::isAssignment( decl ) ) return decl;

                // Skip if already has a visibility attribute.
                auto & attributes = decl->attributes;
                auto found = std::find_if( attributes.begin(), attributes.end(),
                                is_visibility_attribute );
                if ( attributes.end() != found ) return decl;

                auto mutDecl = mutate( decl );
                mutDecl->attributes.push_back( new ast::Attribute( "visibility", {
                        ast::ConstantExpr::from_string( mutDecl->location, "default" )
                } ) );
                return mutDecl;
        }
};

} // namespace

void translateLinkOnce( ast::TranslationUnit & translationUnit ) {
        ast::Pass<LinkOnceCore>::run( translationUnit );

        // When building libcfa (-cfalib), add visibility("default") to CFA
        // function definitions so they are exported despite -fvisibility=hidden.
        if ( buildingLibrary() ) {
                ast::Pass<AutogenDefaultVisibility>::run( translationUnit );
        }
}

} // namespace CodeGen