Changeset f9cebb5

Timestamp:

Aug 4, 2016, 4:10:06 PM (9 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

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

Children:

4819cac

Parents:

73bf8cf2

Message:

add gcc attributes to ObjectDecl?, hoist destructed static variables, add breaks to end of generated switch

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (2 diffs)
• InitTweak/FixGlobalInit.cc (modified) (1 diff)
• InitTweak/FixInit.cc (modified) (7 diffs)
• InitTweak/GenInit.cc (modified) (2 diffs)
• InitTweak/InitTweak.cc (modified) (7 diffs)
• InitTweak/InitTweak.h (modified) (1 diff)
• Parser/TypeData.cc (modified) (1 diff)
• ResolvExpr/Resolver.cc (modified) (1 diff)
• SymTab/Autogen.h (modified) (6 diffs)
• SynTree/Declaration.cc (modified) (2 diffs)
• SynTree/Declaration.h (modified) (6 diffs)
• SynTree/DeclarationWithType.cc (modified) (1 diff)
• SynTree/FunctionDecl.cc (modified) (4 diffs)
• SynTree/Label.h (modified) (1 diff)
• SynTree/ObjectDecl.cc (modified) (3 diffs)

src/CodeGen/CodeGenerator.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : 
+// Last Modified By :
 // Last Modified On : Sun Jul 31 08:42:18 2016
 // Update Count     : 345
@@ -148 +148 @@
         void CodeGenerator::visit( ObjectDecl *objectDecl ) {
                 extension( objectDecl );
+                genAttributes( objectDecl->get_attributes() );
+
                 handleStorageClass( objectDecl );
                 output << genType( objectDecl->get_type(), mangleName( objectDecl ) );

src/InitTweak/FixGlobalInit.cc

@@ -107 +107 @@
 
                         Statement * dtor = ctorInit->get_dtor();
-                        if ( dtor && ! isInstrinsicSingleArgCallStmt( dtor ) ) {
+                        if ( dtor && ! isIntrinsicSingleArgCallStmt( dtor ) ) {
                                 // don't need to call intrinsic dtor, because it does nothing, but
                                 // non-intrinsic dtors must be called

src/InitTweak/FixInit.cc

@@ -26 +26 @@
 #include "SynTree/Type.h"
 #include "SynTree/Expression.h"
+#include "SynTree/Attribute.h"
 #include "SynTree/Statement.h"
 #include "SynTree/Initializer.h"
@@ -208 +209 @@
                                 try {
                                         *i = maybeMutate( *i, fixer );
-                                        // if (! fixer.staticDtorDecls.empty() ) {
-                                                translationUnit.splice( i, fixer.staticDtorDecls );
-                                        // }
+                                        translationUnit.splice( i, fixer.staticDtorDecls );
                                 } catch( SemanticError &e ) {
                                         errors.append( e );
@@ -446 +445 @@
                                         if ( objDecl->get_storageClass() == DeclarationNode::Static ) {
                                                 // originally wanted to take advantage of gcc nested functions, but
-                                                // we get memory errors with this approach. To remedy this, create a
-                                                // global static pointer that is set to refer to the object and make
-                                                // the dtor-caller function global so that.
+                                                // we get memory errors with this approach. To remedy this, the static
+                                                // variable is hoisted when the destructor needs to be called.
                                                 //
                                                 // generate:
-                                                // T * __objName_static_ptrN;
+                                                // static T __objName_static_varN;
                                                 // void __objName_dtor_atexitN() {
-                                                //   __dtor(__objName_static_ptrN);
+                                                //   __dtor__...;
                                                 // }
                                                 // int f(...) {
                                                 //   ...
-                                                //   static T __objName;
                                                 //   static bool __objName_uninitialized = true;
                                                 //   if (__objName_uninitialized) {
-                                                //     __objName_ptr = &__objName;
                                                 //     __ctor(__objName);
-                                                //     on_exit(__objName_dtor_atexitN, &__objName);
                                                 //     __objName_uninitialized = false;
+                                                //     atexit(__objName_dtor_atexitN);
                                                 //   }
                                                 //   ...
                                                 // }
 
-                                                static UniqueName ptrNamer( "_static_ptr" );
                                                 static UniqueName dtorCallerNamer( "_dtor_atexit" );
-
-                                                // T * __objName_ptrN
-                                                ObjectDecl * objPtr = new ObjectDecl( objDecl->get_mangleName() + ptrNamer.newName(), DeclarationNode::Static, LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), objDecl->get_type()->clone() ), 0 );
-                                                objPtr->fixUniqueId();
-
-                                                // void __objName_dtor_atexitN(...) {...}
-                                                // need to modify dtor call so that it refers to objPtr, since function will be global
-                                                Statement * dtorStmt = ctorInit->get_dtor()->clone();
-                                                ApplicationExpr * dtor = dynamic_cast< ApplicationExpr * >( InitTweak::getCtorDtorCall( dtorStmt ) );
-                                                assert( dtor );
-                                                delete dtor->get_args().front();
-                                                dtor->get_args().front() = new VariableExpr( objPtr );
-
-                                                FunctionDecl * dtorCaller = new FunctionDecl( objDecl->get_mangleName() + dtorCallerNamer.newName(), DeclarationNode::Static, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ), false, false );
-                                                dtorCaller->fixUniqueId();
-                                                dtorCaller->get_statements()->get_kids().push_back( dtorStmt );
 
                                                 // static bool __objName_uninitialized = true
@@ -493 +472 @@
                                                 isUninitializedVar->fixUniqueId();
 
-                                                // __objName_static_ptrN = &__objName;
-                                                UntypedExpr * ptrAssign = new UntypedExpr( new NameExpr( "?=?" ) );
-                                                ptrAssign->get_args().push_back( new VariableExpr( objPtr ) );
-                                                ptrAssign->get_args().push_back( new AddressExpr( new VariableExpr( objDecl ) ) );
-
-                                                // atexit(dtor_atexit);
-                                                UntypedExpr * callAtexit = new UntypedExpr( new NameExpr( "atexit" ) );
-                                                callAtexit->get_args().push_back( new VariableExpr( dtorCaller ) );
-
                                                 // __objName_uninitialized = false;
                                                 UntypedExpr * setTrue = new UntypedExpr( new NameExpr( "?=?" ) );
@@ -511 +481 @@
                                                 std::list< Statement * > & body = initStmts->get_kids();
                                                 body.push_back( ctor );
-                                                body.push_back( new ExprStmt( noLabels, ptrAssign ) );
-                                                body.push_back( new ExprStmt( noLabels, callAtexit ) );
                                                 body.push_back( new ExprStmt( noLabels, setTrue ) );
 
@@ -520 +488 @@
                                                 stmtsToAddAfter.push_back( ifStmt );
 
-                                                // add pointer and dtor caller decls to list of decls that will be added into global scope
-                                                staticDtorDecls.push_back( objPtr );
-                                                staticDtorDecls.push_back( dtorCaller );
+                                                if ( ctorInit->get_dtor() ) {
+                                                        // if the object has a non-trivial destructor, have to
+                                                        // hoist it and the object into the global space and
+                                                        // call the destructor function with atexit.
+
+                                                        Statement * dtorStmt = ctorInit->get_dtor()->clone();
+
+                                                        // 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 ), false, false );
+                                                        dtorCaller->fixUniqueId();
+                                                        dtorCaller->get_statements()->get_kids().push_back( dtorStmt );
+
+                                                        // atexit(dtor_atexit);
+                                                        UntypedExpr * callAtexit = new UntypedExpr( new NameExpr( "atexit" ) );
+                                                        callAtexit->get_args().push_back( new VariableExpr( dtorCaller ) );
+
+                                                        body.push_back( new ExprStmt( noLabels, callAtexit ) );
+
+                                                        // hoist variable and dtor caller decls to list of decls that will be added into global scope
+                                                        staticDtorDecls.push_back( objDecl );
+                                                        staticDtorDecls.push_back( dtorCaller );
+
+                                                        // need to rename object uniquely since it now appears
+                                                        // at global scope and there could be multiple function-scoped
+                                                        // static variables with the same name in different functions.
+                                                        static UniqueName staticNamer( "_static_var" );
+                                                        objDecl->set_mangleName( objDecl->get_mangleName() + staticNamer.newName() );
+
+                                                        objDecl->set_init( NULL );
+                                                        ctorInit->set_ctor( NULL );
+                                                        delete ctorInit;
+
+                                                        // xxx - temporary hack: need to return a declaration, but want to hoist the current object out of this scope
+                                                        // 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") } );
+                                                        return dummy;
+                                                }
                                         } else {
                                                 stmtsToAddAfter.push_back( ctor );
@@ -582 +585 @@
                                         assert( ! ctorInit->get_ctor() || ! ctorInit->get_init() );
                                         Statement * dtor = ctorInit->get_dtor();
-                                        if ( dtor && ! isInstrinsicSingleArgCallStmt( dtor ) ) {
+                                        if ( dtor && ! isIntrinsicSingleArgCallStmt( dtor ) ) {
                                                 // don't need to call intrinsic dtor, because it does nothing, but
                                                 // non-intrinsic dtors must be called

src/InitTweak/GenInit.cc

@@ -172 +172 @@
                 // if in function, generate const size_t var
                 static UniqueName dimensionName( "_array_dim" );
+
+                // 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 ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
-                        if ( ! inFunction ) return;
-
                         if ( ! arrayType->get_dimension() ) return; // xxx - recursive call to hoist?
 
@@ -203 +207 @@
                 CtorDtor ctordtor;
                 mutateAll( translationUnit, ctordtor );
-        }
-
-        namespace {
-                Expression * makeCtorDtorExpr( std::string name, ObjectDecl * objDecl, std::list< Expression * > args ) {
-                        UntypedExpr * expr = new UntypedExpr( new NameExpr( name ) );
-                        expr->get_args().push_back( new AddressExpr( new VariableExpr( objDecl ) ) );
-                        expr->get_args().splice( expr->get_args().end(), args );
-                        return expr;
-                }
         }
 

src/InitTweak/InitTweak.cc

@@ -5 +5 @@
 #include "SynTree/Initializer.h"
 #include "SynTree/Expression.h"
+#include "SynTree/Attribute.h"
 #include "GenPoly/GenPoly.h"
 
@@ -125 +126 @@
 
         namespace {
+                /// given index i, dimension d, initializer init, and callExpr f, generates
+                ///   if (i < d) f(..., init)
+                ///   ++i;
+                /// so that only elements within the range of the array are constructed
                 template< typename OutIterator >
-                void dothething( UntypedExpr * callExpr, Expression * index, Expression * dimension, Initializer * init, OutIterator out ) {
+                void buildCallExpr( UntypedExpr * callExpr, Expression * index, Expression * dimension, Initializer * init, OutIterator out ) {
                         UntypedExpr * cond = new UntypedExpr( new NameExpr( "?<?") );
                         cond->get_args().push_back( index->clone() );
@@ -148 +153 @@
                         Expression * dimension = *idx++;
 
+                        // xxx - may want to eventually issue a warning here if we can detect
+                        // that the number of elements exceeds to dimension of the array
                         if ( idx == idxEnd ) {
                                 if ( ListInit * listInit = dynamic_cast< ListInit * >( init ) ) {
                                         for ( Initializer * init : *listInit ) {
-                                                dothething( callExpr->clone(), index, dimension, init, out );
+                                                buildCallExpr( callExpr->clone(), index, dimension, init, out );
                                         }
                                 } else {
-                                        dothething( callExpr->clone(), index, dimension, init, out );
+                                        buildCallExpr( callExpr->clone(), index, dimension, init, out );
                                 }
                         } else {
@@ -166 +173 @@
                                         throw SemanticError( "unbalanced list initializers" );
                                 }
+
+                                static UniqueName targetLabel( "L__autogen__" );
+                                Label switchLabel( targetLabel.newName(), 0, std::list< Attribute * >{ new Attribute("unused") } );
                                 for ( Initializer * init : *listInit ) {
                                         Expression * condition;
@@ -178 +188 @@
                                         std::list< Statement * > stmts;
                                         build( callExpr, idx, idxEnd, init, back_inserter( stmts ) );
+                                        stmts.push_back( new BranchStmt( noLabels, switchLabel, BranchStmt::Break ) );
                                         CaseStmt * caseStmt = new CaseStmt( noLabels, condition, stmts );
                                         branches.push_back( caseStmt );
                                 }
                                 *out++ = new SwitchStmt( noLabels, index->clone(), branches );
+                                *out++ = new NullStmt( std::list<Label>{ switchLabel } );
                         }
                 }
@@ -194 +206 @@
         Statement * InitImpl::buildListInit( UntypedExpr * dst, std::list< Expression * > & indices ) {
                 if ( ! init ) return NULL;
-                std::list< Statement * > results;
-                build( dst, indices.begin(), indices.end(), init, back_inserter( results ) );
-                assert( results.size() <= 1 );
-                if ( results.empty() ) {
+                CompoundStmt * block = new CompoundStmt( noLabels );
+                build( dst, indices.begin(), indices.end(), init, back_inserter( block->get_kids() ) );
+                if ( block->get_kids().empty() ) {
+                        delete block;
                         return NULL;
                 } else {
                         init = NULL; // init was consumed in creating the list init
-                        return results.front();
-                }
-                return ! results.empty() ? results.front() : NULL;
+                        return block;
+                }
         }
 
@@ -280 +291 @@
         }
 
-        bool isInstrinsicSingleArgCallStmt( Statement * stmt ) {
+        bool isIntrinsicSingleArgCallStmt( Statement * stmt ) {
                 std::list< Expression * > callExprs;
                 collectCtorDtorCalls( stmt, callExprs );

src/InitTweak/InitTweak.h

@@ -41 +41 @@
         /// Intended to be used for default ctor/dtor calls, but might have use elsewhere.
         /// Currently has assertions that make it less than fully general.
-        bool isInstrinsicSingleArgCallStmt( Statement * expr );
+        bool isIntrinsicSingleArgCallStmt( Statement * expr );
 
         /// get all Ctor/Dtor call expressions from a Statement

src/Parser/TypeData.cc

@@ -510 +510 @@
                 return buildVariable();
         } else {
-                return new ObjectDecl( name, sc, linkage, bitfieldWidth, build(), init, isInline, isNoreturn );
+                return new ObjectDecl( name, sc, linkage, bitfieldWidth, build(), init, std::list< Attribute * >(),  isInline, isNoreturn );
         } // if
         return 0;

src/ResolvExpr/Resolver.cc

@@ -534 +534 @@
                 // implicitly generated, there's no way for it to have side effects, so get rid of it
                 // to clean up generated code.
-                if ( InitTweak::isInstrinsicSingleArgCallStmt( ctorInit->get_ctor() ) ) {
+                if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->get_ctor() ) ) {
                         delete ctorInit->get_ctor();
                         ctorInit->set_ctor( NULL );
                 }
-                if ( InitTweak::isInstrinsicSingleArgCallStmt( ctorInit->get_dtor() ) ) {
+
+                // xxx - todo
+                // if ( InitTweak::isIntrinsicCallStmt( ctorInit->get_ctor() ) ) {
+                //      // can reduce the constructor down to a SingleInit using the
+                //      // second argument from the ctor call
+                // }
+
+                if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->get_dtor() ) ) {
                         delete ctorInit->get_dtor();
                         ctorInit->set_dtor( NULL );

src/SymTab/Autogen.h

@@ -37 +37 @@
         /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls.
         template< typename OutputIterator >
-        void genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false, bool forward = true );
+        Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false, bool forward = true );
 
         /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Should only be called with non-array types.
+        /// optionally returns a statement which must be inserted prior to the containing loop, if there is one
         template< typename OutputIterator >
-        void genScalarCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false ) {
+        Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false ) {
                 // want to be able to generate assignment, ctor, and dtor generically,
                 // so fname is either ?=?, ?{}, or ^?{}
@@ -63 +64 @@
                 fExpr->get_args().push_back( dstParam );
 
-    Statement * listInit = srcParam.buildListInit( fExpr );
-    if ( listInit ) {
-      *out++ = listInit;
-    }
+                Statement * listInit = srcParam.buildListInit( fExpr );
 
-    std::list< Expression * > args = *++srcParam;
-    fExpr->get_args().splice( fExpr->get_args().end(), args );
+                std::list< Expression * > args = *++srcParam;
+                fExpr->get_args().splice( fExpr->get_args().end(), args );
 
                 *out++ = new ExprStmt( noLabels, fExpr );
 
-    srcParam.clearArrayIndices();
+                srcParam.clearArrayIndices();
+
+                return listInit;
         }
 
@@ -125 +125 @@
                 srcParam.addArrayIndex( new VariableExpr( index ), array->get_dimension()->clone() );
 
-                // if ( srcParam ) {
-                //      UntypedExpr *srcIndex = new UntypedExpr( new NameExpr( "?[?]" ) );
-                //      srcIndex->get_args().push_back( srcParam );
-                //      srcIndex->get_args().push_back( new VariableExpr( index ) );
-                //      srcParam = srcIndex;
-                // }
-
                 // for stmt's body, eventually containing call
                 CompoundStmt * body = new CompoundStmt( noLabels );
-                genCall( srcParam, dstParam, fname, back_inserter( body->get_kids() ), array->get_base(), addCast, forward );
+                Statement * listInit = genCall( srcParam, dstParam, fname, back_inserter( body->get_kids() ), array->get_base(), addCast, forward );
 
                 // block containing for stmt and index variable
@@ -140 +133 @@
                 CompoundStmt * block = new CompoundStmt( noLabels );
                 block->get_kids().push_back( new DeclStmt( noLabels, index ) );
+                if ( listInit ) block->get_kids().push_back( listInit );
                 block->get_kids().push_back( new ForStmt( noLabels, initList, cond, inc, body ) );
 
@@ -146 +140 @@
 
         template< typename OutputIterator >
-        void genCall( InitTweak::InitExpander &  srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast, bool forward ) {
+        Statement * genCall( InitTweak::InitExpander &  srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast, bool forward ) {
                 if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
                         genArrayCall( srcParam, dstParam, fname, out, at, addCast, forward );
+                        return 0;
                 } else {
-                        genScalarCall( srcParam, dstParam, fname, out, type, addCast );
+                        return genScalarCall( srcParam, dstParam, fname, out, type, addCast );
                 }
         }
@@ -171 +166 @@
                 // currently genCall should produce at most one element, but if that changes then the next line needs to be updated to grab the statement which contains the call
                 assert( stmts.size() <= 1 );
-    if ( stmts.size() == 1 ) {
-                Statement * callStmt = stmts.front();
-                if ( addCast ) {
-                        // implicitly generated ctor/dtor calls should be wrapped
-                        // so that later passes are aware they were generated.
-                        // xxx - don't mark as an implicit ctor/dtor if obj is a bitfield,
-                        // because this causes the address to be taken at codegen, which is illegal in C.
-                        callStmt = new ImplicitCtorDtorStmt( callStmt );
-                }
-                *out++ = callStmt;
-    }
+                if ( stmts.size() == 1 ) {
+                        Statement * callStmt = stmts.front();
+                        if ( addCast ) {
+                                // implicitly generated ctor/dtor calls should be wrapped
+                                // so that later passes are aware they were generated.
+                                // xxx - don't mark as an implicit ctor/dtor if obj is a bitfield,
+                                // because this causes the address to be taken at codegen, which is illegal in C.
+                                callStmt = new ImplicitCtorDtorStmt( callStmt );
+                        }
+                        *out++ = callStmt;
+                }
         }
 } // namespace SymTab

src/SynTree/Declaration.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Declaration.cc -- 
+// Declaration.cc --
 //
 // Author           : Richard C. Bilson
@@ -20 +20 @@
 #include "Initializer.h"
 #include "Type.h"
+#include "Attribute.h"
 #include "Common/utility.h"
 

src/SynTree/Declaration.h

@@ -64 +64 @@
 class DeclarationWithType : public Declaration {
   public:
-        DeclarationWithType( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Type linkage );
+        DeclarationWithType( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Type linkage, const std::list< Attribute * > & attributes );
         DeclarationWithType( const DeclarationWithType &other );
         virtual ~DeclarationWithType();
@@ -75 +75 @@
         int get_scopeLevel() const { return scopeLevel; }
         void set_scopeLevel( int newValue ) { scopeLevel = newValue; }
+
+        std::list< Attribute * >& get_attributes() { return attributes; }
+        const std::list< Attribute * >& get_attributes() const { return attributes; }
 
         virtual DeclarationWithType *clone() const = 0;
@@ -87 +90 @@
         // shadowed identifiers can be accessed
         int scopeLevel = 0;
+
+        std::list< Attribute * > attributes;
 };
 
@@ -92 +97 @@
         typedef DeclarationWithType Parent;
   public:
-        ObjectDecl( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Type linkage, Expression *bitfieldWidth, Type *type, Initializer *init, bool isInline = false, bool isNoreturn = false );
+        ObjectDecl( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Type linkage, Expression *bitfieldWidth, Type *type, Initializer *init, const std::list< Attribute * > attributes = std::list< Attribute * >(), bool isInline = false, bool isNoreturn = false );
         ObjectDecl( const ObjectDecl &other );
         virtual ~ObjectDecl();
@@ -131 +136 @@
         std::list< std::string >& get_oldIdents() { return oldIdents; }
         std::list< Declaration* >& get_oldDecls() { return oldDecls; }
-        std::list< Attribute * >& get_attributes() { return attributes; }
 
         virtual FunctionDecl *clone() const { return new FunctionDecl( *this ); }
@@ -143 +147 @@
         std::list< std::string > oldIdents;
         std::list< Declaration* > oldDecls;
-        std::list< Attribute * > attributes;
 };
 

src/SynTree/DeclarationWithType.cc

@@ -16 +16 @@
 #include "Declaration.h"
 #include "Type.h"
+#include "Attribute.h"
 #include "Common/utility.h"
 
-DeclarationWithType::DeclarationWithType( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Type linkage )
-                : Declaration( name, sc, linkage ) {
+DeclarationWithType::DeclarationWithType( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Type linkage, const std::list< Attribute * > & attributes )
+                : Declaration( name, sc, linkage ), attributes( attributes ) {
 }
 
 DeclarationWithType::DeclarationWithType( const DeclarationWithType &other )
                 : Declaration( other ), mangleName( other.mangleName ), scopeLevel( other.scopeLevel ) {
+        cloneAll( other.attributes, attributes );
 }
 
 DeclarationWithType::~DeclarationWithType() {
+        deleteAll( attributes );
 }
 

src/SynTree/FunctionDecl.cc

@@ -23 +23 @@
 
 FunctionDecl::FunctionDecl( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Type linkage, FunctionType *type, CompoundStmt *statements, bool isInline, bool isNoreturn, std::list< Attribute * > attributes )
-                : Parent( name, sc, linkage ), type( type ), statements( statements ), attributes( attributes ) {
+                : Parent( name, sc, linkage, attributes ), type( type ), statements( statements ) {
         set_isInline( isInline );
         set_isNoreturn( isNoreturn );
@@ -34 +34 @@
 FunctionDecl::FunctionDecl( const FunctionDecl &other )
         : Parent( other ), type( maybeClone( other.type ) ), statements( maybeClone( other.statements ) ) {
-                cloneAll( other.attributes, attributes );
 }
 
@@ -40 +39 @@
         delete type;
         delete statements;
-        deleteAll( attributes );
 }
 
@@ -69 +67 @@
         } // if
 
-        printAll( attributes, os, indent );
+        printAll( get_attributes(), os, indent );
 
         if ( get_storageClass() != DeclarationNode::NoStorageClass ) {

src/SynTree/Label.h

@@ -24 +24 @@
 class Label {
   public:
-        Label( const std::string & name = "", Statement * labelled = 0 ) : name( name ), labelled( labelled ) {}
+        Label( const std::string & name = "", Statement * labelled = 0, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : name( name ), labelled( labelled ), attributes( attributes ) {}
         Label( const char * name, Statement * labelled = 0 ) : name( name ), labelled( labelled ) {}
 

src/SynTree/ObjectDecl.cc

@@ -18 +18 @@
 #include "Initializer.h"
 #include "Expression.h"
+#include "Attribute.h"
 #include "Common/utility.h"
 #include "Statement.h"
 
-ObjectDecl::ObjectDecl( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Type linkage, Expression *bitfieldWidth, Type *type, Initializer *init, bool isInline, bool isNoreturn )
-        : Parent( name, sc, linkage ), type( type ), init( init ), bitfieldWidth( bitfieldWidth ) {
+ObjectDecl::ObjectDecl( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Type linkage, Expression *bitfieldWidth, Type *type, Initializer *init, const std::list< Attribute * > attributes, bool isInline, bool isNoreturn )
+        : Parent( name, sc, linkage, attributes ), type( type ), init( init ), bitfieldWidth( bitfieldWidth ) {
         set_isInline( isInline );
         set_isNoreturn( isNoreturn );
@@ -45 +46 @@
                 os << LinkageSpec::toString( get_linkage() ) << " ";
         } // if
+
+        printAll( get_attributes(), os, indent );
 
         if ( get_storageClass() != DeclarationNode::NoStorageClass ) {
@@ -80 +83 @@
         } // if
 
+        // xxx - should printShort print attributes?
+
         if ( get_storageClass() != DeclarationNode::NoStorageClass ) {
                 os << DeclarationNode::storageName[ get_storageClass() ] << ' ';