Index: src/CodeGen/CodeGenerator.cc =================================================================== --- src/CodeGen/CodeGenerator.cc (revision 68ac32ea18da20c419e6bf09e1ae72348b4ac166) +++ src/CodeGen/CodeGenerator.cc (revision 08d5507b99eb502f8fb69133c61233301ed6b029) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun Mar 5 17:13:33 2017 -// Update Count : 475 +// Last Modified On : Mon Mar 13 23:56:59 2017 +// Update Count : 477 // @@ -895,5 +895,5 @@ void CodeGenerator::handleStorageClass( DeclarationWithType * decl ) { - if ( decl->get_storageClasses().any() ) { + if ( decl->get_storageClasses().val != 0 ) { DeclarationNode::print_StorageClass( output, decl->get_storageClasses() ); } // if Index: src/GenPoly/Box.cc =================================================================== --- src/GenPoly/Box.cc (revision 68ac32ea18da20c419e6bf09e1ae72348b4ac166) +++ src/GenPoly/Box.cc (revision 08d5507b99eb502f8fb69133c61233301ed6b029) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Mar 6 23:45:59 2017 -// Update Count : 330 +// Last Modified On : Tue Mar 14 07:45:29 2017 +// Update Count : 334 // @@ -299,7 +299,7 @@ // because each unit generates copies of the default routines for each aggregate. FunctionDecl *layoutDecl = new FunctionDecl( layoutofName( typeDecl ), - functionNesting > 0 ? DeclarationNode::StorageClasses() : DeclarationNode::StorageClasses( DeclarationNode::StaticClass ), + functionNesting > 0 ? DeclarationNode::StorageClasses() : DeclarationNode::StorageClasses( DeclarationNode::Static ), LinkageSpec::AutoGen, layoutFnType, new CompoundStmt( noLabels ), - std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::InlineSpec ) ); + std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::Inline ) ); layoutDecl->fixUniqueId(); return layoutDecl; Index: src/InitTweak/FixGlobalInit.cc =================================================================== --- src/InitTweak/FixGlobalInit.cc (revision 68ac32ea18da20c419e6bf09e1ae72348b4ac166) +++ src/InitTweak/FixGlobalInit.cc (revision 08d5507b99eb502f8fb69133c61233301ed6b029) @@ -10,6 +10,6 @@ // Created On : Mon May 04 15:14:56 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Mar 6 23:14:19 2017 -// Update Count : 14 +// Last Modified On : Mon Mar 13 23:58:27 2017 +// Update Count : 16 // @@ -87,7 +87,7 @@ dtorParameters.push_back( new ConstantExpr( Constant::from_int( 102 ) ) ); } - initFunction = new FunctionDecl( "_init_" + fixedName, DeclarationNode::StorageClasses( DeclarationNode::StaticClass ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) ); + initFunction = new FunctionDecl( "_init_" + fixedName, DeclarationNode::StorageClasses( DeclarationNode::Static ), 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::StorageClasses( DeclarationNode::StaticClass ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) ); + destroyFunction = new FunctionDecl( "_destroy_" + fixedName, DeclarationNode::StorageClasses( DeclarationNode::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) ); destroyFunction->get_attributes().push_back( new Attribute( "destructor", dtorParameters ) ); } @@ -143,3 +143,2 @@ // compile-command: "make install" // // End: // - Index: src/InitTweak/FixInit.cc =================================================================== --- src/InitTweak/FixInit.cc (revision 68ac32ea18da20c419e6bf09e1ae72348b4ac166) +++ src/InitTweak/FixInit.cc (revision 08d5507b99eb502f8fb69133c61233301ed6b029) @@ -10,6 +10,6 @@ // Created On : Wed Jan 13 16:29:30 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Mar 7 07:51:40 2017 -// Update Count : 59 +// Last Modified On : Tue Mar 14 08:05:28 2017 +// Update Count : 63 // @@ -678,5 +678,5 @@ assert( ! ctorInit->get_ctor() || ! ctorInit->get_init() ); if ( Statement * ctor = ctorInit->get_ctor() ) { - if ( objDecl->get_storageClasses()[ DeclarationNode::Static ] ) { + if ( objDecl->get_storageClasses().is_static ) { // originally wanted to take advantage of gcc nested functions, but // we get memory errors with this approach. To remedy this, the static @@ -704,5 +704,5 @@ 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::StorageClasses( DeclarationNode::StaticClass ), LinkageSpec::Cforall, 0, boolType, boolInitExpr ); + ObjectDecl * isUninitializedVar = new ObjectDecl( objDecl->get_mangleName() + "_uninitialized", DeclarationNode::StorageClasses( DeclarationNode::Static ), LinkageSpec::Cforall, 0, boolType, boolInitExpr ); isUninitializedVar->fixUniqueId(); @@ -731,5 +731,5 @@ // void __objName_dtor_atexitN(...) {...} - FunctionDecl * dtorCaller = new FunctionDecl( objDecl->get_mangleName() + dtorCallerNamer.newName(), DeclarationNode::StorageClasses( DeclarationNode::StaticClass ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) ); + FunctionDecl * dtorCaller = new FunctionDecl( objDecl->get_mangleName() + dtorCallerNamer.newName(), DeclarationNode::StorageClasses( DeclarationNode::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) ); dtorCaller->fixUniqueId(); dtorCaller->get_statements()->push_back( dtorStmt ); @@ -764,5 +764,5 @@ // create a new object which is never used static UniqueName dummyNamer( "_dummy" ); - 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") } ); + ObjectDecl * dummy = new ObjectDecl( dummyNamer.newName(), DeclarationNode::StorageClasses( DeclarationNode::Static ), LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), 0, std::list< Attribute * >{ new Attribute("unused") } ); return dummy; } @@ -821,5 +821,5 @@ void InsertDtors::visit( ObjectDecl * objDecl ) { // remember non-static destructed objects so that their destructors can be inserted later - if ( ! objDecl->get_storageClasses()[ DeclarationNode::Static ] ) { + if ( ! objDecl->get_storageClasses().is_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 Index: src/InitTweak/GenInit.cc =================================================================== --- src/InitTweak/GenInit.cc (revision 68ac32ea18da20c419e6bf09e1ae72348b4ac166) +++ src/InitTweak/GenInit.cc (revision 08d5507b99eb502f8fb69133c61233301ed6b029) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Mar 7 07:51:38 2017 -// Update Count : 179 +// Last Modified On : Mon Mar 13 23:59:09 2017 +// Update Count : 180 // @@ -186,5 +186,5 @@ // C doesn't allow variable sized arrays at global scope or for static variables, so don't hoist dimension. if ( ! inFunction ) return; - if ( storageClasses[ DeclarationNode::StaticClass] ) return; + if ( storageClasses.is_static ) return; if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) { Index: src/InitTweak/InitTweak.cc =================================================================== --- src/InitTweak/InitTweak.cc (revision 68ac32ea18da20c419e6bf09e1ae72348b4ac166) +++ src/InitTweak/InitTweak.cc (revision 08d5507b99eb502f8fb69133c61233301ed6b029) @@ -260,5 +260,5 @@ (objDecl->get_init() == NULL || ( objDecl->get_init() != NULL && objDecl->get_init()->get_maybeConstructed() )) - && ! objDecl->get_storageClasses()[ DeclarationNode::Extern ]; + && ! objDecl->get_storageClasses().is_extern; } Index: src/Parser/DeclarationNode.cc =================================================================== --- src/Parser/DeclarationNode.cc (revision 68ac32ea18da20c419e6bf09e1ae72348b4ac166) +++ src/Parser/DeclarationNode.cc (revision 08d5507b99eb502f8fb69133c61233301ed6b029) @@ -10,6 +10,6 @@ // Created On : Sat May 16 12:34:05 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Mar 7 17:28:56 2017 -// Update Count : 937 +// Last Modified On : Tue Mar 14 10:19:38 2017 +// Update Count : 964 // @@ -90,6 +90,6 @@ newnode->type = maybeClone( type ); newnode->storageClasses = storageClasses; + newnode->funcSpecs = funcSpecs; newnode->bitfieldWidth = maybeClone( bitfieldWidth ); - newnode->funcSpecs = funcSpecs; newnode->enumeratorValue.reset( maybeClone( enumeratorValue.get() ) ); newnode->hasEllipsis = hasEllipsis; @@ -117,5 +117,5 @@ void DeclarationNode::print_StorageClass( std::ostream & output, StorageClasses storageClasses ) { - if ( storageClasses.any() ) { // function specifiers? + if ( storageClasses.val != 0 ) { // storage classes ? for ( unsigned int i = 0; i < DeclarationNode::NoStorageClass; i += 1 ) { if ( storageClasses[i] ) { @@ -127,5 +127,5 @@ void DeclarationNode::print_FuncSpec( std::ostream & output, DeclarationNode::FuncSpecifiers funcSpec ) { - if ( funcSpec.any() ) { // function specifiers? + if ( funcSpec.val != 0 ) { // function specifiers ? for ( unsigned int i = 0; i < DeclarationNode::NoFuncSpecifier; i += 1 ) { if ( funcSpec[i] ) { @@ -202,13 +202,13 @@ -DeclarationNode * DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) { - DeclarationNode * newnode = new DeclarationNode; - newnode->storageClasses[ sc ] = true; +DeclarationNode * DeclarationNode::newStorageClass( DeclarationNode::StorageClasses sc ) { + DeclarationNode * newnode = new DeclarationNode; + newnode->storageClasses = sc; return newnode; } // DeclarationNode::newStorageClass -DeclarationNode * DeclarationNode::newFuncSpecifier( DeclarationNode::FuncSpecifier fs ) { - DeclarationNode * newnode = new DeclarationNode; - newnode->funcSpecs[ fs ] = true; +DeclarationNode * DeclarationNode::newFuncSpecifier( DeclarationNode::FuncSpecifiers fs ) { + DeclarationNode * newnode = new DeclarationNode; + newnode->funcSpecs = fs; return newnode; } // DeclarationNode::newFuncSpecifier @@ -459,6 +459,6 @@ const TypeData::TypeQualifiers qsrc = src->typeQualifiers, qdst = dst->typeQualifiers; // optimization - if ( (qsrc & qdst).any() ) { // common qualifier ? - for ( unsigned int i = 0; i < NoTypeQualifier; i += 1 ) { // find common qualifiers + if ( (qsrc & qdst).any() ) { // duplicates ? + for ( unsigned int i = 0; i < NoTypeQualifier; i += 1 ) { // find duplicates if ( qsrc[i] && qdst[i] ) { appendError( error, string( "duplicate " ) + DeclarationNode::typeQualifierNames[i] ); @@ -469,6 +469,6 @@ void DeclarationNode::checkSpecifiers( DeclarationNode * src ) { - if ( (funcSpecs & src->funcSpecs).any() ) { // common specifier ? - for ( unsigned int i = 0; i < NoFuncSpecifier; i += 1 ) { // find common specifier + if ( (funcSpecs.val & src->funcSpecs.val) != 0 ) { // duplicates ? + for ( unsigned int i = 0; i < NoFuncSpecifier; i += 1 ) { // find duplicates if ( funcSpecs[i] && src->funcSpecs[i] ) { appendError( error, string( "duplicate " ) + DeclarationNode::funcSpecifierNames[i] ); @@ -477,6 +477,6 @@ } // if - if ( storageClasses != 0 && src->storageClasses != 0 ) { // any reason to check ? - if ( (storageClasses & src->storageClasses).any() ) { // duplicates ? + if ( storageClasses.val != 0 && src->storageClasses.val != 0 ) { // any reason to check ? + if ( (storageClasses.val & src->storageClasses.val ) != 0 ) { // duplicates ? for ( unsigned int i = 0; i < NoStorageClass; i += 1 ) { // find duplicates if ( storageClasses[i] && src->storageClasses[i] ) { @@ -485,8 +485,8 @@ } // for // src is the new item being added and has a single bit - } else if ( ! src->storageClasses[ Threadlocal ] ) { // conflict ? - appendError( error, string( "conflicting " ) + storageClassNames[ffs( storageClasses.to_ulong() ) - 1] + - " & " + storageClassNames[ffs( src->storageClasses.to_ulong() ) - 1] ); - src->storageClasses.reset(); // FIX to preserve invariant of one basic storage specifier + } else if ( ! src->storageClasses.is_threadlocal ) { // conflict ? + appendError( error, string( "conflicting " ) + storageClassNames[ffs( storageClasses.val ) - 1] + + " & " + storageClassNames[ffs( src->storageClasses.val ) - 1] ); + src->storageClasses.val = 0; // FIX to preserve invariant of one basic storage specifier } // if } // if @@ -496,6 +496,6 @@ DeclarationNode * DeclarationNode::copySpecifiers( DeclarationNode * q ) { - funcSpecs = funcSpecs | q->funcSpecs; - storageClasses = storageClasses | q->storageClasses; + funcSpecs.val = funcSpecs.val | q->funcSpecs.val; + storageClasses.val = storageClasses.val | q->storageClasses.val; for ( Attribute *attr: reverseIterate( q->attributes ) ) { @@ -1058,5 +1058,5 @@ // inline _Noreturn int g( int i ); // allowed // inline _Noreturn int i; // disallowed - if ( type->kind != TypeData::Function && funcSpecs.any() ) { + if ( type->kind != TypeData::Function && funcSpecs.val != 0 ) { throw SemanticError( "invalid function specifier for ", this ); } // if @@ -1068,5 +1068,5 @@ // inlne _Noreturn struct S { ... }; // disallowed // inlne _Noreturn enum E { ... }; // disallowed - if ( funcSpecs.any() ) { + if ( funcSpecs.val != 0 ) { throw SemanticError( "invalid function specifier for ", this ); } // if Index: src/Parser/ParseNode.h =================================================================== --- src/Parser/ParseNode.h (revision 68ac32ea18da20c419e6bf09e1ae72348b4ac166) +++ src/Parser/ParseNode.h (revision 08d5507b99eb502f8fb69133c61233301ed6b029) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:28:16 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Mar 7 08:10:53 2017 -// Update Count : 726 +// Last Modified On : Tue Mar 14 11:05:05 2017 +// Update Count : 752 // @@ -204,8 +204,32 @@ // These must remain in the same order as the corresponding DeclarationNode names. - enum StorageClass { Extern, Static, Auto, Register, Threadlocal, NoStorageClass, - ExternClass = 1 << Extern, StaticClass = 1 << Static, AutoClass = 1 << Auto, RegisterClass = 1 << Register, ThreadlocalClass = 1 << Threadlocal }; - enum FuncSpecifier { Inline, Noreturn, Fortran, NoFuncSpecifier, - InlineSpec = 1 << Inline, NoreturnSpec = 1 << Noreturn, FortranSpec = 1 << Fortran }; + enum { Extern = 1 << 0, Static = 1 << 1, Auto = 1 << 2, Register = 1 << 3, Threadlocal = 1 << 4, NoStorageClass = 5 }; + union StorageClasses { + unsigned int val; + struct { + bool is_extern : 1; + bool is_static : 1; + bool is_auto : 1; + bool is_register : 1; + bool is_threadlocal : 1; + }; + StorageClasses() : val( 0 ) {} + StorageClasses( unsigned int val ) : val( val ) {} + bool operator[]( unsigned int i ) const { return val & (1 << i); } + }; // StorageClasses + + enum { Inline = 1 << 0, Noreturn = 1 << 1, Fortran = 1 << 2, NoFuncSpecifier = 3 }; + union FuncSpecifiers { + unsigned int val; + struct { + bool is_inline : 1; + bool is_noreturn : 1; + bool is_fortran : 1; + }; + FuncSpecifiers() : val( 0 ) {} + FuncSpecifiers( unsigned int val ) : val( val ) {} + bool operator[]( unsigned int i ) const { return val & (1 << i); } + }; // FuncSpecifiers + enum TypeQualifier { Const, Restrict, Volatile, Lvalue, Mutex, Atomic, NoTypeQualifier }; enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, NoBasicType }; @@ -228,6 +252,6 @@ static const char * builtinTypeNames[]; - static DeclarationNode * newStorageClass( StorageClass ); - static DeclarationNode * newFuncSpecifier( FuncSpecifier ); + static DeclarationNode * newStorageClass( StorageClasses ); + static DeclarationNode * newFuncSpecifier( FuncSpecifiers ); static DeclarationNode * newTypeQualifier( TypeQualifier ); static DeclarationNode * newBasicType( BasicType ); @@ -326,9 +350,7 @@ TypeData * type; - typedef std::bitset< DeclarationNode::NoStorageClass > StorageClasses; StorageClasses storageClasses; static void print_StorageClass( std::ostream & output, StorageClasses storageClasses ); - typedef std::bitset< DeclarationNode::NoFuncSpecifier > FuncSpecifiers; FuncSpecifiers funcSpecs; static void print_FuncSpec( std::ostream & output, FuncSpecifiers funcSpecs ); Index: src/SymTab/Autogen.cc =================================================================== --- src/SymTab/Autogen.cc (revision 68ac32ea18da20c419e6bf09e1ae72348b4ac166) +++ src/SymTab/Autogen.cc (revision 08d5507b99eb502f8fb69133c61233301ed6b029) @@ -10,6 +10,6 @@ // Created On : Thu Mar 03 15:45:56 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Mar 7 07:42:44 2017 -// Update Count : 51 +// Last Modified On : Tue Mar 14 07:45:00 2017 +// Update Count : 54 // @@ -162,8 +162,8 @@ // because each unit generates copies of the default routines for each aggregate. // DeclarationNode::StorageClass sc = functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static; - DeclarationNode::StorageClasses scs = functionNesting > 0 ? DeclarationNode::StorageClasses() : DeclarationNode::StorageClasses( DeclarationNode::StaticClass ); + DeclarationNode::StorageClasses scs = functionNesting > 0 ? DeclarationNode::StorageClasses() : DeclarationNode::StorageClasses( DeclarationNode::Static ); LinkageSpec::Spec spec = isIntrinsic ? LinkageSpec::Intrinsic : LinkageSpec::AutoGen; FunctionDecl * decl = new FunctionDecl( fname, scs, spec, ftype, new CompoundStmt( noLabels ), - std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::InlineSpec ) ); + std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::Inline ) ); decl->fixUniqueId(); return decl; @@ -720,11 +720,11 @@ TypeInstType * inst = new TypeInstType( Type::Qualifiers(), newDecl->get_name(), newDecl ); newDecl->get_assertions().push_back( new FunctionDecl( "?=?", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, genAssignType( inst ), nullptr, - std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::InlineSpec ) ) ); + std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::Inline ) ) ); newDecl->get_assertions().push_back( new FunctionDecl( "?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, genDefaultType( inst ), nullptr, - std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::InlineSpec ) ) ); + std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::Inline ) ) ); newDecl->get_assertions().push_back( new FunctionDecl( "?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, genCopyType( inst ), nullptr, - std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::InlineSpec ) ) ); + std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::Inline ) ) ); newDecl->get_assertions().push_back( new FunctionDecl( "^?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, genDefaultType( inst ), nullptr, - std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::InlineSpec ) ) ); + std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::Inline ) ) ); typeParams.push_back( newDecl ); done.insert( ty->get_baseType() ); Index: src/SymTab/Indexer.cc =================================================================== --- src/SymTab/Indexer.cc (revision 68ac32ea18da20c419e6bf09e1ae72348b4ac166) +++ src/SymTab/Indexer.cc (revision 08d5507b99eb502f8fb69133c61233301ed6b029) @@ -10,6 +10,6 @@ // Created On : Sun May 17 21:37:33 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Mar 7 07:45:32 2017 -// Update Count : 16 +// Last Modified On : Tue Mar 14 08:07:34 2017 +// Update Count : 17 // @@ -738,5 +738,5 @@ ObjectDecl *newobj = dynamic_cast< ObjectDecl* >( added ); ObjectDecl *oldobj = dynamic_cast< ObjectDecl* >( existing ); - if ( ! newobj->get_storageClasses()[ DeclarationNode::Extern ] && ! oldobj->get_storageClasses()[ DeclarationNode::Extern ] ) { + if ( ! newobj->get_storageClasses().is_extern && ! oldobj->get_storageClasses().is_extern ) { throw SemanticError( "duplicate object definition for ", added ); } // if