Changeset c28ea4e for src/InitTweak

Timestamp:

Nov 4, 2020, 2:56:30 PM (5 years ago)

Author:

Colby Alexander Parsons <caparsons@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

eeb5023

Parents:

4b30e8cc (diff), a3f5208a (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src/InitTweak

Files:

• FixGlobalInit.cc (modified) (5 diffs)
• FixGlobalInit.h (modified) (2 diffs)
• FixInit.cc (modified) (2 diffs)
• FixInit.h (modified) (1 diff)
• FixInitNew.cpp (added)
• GenInit.cc (modified) (1 diff)
• GenInit.h (modified) (1 diff)
• InitTweak.cc (modified) (7 diffs)
• InitTweak.h (modified) (4 diffs)
• module.mk (modified) (1 diff)

src/InitTweak/FixGlobalInit.cc

@@ -34 +34 @@
 #include "SynTree/Visitor.h"       // for acceptAll, Visitor
 
+#include "AST/Expr.hpp"
+#include "AST/Node.hpp"
+#include "AST/Pass.hpp"
+
 namespace InitTweak {
         class GlobalFixer : public WithShortCircuiting {
@@ -50 +54 @@
                 FunctionDecl * initFunction;
                 FunctionDecl * destroyFunction;
+        };
+
+        class GlobalFixer_new : 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; }
+
+                std::list< ast::ptr<ast::Stmt> > initStmts;
+                std::list< ast::ptr<ast::Stmt> > destroyStmts;
         };
 
@@ -91 +109 @@
         }
 
+        void fixGlobalInit(ast::TranslationUnit & translationUnit, bool inLibrary) {
+                ast::Pass<GlobalFixer_new> fixer;
+                accept_all(translationUnit, fixer);
+
+                if ( !fixer.core.initStmts.empty() ) {
+                        std::vector<ast::ptr<ast::Expr>> ctorParams;
+                        if (inLibrary) ctorParams.emplace_back(ast::ConstantExpr::from_int({}, 200));
+                        auto initFunction = new ast::FunctionDecl({}, "__global_init__", {}, {}, {}, new ast::CompoundStmt({}, 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({}, 200));
+                        auto destroyFunction = new ast::FunctionDecl({}, "__global_destroy__", {}, {}, {}, new ast::CompoundStmt({}, std::move(fixer.core.destroyStmts)), 
+                                ast::Storage::Static, ast::Linkage::C, {new ast::Attribute("destructor", std::move(dtorParams))});
+
+                        translationUnit.decls.emplace_back(destroyFunction);
+                } // if
+        }
+
         void GlobalFixer::previsit( ObjectDecl *objDecl ) {
                 std::list< Statement * > & initStatements = initFunction->get_statements()->get_kids();
@@ -112 +153 @@
                         } // if
                         if ( Statement * ctor = ctorInit->ctor ) {
-                                // Translation 1: Add this attribute on the global declaration:
-                                //    __attribute__((section (".data#")))
-                                // which makes gcc put the global in the data section,
-                                // so that the global is writeable (via a const cast) in the init function.
-                                // The trailing # is an injected assembly comment, to suppress the "a" in
-                                //    .section .data,"a"
-                                //    .section .data#,"a"
-                                // to avoid assembler warning "ignoring changed section attributes for .data"
-                                Type *strLitT = new PointerType( Type::Qualifiers( ),
-                                        new BasicType( Type::Qualifiers( ), BasicType::Char ) );
-                                std::list< Expression * > attr_params;
-                                attr_params.push_back( 
-                                        new ConstantExpr( Constant( strLitT, "\".data#\"", std::nullopt ) ) );
-                                objDecl->attributes.push_back(new Attribute("section", attr_params));
-                                // Translation 2: Move the initizliation off the global declaration,
-                                // into the startup function.
+                                addDataSectonAttribute( objDecl );
                                 initStatements.push_back( ctor );
                                 objDecl->init = nullptr;
@@ -142 +168 @@
         }
 
+        void GlobalFixer_new::previsit(const ast::ObjectDecl * objDecl) {
+                auto mutDecl = mutate(objDecl);
+                assertf(mutDecl == objDecl, "Global object decl must be unique");
+                if ( auto ctorInit = objDecl->init.as<ast::ConstructorInit>() ) {
+                        // 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 );
+                                // ctorInit->dtor = nullptr;
+                        } // if
+                        if ( const ast::Stmt * ctor = ctorInit->ctor ) {
+                                initStmts.push_back( ctor );
+                                mutDecl->init = nullptr;
+                                // ctorInit->ctor = nullptr;
+                        } else if ( const ast::Init * init = ctorInit->init ) {
+                                mutDecl->init = init;
+                                // ctorInit->init = nullptr;
+                        } else {
+                                // no constructor and no initializer, which is okay
+                                mutDecl->init = nullptr;
+                        } // if
+                        // delete ctorInit;
+                } // if
+        }
+
         // only modify global variables
         void GlobalFixer::previsit( FunctionDecl * ) { visit_children = false; }

src/InitTweak/FixGlobalInit.h

@@ -19 +19 @@
 #include <string>  // for string
 
+#include <AST/Fwd.hpp>
+
+
 class Declaration;
 
@@ -26 +29 @@
         /// function is for library code.
         void fixGlobalInit( std::list< Declaration * > & translationUnit, bool inLibrary );
+        void fixGlobalInit( ast::TranslationUnit & translationUnit, bool inLibrary );
 } // namespace
 

src/InitTweak/FixInit.cc

@@ -219 +219 @@
                 };
 
-                struct SplitExpressions : public WithShortCircuiting, public WithTypeSubstitution, public WithStmtsToAdd {
+                struct SplitExpressions : public WithShortCircuiting, /*public WithTypeSubstitution, */public WithStmtsToAdd {
                         /// add CompoundStmts around top-level expressions so that temporaries are destroyed in the correct places.
                         static void split( std::list< Declaration * > &translationUnit );
@@ -802 +802 @@
                                 if ( Statement * ctor = ctorInit->get_ctor() ) {
                                         if ( objDecl->get_storageClasses().is_static ) {
+
+                                                // The ojbect needs to go in the data section, regardless of dtor complexity below.
+                                                // The attribute works, and is meant to apply, both for leaving the static local alone,
+                                                // and for hoisting it out as a static global.
+                                                addDataSectonAttribute( objDecl );
+
                                                 // originally wanted to take advantage of gcc nested functions, but
                                                 // we get memory errors with this approach. To remedy this, the static

src/InitTweak/FixInit.h

@@ -20 +20 @@
 
 class Declaration;
+namespace ast {
+        class TranslationUnit;
+}
 
 namespace InitTweak {
         /// replace constructor initializers with expression statements and unwrap basic C-style initializers
         void fix( std::list< Declaration * > & translationUnit, bool inLibrary );
+
+        void fix( ast::TranslationUnit & translationUnit, bool inLibrary);
 } // namespace
 

src/InitTweak/GenInit.cc

@@ -283 +283 @@
                 assert( stmts.size() <= 1 );
                 return stmts.size() == 1 ? strict_dynamic_cast< ImplicitCtorDtorStmt * >( stmts.front() ) : nullptr;
+
+        }
+
+        ast::ptr<ast::Stmt> genCtorDtor (const CodeLocation & loc, const std::string & fname, const ast::ObjectDecl * objDecl, const ast::Expr * arg) {
+                assertf(objDecl, "genCtorDtor passed null objDecl");
+                InitExpander_new srcParam(arg);
+                return SymTab::genImplicitCall(srcParam, new ast::VariableExpr(loc, objDecl), loc, fname, objDecl);
         }
 

src/InitTweak/GenInit.h

@@ -33 +33 @@
         /// generates a single ctor/dtor statement using objDecl as the 'this' parameter and arg as the optional argument
         ImplicitCtorDtorStmt * genCtorDtor( const std::string & fname, ObjectDecl * objDecl, Expression * arg = nullptr );
+        ast::ptr<ast::Stmt> genCtorDtor (const CodeLocation & loc, const std::string & fname, const ast::ObjectDecl * objDecl, const ast::Expr * arg = nullptr);
 
         /// creates an appropriate ConstructorInit node which contains a constructor, destructor, and C-initializer

src/InitTweak/InitTweak.cc

@@ -498 +498 @@
         }
 
+        const ast::ObjectDecl * getParamThis(const ast::FunctionDecl * func) {
+                assertf( func, "getParamThis: nullptr ftype" );
+                auto & params = func->params;
+                assertf( ! params.empty(), "getParamThis: ftype with 0 parameters: %s", toString( func ).c_str());
+                return params.front().strict_as<ast::ObjectDecl>();
+        }
+
         bool tryConstruct( DeclarationWithType * dwt ) {
                 ObjectDecl * objDecl = dynamic_cast< ObjectDecl * >( dwt );
@@ -511 +518 @@
         }
 
+        bool tryConstruct( const ast::DeclWithType * dwt ) {
+                auto objDecl = dynamic_cast< const ast::ObjectDecl * >( dwt );
+                if ( ! objDecl ) return false;
+                return (objDecl->init == nullptr ||
+                                ( objDecl->init != nullptr && objDecl->init->maybeConstructed ))
+                        && ! objDecl->storage.is_extern
+                        && isConstructable( objDecl->type );
+        }
+
+        bool isConstructable( const ast::Type * type ) {
+                return ! dynamic_cast< const ast::VarArgsType * >( type ) && ! dynamic_cast< const ast::ReferenceType * >( type ) 
+                && ! dynamic_cast< const ast::FunctionType * >( type ) && ! Tuples::isTtype( type );
+        }
+
         struct CallFinder_old {
                 CallFinder_old( const std::list< std::string > & names ) : names( names ) {}
@@ -536 +557 @@
 
         struct CallFinder_new final {
-                std::vector< ast::ptr< ast::Expr > > matches;
+                std::vector< const ast::Expr * > matches;
                 const std::vector< std::string > names;
 
@@ -558 +579 @@
         }
 
-        std::vector< ast::ptr< ast::Expr > > collectCtorDtorCalls( const ast::Stmt * stmt ) {
+        std::vector< const ast::Expr * > collectCtorDtorCalls( const ast::Stmt * stmt ) {
                 ast::Pass< CallFinder_new > finder{ std::vector< std::string >{ "?{}", "^?{}" } };
                 maybe_accept( stmt, finder );
@@ -696 +717 @@
                 template <typename Predicate>
                 bool allofCtorDtor( const ast::Stmt * stmt, const Predicate & pred ) {
-                        std::vector< ast::ptr< ast::Expr > > callExprs = collectCtorDtorCalls( stmt );
+                        std::vector< const ast::Expr * > callExprs = collectCtorDtorCalls( stmt );
                         return std::all_of( callExprs.begin(), callExprs.end(), pred );
                 }
@@ -939 +960 @@
         }
 
+        // looks like some other such codegen uses UntypedExpr and does not create fake function. should revisit afterwards
+        // following passes may accidentally resolve this expression if returned as untyped...
+        ast::Expr * createBitwiseAssignment (const ast::Expr * dst, const ast::Expr * src) {
+                static ast::ptr<ast::FunctionDecl> assign = nullptr;
+                if (!assign) {
+                        auto td = new ast::TypeDecl({}, "T", {}, nullptr, ast::TypeDecl::Dtype, true);
+                        assign = new ast::FunctionDecl({}, "?=?", {}, 
+                        { new ast::ObjectDecl({}, "_dst", new ast::ReferenceType(new ast::TypeInstType("T", td))),
+                          new ast::ObjectDecl({}, "_src", new ast::TypeInstType("T", td))},
+                        { new ast::ObjectDecl({}, "_ret", new ast::TypeInstType("T", td))}, nullptr, {}, ast::Linkage::Intrinsic);
+                }
+                if (dst->result.as<ast::ReferenceType>()) {
+                        for (int depth = dst->result->referenceDepth(); depth > 0; depth--) {
+                                dst = new ast::AddressExpr(dst);
+                        }
+                }
+                else {
+                        dst = new ast::CastExpr(dst, new ast::ReferenceType(dst->result, {}));
+                }
+                if (src->result.as<ast::ReferenceType>()) {
+                        for (int depth = src->result->referenceDepth(); depth > 0; depth--) {
+                                src = new ast::AddressExpr(src);
+                        }
+                }
+                return new ast::ApplicationExpr(dst->location, ast::VariableExpr::functionPointer(dst->location, assign), {dst, src});
+        }
+
         struct ConstExprChecker : public WithShortCircuiting {
                 // most expressions are not const expr
@@ -1055 +1103 @@
                 return isCopyFunction( decl, "?{}" );
         }
+
+        void addDataSectonAttribute( ObjectDecl * objDecl ) {
+                Type *strLitT = new PointerType( Type::Qualifiers( ),
+                        new BasicType( Type::Qualifiers( ), BasicType::Char ) );
+                std::list< Expression * > attr_params;
+                attr_params.push_back( 
+                        new ConstantExpr( Constant( strLitT, "\".data#\"", std::nullopt ) ) );
+                objDecl->attributes.push_back(new Attribute("section", attr_params));
+        }
+
 }

src/InitTweak/InitTweak.h

@@ -38 +38 @@
         /// returns the first parameter of a constructor/destructor/assignment function
         ObjectDecl * getParamThis( FunctionType * ftype );
+        const ast::ObjectDecl * getParamThis(const ast::FunctionDecl * func);
 
         /// generate a bitwise assignment operation.
         ApplicationExpr * createBitwiseAssignment( Expression * dst, Expression * src );
+
+        ast::Expr * createBitwiseAssignment( const ast::Expr * dst, const ast::Expr * src);
 
         /// transform Initializer into an argument list that can be passed to a call expression
@@ -48 +51 @@
         /// True if the resolver should try to construct dwt
         bool tryConstruct( DeclarationWithType * dwt );
+        bool tryConstruct( const ast::DeclWithType * dwt );
 
         /// True if the type can have a user-defined constructor
         bool isConstructable( Type * t );
+        bool isConstructable( const ast::Type * t );
 
         /// True if the Initializer contains designations
@@ -79 +84 @@
         /// get all Ctor/Dtor call expressions from a Statement
         void collectCtorDtorCalls( Statement * stmt, std::list< Expression * > & matches );
-        std::vector< ast::ptr< ast::Expr > > collectCtorDtorCalls( const ast::Stmt * stmt );
+        std::vector< const ast::Expr * > collectCtorDtorCalls( const ast::Stmt * stmt );
 
         /// get the Ctor/Dtor call expression from a Statement that looks like a generated ctor/dtor call
@@ -102 +107 @@
         bool isConstExpr( Expression * expr );
         bool isConstExpr( Initializer * init );
+
+        /// Modifies objDecl to have:
+        ///    __attribute__((section (".data#")))
+        /// which makes gcc put the declared variable in the data section,
+        /// which is helpful for global constants on newer gcc versions,
+        /// so that CFA's generated initialization won't segfault when writing it via a const cast.
+        /// The trailing # is an injected assembly comment, to suppress the "a" in
+        ///    .section .data,"a"
+        ///    .section .data#,"a"
+        /// to avoid assembler warning "ignoring changed section attributes for .data"
+        void addDataSectonAttribute( ObjectDecl * objDecl );
 
         class InitExpander_old {

src/InitTweak/module.mk

@@ -23 +23 @@
         InitTweak/GenInit.h \
         InitTweak/InitTweak.cc \
-        InitTweak/InitTweak.h
+        InitTweak/InitTweak.h \
+        InitTweak/FixInitNew.cpp
 
 SRCDEMANGLE += \