Changeset 4da6a6c

Timestamp:

Mar 14, 2017, 3:14:56 PM (7 years ago)

Author:

Thierry Delisle <tdelisle@…>

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:

2f26687a, 3831b58, e61a35e

Parents:

026bb82 (diff), 08d5507b (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

Files:

• CodeGen/CodeGenerator.cc (modified) (2 diffs)
• GenPoly/Box.cc (modified) (2 diffs)
• InitTweak/FixGlobalInit.cc (modified) (3 diffs)
• InitTweak/FixInit.cc (modified) (6 diffs)
• InitTweak/GenInit.cc (modified) (2 diffs)
• InitTweak/InitTweak.cc (modified) (1 diff)
• Parser/DeclarationNode.cc (modified) (12 diffs)
• Parser/ParseNode.h (modified) (4 diffs)
• SymTab/Autogen.cc (modified) (3 diffs)
• SymTab/Indexer.cc (modified) (2 diffs)

src/CodeGen/CodeGenerator.cc

@@ -10 +10 @@
 // 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 +895 @@
 
         void CodeGenerator::handleStorageClass( DeclarationWithType * decl ) {
-                if ( decl->get_storageClasses().any() ) {
+                if ( decl->get_storageClasses().val != 0 ) {
                         DeclarationNode::print_StorageClass( output, decl->get_storageClasses() );
                 } // if

src/GenPoly/Box.cc

@@ -10 +10 @@
 // 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 +299 @@
                 // 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;

src/InitTweak/FixGlobalInit.cc

@@ -10 +10 @@
 // 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 +87 @@
                         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 +143 @@
 // compile-command: "make install" //
 // End: //
-

src/InitTweak/FixInit.cc

@@ -10 +10 @@
 // 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 +678 @@
                                 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 +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::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 +731 @@
 
                                                         // 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 +764 @@
                                                         // 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 +821 @@
                 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

src/InitTweak/GenInit.cc

@@ -10 +10 @@
 // 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 +186 @@
                 // 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 ) ) {

src/InitTweak/InitTweak.cc

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

src/Parser/DeclarationNode.cc

@@ -10 +10 @@
 // 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 +90 @@
         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 +117 @@
 
 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 +127 @@
 
 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 +202 @@
 
 
-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 +459 @@
         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 +469 @@
 
 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 +477 @@
         } // 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 +485 @@
                         } // 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 +496 @@
 
 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 +1058 @@
                 //    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 +1068 @@
         //    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

src/Parser/ParseNode.h

@@ -10 +10 @@
 // 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 +204 @@
         // 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 +252 @@
         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 +350 @@
         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 );

src/SymTab/Autogen.cc

@@ -10 +10 @@
 // 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 +162 @@
                 // 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 +720 @@
                                         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() );

src/SymTab/Indexer.cc

@@ -10 +10 @@
 // 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 +738 @@
                                 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