Changeset 692c1cc

Timestamp:

Feb 16, 2023, 4:44:53 PM (14 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, ast-experimental, master

Children:

14f6a3cb

Parents:

f8729be

Message:

update printing attributes, clean up anon flag setting, move attribute transparent_union from typedef to its union alias

File:

• src/Parser/DeclarationNode.cc (modified) (8 diffs)

src/Parser/DeclarationNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Aug  8 17:07:00 2022
-// Update Count     : 1185
+// Last Modified On : Thu Feb 16 14:12:03 2023
+// Update Count     : 1388
 //
 
@@ -154 +154 @@
         } // if
 
-        for ( Attribute * attr: reverseIterate( attributes ) ) {
-                os << string( indent + 2, ' ' ) << "attr " << attr->name.c_str();
-        } // for
+        if ( ! attributes.empty() ) {
+                os << string( indent + 2, ' ' ) << "with attributes " << endl;
+                for ( Attribute * attr: reverseIterate( attributes ) ) {
+                        os << string( indent + 4, ' ' ) << attr->name.c_str() << endl;
+                } // for
+        } // if
 
         os << endl;
@@ -244 +247 @@
         newnode->type = new TypeData( TypeData::Aggregate );
         newnode->type->aggregate.kind = kind;
-        newnode->type->aggregate.name = name == nullptr ? new string( DeclarationNode::anonymous.newName() ) : name;
+        newnode->type->aggregate.anon = name == nullptr;
+        newnode->type->aggregate.name = newnode->type->aggregate.anon ? new string( DeclarationNode::anonymous.newName() ) : name;
         newnode->type->aggregate.actuals = actuals;
         newnode->type->aggregate.fields = fields;
@@ -250 +254 @@
         newnode->type->aggregate.tagged = false;
         newnode->type->aggregate.parent = nullptr;
-        newnode->type->aggregate.anon = name == nullptr;
         return newnode;
 } // DeclarationNode::newAggregate
@@ -257 +260 @@
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Enum );
-        newnode->type->enumeration.name = name == nullptr ? new string( DeclarationNode::anonymous.newName() ) : name;
+        newnode->type->enumeration.anon = name == nullptr;
+        newnode->type->enumeration.name = newnode->type->enumeration.anon ? new string( DeclarationNode::anonymous.newName() ) : name;
         newnode->type->enumeration.constants = constants;
         newnode->type->enumeration.body = body;
-        newnode->type->enumeration.anon = name == nullptr;
         newnode->type->enumeration.typed = typed;
         newnode->type->enumeration.hiding = hiding;
@@ -989 +992 @@
         for ( const DeclarationNode * cur = firstNode; cur; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ) ) {
                 try {
-                        bool extracted = false;
-                        bool anon = false;
+                        bool extracted = false, anon = false;
+                        AggregateDecl * unionDecl = nullptr;
+
                         if ( DeclarationNode * extr = cur->extractAggregate() ) {
                                 // handle the case where a structure declaration is contained within an object or type declaration
+
                                 Declaration * decl = extr->build();
                                 if ( decl ) {
-                                        // hoist the structure declaration
+                                        // Remember the declaration if it is a union aggregate ?
+                                        unionDecl = dynamic_cast<UnionDecl *>( decl );
+
                                         decl->location = cur->location;
-                                        * out++ = decl;
+                                        *out++ = decl;
 
                                         // need to remember the cases where a declaration contains an anonymous aggregate definition
@@ -1003 +1010 @@
                                         assert( extr->type );
                                         if ( extr->type->kind == TypeData::Aggregate ) {
+                                                // typedef struct { int A } B is the only case?
                                                 anon = extr->type->aggregate.anon;
                                         } else if ( extr->type->kind == TypeData::Enum ) {
-                                                // xxx - is it useful to have an implicit anonymous enum member?
+                                                // typedef enum { A } B is the only case?
                                                 anon = extr->type->enumeration.anon;
                                         }
@@ -1014 +1022 @@
                         Declaration * decl = cur->build();
                         if ( decl ) {
+                                if ( TypedefDecl * typedefDecl = dynamic_cast<TypedefDecl *>( decl ) ) {
+                                        if ( unionDecl ) {                                      // is the typedef alias a union aggregate ?
+                                                // This code handles a special issue with the attribute transparent_union.
+                                                //
+                                                //    typedef union U { int i; } typedef_name __attribute__(( aligned(16) )) __attribute__(( transparent_union ))
+                                                //
+                                                // Here the attribute aligned goes with the typedef_name, so variables declared of this type are
+                                                // aligned.  However, the attribute transparent_union must be moved from the typedef_name to
+                                                // alias union U.  Currently, this is the only know attribute that must be moved from typedef to
+                                                // alias.
+
+                                                // If typedef is an alias for a union, then its alias type was hoisted above and remembered.
+                                                if ( UnionInstType * unionInstType = dynamic_cast<UnionInstType *>( typedefDecl->base ) ) {
+                                                        // Remove all transparent_union attributes from typedef and move to alias union.
+                                                        list<Attribute *>::iterator attr;
+                                                        for ( attr = unionInstType->attributes.begin(); attr != unionInstType->attributes.end(); ) { // forward order
+                                                                if ( (*attr)->name == "transparent_union" || (*attr)->name == "__transparent_union__" ) {
+                                                                        list<Attribute *>::iterator cur = attr; // remember current node
+                                                                        attr++;                         // advance iterator
+                                                                        unionDecl->attributes.emplace_back( *cur ); // move current
+                                                                        unionInstType->attributes.erase( cur ); // remove current
+                                                                } else {
+                                                                        attr++;                         // advance iterator
+                                                                } // if
+                                                        } // for
+                                                } // if
+                                        } // if
+                                } // if
+
                                 // don't include anonymous declaration for named aggregates, but do include them for anonymous aggregates, e.g.:
                                 // struct S {