Changeset a7c90d4 for src/InitTweak

Timestamp:

Mar 7, 2017, 8:33:43 AM (9 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

64cb860, c3396e0

Parents:

7fe2498

Message:

change StorageClass to bitset, support _Thread_local as separate storage-class

Location:

src/InitTweak

Files:

• FixGlobalInit.cc (modified) (2 diffs)
• FixInit.cc (modified) (11 diffs)
• GenInit.cc (modified) (4 diffs)
• InitTweak.cc (modified) (1 diff)

src/InitTweak/FixGlobalInit.cc

@@ -10 +10 @@
 // Created On       : Mon May 04 15:14:56 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Mar  3 21:55:33 2017
-// Update Count     : 9
+// Last Modified On : Mon Mar  6 23:14:19 2017
+// Update Count     : 14
 //
 
@@ -87 +87 @@
                         dtorParameters.push_back( new ConstantExpr( Constant::from_int( 102 ) ) );
                 }
-                initFunction = new FunctionDecl( "_init_" + fixedName, DeclarationNode::Static, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
+                initFunction = new FunctionDecl( "_init_" + fixedName, DeclarationNode::StorageClasses( DeclarationNode::StaticClass ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
                 initFunction->get_attributes().push_back( new Attribute( "constructor", ctorParameters ) );
-                destroyFunction = new FunctionDecl( "_destroy_" + fixedName, DeclarationNode::Static, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
+                destroyFunction = new FunctionDecl( "_destroy_" + fixedName, DeclarationNode::StorageClasses( DeclarationNode::StaticClass ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
                 destroyFunction->get_attributes().push_back( new Attribute( "destructor", dtorParameters ) );
         }

src/InitTweak/FixInit.cc

@@ -10 +10 @@
 // Created On       : Wed Jan 13 16:29:30 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Mar  3 21:56:11 2017
-// Update Count     : 39
+// Last Modified On : Tue Mar  7 07:51:40 2017
+// Update Count     : 59
 //
 
@@ -437 +437 @@
                         result = result->clone();
                         env->apply( result );
-                        ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result, 0 );
+                        ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, 0, result, 0 );
                         tmp->get_type()->set_isConst( false );
 
@@ -483 +483 @@
                                 result = result->clone();
                                 env->apply( result );
-                                ObjectDecl * ret = new ObjectDecl( retNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result, 0 );
+                                ObjectDecl * ret = new ObjectDecl( retNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, 0, result, 0 );
                                 ret->get_type()->set_isConst( false );
                                 impCpCtorExpr->get_returnDecls().push_back( ret );
@@ -506 +506 @@
                                 result = result->clone();
                                 env->apply( result );
-                                ObjectDecl * ret = new ObjectDecl( retNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result, 0 );
+                                ObjectDecl * ret = new ObjectDecl( retNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, 0, result, 0 );
                                 ret->get_type()->set_isConst( false );
                                 stmtExpr->get_returnDecls().push_front( ret );
@@ -538 +538 @@
                         } else {
                                 // expr isn't a call expr, so create a new temporary variable to use to hold the value of the unique expression
-                                unqExpr->set_object( new ObjectDecl( toString("_unq_expr_", unqExpr->get_id()), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, unqExpr->get_result()->clone(), nullptr ) );
+                                unqExpr->set_object( new ObjectDecl( toString("_unq_expr_", unqExpr->get_id()), DeclarationNode::StorageClasses(), LinkageSpec::C, nullptr, unqExpr->get_result()->clone(), nullptr ) );
                                 unqExpr->set_var( new VariableExpr( unqExpr->get_object() ) );
                         }
@@ -678 +678 @@
                                 assert( ! ctorInit->get_ctor() || ! ctorInit->get_init() );
                                 if ( Statement * ctor = ctorInit->get_ctor() ) {
-                                        if ( objDecl->get_storageClass() == DeclarationNode::Static ) {
+                                        if ( objDecl->get_storageClasses()[ DeclarationNode::Static ] ) {
                                                 // originally wanted to take advantage of gcc nested functions, but
                                                 // we get memory errors with this approach. To remedy this, the static
@@ -704 +704 @@
                                                 BasicType * boolType = new BasicType( Type::Qualifiers(), BasicType::Bool );
                                                 SingleInit * boolInitExpr = new SingleInit( new ConstantExpr( Constant( boolType->clone(), "1" ) ), noDesignators );
-                                                ObjectDecl * isUninitializedVar = new ObjectDecl( objDecl->get_mangleName() + "_uninitialized", DeclarationNode::Static, LinkageSpec::Cforall, 0, boolType, boolInitExpr );
+                                                ObjectDecl * isUninitializedVar = new ObjectDecl( objDecl->get_mangleName() + "_uninitialized", DeclarationNode::StorageClasses( DeclarationNode::StaticClass ), LinkageSpec::Cforall, 0, boolType, boolInitExpr );
                                                 isUninitializedVar->fixUniqueId();
 
@@ -731 +731 @@
 
                                                         // void __objName_dtor_atexitN(...) {...}
-                                                        FunctionDecl * dtorCaller = new FunctionDecl( objDecl->get_mangleName() + dtorCallerNamer.newName(), DeclarationNode::Static, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
+                                                        FunctionDecl * dtorCaller = new FunctionDecl( objDecl->get_mangleName() + dtorCallerNamer.newName(), DeclarationNode::StorageClasses( DeclarationNode::StaticClass ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
                                                         dtorCaller->fixUniqueId();
                                                         dtorCaller->get_statements()->push_back( dtorStmt );
@@ -764 +764 @@
                                                         // create a new object which is never used
                                                         static UniqueName dummyNamer( "_dummy" );
-                                                        ObjectDecl * dummy = new ObjectDecl( dummyNamer.newName(), DeclarationNode::Static, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), 0, std::list< Attribute * >{ new Attribute("unused") } );
+                                                        ObjectDecl * dummy = new ObjectDecl( dummyNamer.newName(), DeclarationNode::StorageClasses( DeclarationNode::StaticClass ), LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), 0, std::list< Attribute * >{ new Attribute("unused") } );
                                                         return dummy;
                                                 }
@@ -821 +821 @@
                 void InsertDtors::visit( ObjectDecl * objDecl ) {
                         // remember non-static destructed objects so that their destructors can be inserted later
-                        if ( objDecl->get_storageClass() != DeclarationNode::Static ) {
+                        if ( ! objDecl->get_storageClasses()[ DeclarationNode::Static ] ) {
                                 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
@@ -1118 +1118 @@
 
                         // xxx - ideally we would reuse the temporary generated from the copy constructor passes from within firstArg if it exists and not generate a temporary if it's unnecessary.
-                        ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, ctorExpr->get_result()->clone(), nullptr );
+                        ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, nullptr, ctorExpr->get_result()->clone(), nullptr );
                         addDeclaration( tmp );
 

src/InitTweak/GenInit.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb 16 14:57:53 2017
-// Update Count     : 167
+// Last Modified On : Tue Mar  7 07:51:38 2017
+// Update Count     : 179
 //
 
@@ -120 +120 @@
                 void hoist( Type * type );
 
-                DeclarationNode::StorageClass storageclass = DeclarationNode::NoStorageClass;
+                DeclarationNode::StorageClasses storageClasses;
                 bool inFunction = false;
         };
@@ -174 +174 @@
 
         DeclarationWithType * HoistArrayDimension::mutate( ObjectDecl * objectDecl ) {
-                storageclass = objectDecl->get_storageClass();
+                storageClasses = objectDecl->get_storageClasses();
                 DeclarationWithType * temp = Parent::mutate( objectDecl );
                 hoist( objectDecl->get_type() );
-                storageclass = DeclarationNode::NoStorageClass;
                 return temp;
         }
@@ -185 +184 @@
                 static UniqueName dimensionName( "_array_dim" );
 
-                // C doesn't allow variable sized arrays at global scope or for static variables,
-                // so don't hoist dimension.
+                // C doesn't allow variable sized arrays at global scope or for static variables, so don't hoist dimension.
                 if ( ! inFunction ) return;
-                if ( storageclass == DeclarationNode::Static ) return;
+                if ( storageClasses[ DeclarationNode::StaticClass] ) return;
 
                 if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
                         if ( ! arrayType->get_dimension() ) return; // xxx - recursive call to hoist?
 
-                        // don't need to hoist dimension if it's a constexpr - only need to if there's potential
-                        // for side effects.
+                        // don't need to hoist dimension if it's a constexpr - only need to if there's potential for side effects.
                         if ( isConstExpr( arrayType->get_dimension() ) ) return;
 
-                        ObjectDecl * arrayDimension = new ObjectDecl( dimensionName.newName(), storageclass, LinkageSpec::C, 0, SymTab::SizeType->clone(), new SingleInit( arrayType->get_dimension() ) );
+                        ObjectDecl * arrayDimension = new ObjectDecl( dimensionName.newName(), storageClasses, LinkageSpec::C, 0, SymTab::SizeType->clone(), new SingleInit( arrayType->get_dimension() ) );
                         arrayDimension->get_type()->set_isConst( true );
 

src/InitTweak/InitTweak.cc

@@ -260 +260 @@
                         (objDecl->get_init() == NULL ||
                                 ( objDecl->get_init() != NULL && objDecl->get_init()->get_maybeConstructed() ))
-                        && objDecl->get_storageClass() != DeclarationNode::Extern;
+                        && ! objDecl->get_storageClasses()[ DeclarationNode::Extern ];
         }