Changes in src/InitTweak/FixGlobalInit.cc [f072892:a16764a6]

File:

• src/InitTweak/FixGlobalInit.cc (modified) (5 diffs)

src/InitTweak/FixGlobalInit.cc

@@ -37 +37 @@
         class GlobalFixer : public WithShortCircuiting {
           public:
-                GlobalFixer( bool inLibrary );
+                GlobalFixer( const std::string & name, bool inLibrary );
 
                 void previsit( ObjectDecl *objDecl );
@@ -52 +52 @@
         };
 
-        void fixGlobalInit( std::list< Declaration * > & translationUnit, bool inLibrary ) {
-                PassVisitor<GlobalFixer> visitor( inLibrary );
+        void fixGlobalInit( std::list< Declaration * > & translationUnit, const std::string & name, bool inLibrary ) {
+                PassVisitor<GlobalFixer> visitor( name, inLibrary );
                 acceptAll( translationUnit, visitor );
                 GlobalFixer & fixer = visitor.pass;
@@ -70 +70 @@
         }
 
-        GlobalFixer::GlobalFixer( bool inLibrary ) : tempNamer( "_global_init" ) {
+  std::string globalFunctionName( const std::string & name ) {
+        // get basename
+        std::string ret = name.substr( 0, name.find( '.' ) );
+        // replace invalid characters with _
+                static std::string invalid = "/-";
+        replace_if( ret.begin(), ret.end(), []( char c ) { return invalid.find(c) != std::string::npos; }, '_' );
+        return ret;
+  }
+
+        GlobalFixer::GlobalFixer( const std::string & name, bool inLibrary ) : tempNamer( "_global_init" ) {
+                std::string fixedName = globalFunctionName( name );
                 std::list< Expression * > ctorParameters;
                 std::list< Expression * > dtorParameters;
@@ -80 +90 @@
                         // for library code are run before constructors and destructors for user code,
                         // specify a priority when building the library. Priorities 0-100 are reserved by gcc.
-                        // Priorities 101-200 are reserved by cfa, so use priority 200 for CFA library globals,
-                        // allowing room for overriding with a higher priority.
-                        ctorParameters.push_back( new ConstantExpr( Constant::from_int( 200 ) ) );
-                        dtorParameters.push_back( new ConstantExpr( Constant::from_int( 200 ) ) );
+                        ctorParameters.push_back( new ConstantExpr( Constant::from_int( 102 ) ) );
+                        dtorParameters.push_back( new ConstantExpr( Constant::from_int( 102 ) ) );
                 }
-                initFunction = new FunctionDecl( "__global_init__", Type::StorageClasses( Type::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt() );
+                initFunction = new FunctionDecl( "_init_" + fixedName, Type::StorageClasses( Type::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt() );
                 initFunction->get_attributes().push_back( new Attribute( "constructor", ctorParameters ) );
-                destroyFunction = new FunctionDecl( "__global_destroy__", Type::StorageClasses( Type::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt() );
+                destroyFunction = new FunctionDecl( "_destroy_" + fixedName, Type::StorageClasses( Type::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt() );
                 destroyFunction->get_attributes().push_back( new Attribute( "destructor", dtorParameters ) );
         }
@@ -102 +110 @@
                 if ( ConstructorInit * ctorInit = dynamic_cast< ConstructorInit * >( objDecl->get_init() ) ) {
                         // a decision should have been made by the resolver, so ctor and init are not both non-NULL
-                        assert( ! ctorInit->ctor || ! ctorInit->init );
+                        assert( ! ctorInit->get_ctor() || ! ctorInit->get_init() );
 
-                        Statement * dtor = ctorInit->dtor;
+                        Statement * dtor = ctorInit->get_dtor();
                         if ( dtor && ! isIntrinsicSingleArgCallStmt( dtor ) ) {
                                 // don't need to call intrinsic dtor, because it does nothing, but
                                 // non-intrinsic dtors must be called
                                 destroyStatements.push_front( dtor );
-                                ctorInit->dtor = nullptr;
+                                ctorInit->set_dtor( NULL );
                         } // if
-                        if ( Statement * ctor = ctorInit->ctor ) {
+                        if ( Statement * ctor = ctorInit->get_ctor() ) {
                                 initStatements.push_back( ctor );
-                                objDecl->init = nullptr;
-                                ctorInit->ctor = nullptr;
-                        } else if ( Initializer * init = ctorInit->init ) {
-                                objDecl->init = init;
-                                ctorInit->init = nullptr;
+                                objDecl->set_init( NULL );
+                                ctorInit->set_ctor( NULL );
+                        } else if ( Initializer * init = ctorInit->get_init() ) {
+                                objDecl->set_init( init );
+                                ctorInit->set_init( NULL );
                         } else {
                                 // no constructor and no initializer, which is okay
-                                objDecl->init = nullptr;
+                                objDecl->set_init( NULL );
                         } // if
                         delete ctorInit;