source: src/InitTweak/FixGlobalInit.cpp@ 13481af0

//
// 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.
//
// FixGlobalInit.cpp --
//
// Author           : Rob Schluntz
// Created On       : Mon May 04 15:14:56 2016
// Last Modified By : Peter A. Buhr
// Last Modified On : Thu Jul  2 16:39:52 2026
// Update Count     : 35
//

#include "FixGlobalInit.hpp"

#include <set>
#include <cassert>                 // for assert
#include <stddef.h>                // for NULL
#include <algorithm>               // for replace_if

#include "AST/Expr.hpp"
#include "AST/Node.hpp"
#include "AST/Pass.hpp"
#include "Common/UniqueName.hpp"   // for UniqueName
#include "InitTweak.hpp"           // for isIntrinsicSingleArgCallStmt

namespace InitTweak {

namespace {

class GlobalFixer : public ast::WithShortCircuiting {
public:
        void previsit(const ast::ObjectDecl *);
        void previsit(const ast::FunctionDecl *) { visit_children = false; }
        void previsit(const ast::StructDecl *) { visit_children = false; }
        void previsit(const ast::UnionDecl *) { visit_children = false; }
        void previsit(const ast::EnumDecl *) { visit_children = false; }
        void previsit(const ast::TraitDecl *) { visit_children = false; }
        void previsit(const ast::TypeDecl *) { visit_children = false; }

        bool pass = false;
        std::list< ast::ptr<ast::Stmt> > initStmts;
        std::list< ast::ptr<ast::Stmt> > destroyStmts;
        std::set< std::string > constDeclsMnames;
};

void GlobalFixer::previsit(const ast::ObjectDecl * objDecl) {
        auto mutDecl = mutate(objDecl);
        assertf(mutDecl == objDecl, "Global object decl must be unique");
        if ( ! pass ) {                                                                         // pass 1
                auto ctorInit = objDecl->init.as<ast::ConstructorInit>();
                if ( nullptr == ctorInit ) return;

                // a decision should have been made by the resolver, so ctor and init are not both non-NULL
                assert( !ctorInit->ctor || !ctorInit->init );

                const ast::Stmt * dtor = ctorInit->dtor;
                if ( dtor && !isIntrinsicSingleArgCallStmt( dtor ) ) {
                        // don't need to call intrinsic dtor, because it does nothing, but
                        // non-intrinsic dtors must be called
                        destroyStmts.push_front( dtor );
                } // if
                if ( const ast::Stmt * ctor = ctorInit->ctor ) {
                        if ( mutDecl->type->is_const() ) {
                                // Store names of all declarations with const qualifier and initializer for second pass.
                                constDeclsMnames.emplace( mutDecl->mangleName );
                        }
                        initStmts.push_back( ctor );
                        mutDecl->init = nullptr;
                } else if ( const ast::Init * init = ctorInit->init ) {
                        mutDecl->init = init;
                } else {
                        // no constructor and no initializer, which is okay
                        mutDecl->init = nullptr;
                }
        } else {                                                                                // pass 2
                // Remove const qualifier from matching names, covering all forward declaration(s) and definition.
                if ( constDeclsMnames.find( objDecl->mangleName ) != constDeclsMnames.end() ) {
                        ast::Type * fred = const_cast<ast::Type *>(mutDecl->get_type());
                        fred->set_const( false );
                } // if
        }
}

} // namespace

void fixGlobalInit(ast::TranslationUnit & translationUnit, bool inLibrary) {
        ast::Pass<GlobalFixer> fixer;

        // First pass fixes global initialization.
        accept_all( translationUnit, fixer );

        // Say these magic declarations come at the end of the file.
        CodeLocation const & location = translationUnit.decls.back()->location;

        if ( !fixer.core.initStmts.empty() ) {
                std::vector<ast::ptr<ast::Expr>> ctorParams;
                if (inLibrary) ctorParams.emplace_back(ast::ConstantExpr::from_int(location, 200));
                auto initFunction = new ast::FunctionDecl(location,
                        "__global_init__", {}, {}, {}, {},
                        new ast::CompoundStmt(location, std::move(fixer.core.initStmts)),
                        ast::Storage::Static, ast::Linkage::C,
                        {new ast::Attribute("constructor", std::move(ctorParams))});

                translationUnit.decls.emplace_back( initFunction );
        } // if

        if ( !fixer.core.destroyStmts.empty() ) {
                std::vector<ast::ptr<ast::Expr>> dtorParams;
                if (inLibrary) dtorParams.emplace_back(ast::ConstantExpr::from_int(location, 200));
                auto destroyFunction = new ast::FunctionDecl( location,
                        "__global_destroy__", {}, {}, {}, {},
                        new ast::CompoundStmt(location, std::move(fixer.core.destroyStmts)),
                        ast::Storage::Static, ast::Linkage::C,
                        {new ast::Attribute("destructor", std::move(dtorParams))});

                translationUnit.decls.emplace_back(destroyFunction);
        } // if

        fixer.core.pass = ! fixer.core.pass;
        // Second pass, removes const qualifiers so declarations appear in mutable .data section.
        // Note, the resolver has already checked for const-ness, so C only has to get the initialization correct.
        accept_all(translationUnit, fixer);
}

} // namespace InitTweak

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