Changeset 3ad5c50

Timestamp:

Mar 15, 2024, 10:01:27 PM (8 weeks ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

30aab55, 897eb01, d887800

Parents:

33807a1e (diff), 2583407 (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

File:

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

src/Parser/DeclarationNode.cc

@@ -502 +502 @@
 }
 
+// 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.
+static void moveUnionAttribute( DeclarationNode * decl, DeclarationNode * unionDecl ) {
+        assert( decl->type->kind == TypeData::Symbolic );
+        assert( decl->type->symbolic.isTypedef );
+        assert( unionDecl->type->kind == TypeData::Aggregate );
+
+        if ( unionDecl->type->aggregate.kind != ast::AggregateDecl::Union ) return;
+
+        // Ignore the Aggregate_t::attributes. Why did we add that before the rework?
+        for ( auto attr = decl->attributes.begin() ; attr != decl->attributes.end() ; ) {
+                if ( (*attr)->name == "transparent_union" || (*attr)->name == "__transparent_union__" ) {
+                        unionDecl->attributes.emplace_back( attr->release() );
+                        attr = decl->attributes.erase( attr );
+                } else {
+                        ++attr;
+                }
+        }
+}
+
+// Helper for addTypedef, handles the case where the typedef wraps an
+// aggregate declaration (not a type), returns a chain of nodes.
+static DeclarationNode * addTypedefAggr(
+                DeclarationNode * olddecl, TypeData * newtype ) {
+        TypeData *& oldaggr = olddecl->type->aggInst.aggregate;
+
+        // Handle anonymous aggregates: typedef struct { int i; } foo
+        // Give the typedefed type a consistent name across translation units.
+        if ( oldaggr->aggregate.anon ) {
+                delete oldaggr->aggregate.name;
+                oldaggr->aggregate.name = new string( "__anonymous_" + *olddecl->name );
+                oldaggr->aggregate.anon = false;
+                oldaggr->qualifiers.reset();
+        }
+
+        // Replace the wrapped TypeData with a forward declaration.
+        TypeData * newaggr = new TypeData( TypeData::Aggregate );
+        newaggr->aggregate.kind = oldaggr->aggregate.kind;
+        newaggr->aggregate.name = oldaggr->aggregate.name ? new string( *oldaggr->aggregate.name ) : nullptr;
+        newaggr->aggregate.body = false;
+        newaggr->aggregate.anon = oldaggr->aggregate.anon;
+        newaggr->aggregate.tagged = oldaggr->aggregate.tagged;
+        swap( newaggr, oldaggr );
+
+        newtype->base = olddecl->type;
+        olddecl->type = newtype;
+        DeclarationNode * newdecl = new DeclarationNode;
+        newdecl->type = newaggr;
+        newdecl->next = olddecl;
+
+        moveUnionAttribute( olddecl, newdecl );
+
+        return newdecl;
+}
+
+// Helper for addTypedef, handles the case where the typedef wraps an
+// enumeration declaration (not a type), returns a chain of nodes.
+static DeclarationNode * addTypedefEnum(
+                DeclarationNode * olddecl, TypeData * newtype ) {
+        TypeData *& oldenum = olddecl->type->aggInst.aggregate;
+
+        // Handle anonymous enumeration: typedef enum { A, B, C } foo
+        // Give the typedefed type a consistent name across translation units.
+        if ( oldenum->enumeration.anon ) {
+                delete oldenum->enumeration.name;
+                oldenum->enumeration.name = new string( "__anonymous_" + *olddecl->name );
+                oldenum->enumeration.anon = false;
+                oldenum->qualifiers.reset();
+        }
+
+        // Replace the wrapped TypeData with a forward declaration.
+        TypeData * newenum = new TypeData( TypeData::Enum );
+        newenum->enumeration.name = oldenum->enumeration.name ? new string( *oldenum->enumeration.name ) : nullptr;
+        newenum->enumeration.body = false;
+        newenum->enumeration.anon = oldenum->enumeration.anon;
+        newenum->enumeration.typed = oldenum->enumeration.typed;
+        newenum->enumeration.hiding = oldenum->enumeration.hiding;
+        swap( newenum, oldenum );
+
+        newtype->base = olddecl->type;
+        olddecl->type = newtype;
+        DeclarationNode * newdecl = new DeclarationNode;
+        newdecl->type = newenum;
+        newdecl->next = olddecl;
+
+        return newdecl;
+}
+
 DeclarationNode * DeclarationNode::addTypedef() {
         TypeData * newtype = new TypeData( TypeData::Symbolic );
@@ -507 +601 @@
         newtype->symbolic.isTypedef = true;
         newtype->symbolic.name = name ? new string( *name ) : nullptr;
-        newtype->base = type;
-        type = newtype;
-        return this;
+        // If this typedef is wrapping an aggregate, separate them out.
+        if ( TypeData::AggregateInst == type->kind
+                        && TypeData::Aggregate == type->aggInst.aggregate->kind
+                        && type->aggInst.aggregate->aggregate.body ) {
+                return addTypedefAggr( this, newtype );
+        // If this typedef is wrapping an enumeration, separate them out.
+        } else if ( TypeData::AggregateInst == type->kind
+                        && TypeData::Enum == type->aggInst.aggregate->kind
+                        && type->aggInst.aggregate->enumeration.body ) {
+                return addTypedefEnum( this, newtype );
+        // There is no internal declaration, just a type.
+        } else {
+                newtype->base = type;
+                type = newtype;
+                return this;
+        }
 }
 
@@ -711 +818 @@
 }
 
-// If a typedef wraps an anonymous declaration, name the inner declaration so it has a consistent name across
-// translation units.
-static void nameTypedefedDecl(
-                DeclarationNode * innerDecl,
-                const DeclarationNode * outerDecl ) {
-        TypeData * outer = outerDecl->type;
-        assert( outer );
-        // First make sure this is a typedef:
-        if ( outer->kind != TypeData::Symbolic || !outer->symbolic.isTypedef ) {
-                return;
-        }
-        TypeData * inner = innerDecl->type;
-        assert( inner );
-        // Always clear any CVs associated with the aggregate:
-        inner->qualifiers.reset();
-        // Handle anonymous aggregates: typedef struct { int i; } foo
-        if ( inner->kind == TypeData::Aggregate && inner->aggregate.anon ) {
-                delete inner->aggregate.name;
-                inner->aggregate.name = new string( "__anonymous_" + *outerDecl->name );
-                inner->aggregate.anon = false;
-                assert( outer->base );
-                delete outer->base->aggInst.aggregate->aggregate.name;
-                outer->base->aggInst.aggregate->aggregate.name = new string( "__anonymous_" + *outerDecl->name );
-                outer->base->aggInst.aggregate->aggregate.anon = false;
-                outer->base->aggInst.aggregate->qualifiers.reset();
-        // Handle anonymous enumeration: typedef enum { A, B, C } foo
-        } else if ( inner->kind == TypeData::Enum && inner->enumeration.anon ) {
-                delete inner->enumeration.name;
-                inner->enumeration.name = new string( "__anonymous_" + *outerDecl->name );
-                inner->enumeration.anon = false;
-                assert( outer->base );
-                delete outer->base->aggInst.aggregate->enumeration.name;
-                outer->base->aggInst.aggregate->enumeration.name = new string( "__anonymous_" + *outerDecl->name );
-                outer->base->aggInst.aggregate->enumeration.anon = false;
-                // No qualifiers.reset() here.
-        }
-}
-
-// 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.
-static void moveUnionAttribute( ast::Decl * decl, ast::UnionDecl * unionDecl ) {
-        if ( auto typedefDecl = dynamic_cast<ast::TypedefDecl *>( decl ) ) {
-                // Is the typedef alias a union aggregate?
-                if ( nullptr == unionDecl ) return;
-
-                // If typedef is an alias for a union, then its alias type was hoisted above and remembered.
-                if ( auto unionInstType = typedefDecl->base.as<ast::UnionInstType>() ) {
-                        auto instType = ast::mutate( unionInstType );
-                        // Remove all transparent_union attributes from typedef and move to alias union.
-                        for ( auto attr = instType->attributes.begin() ; attr != instType->attributes.end() ; ) {
-                                assert( *attr );
-                                if ( (*attr)->name == "transparent_union" || (*attr)->name == "__transparent_union__" ) {
-                                        unionDecl->attributes.emplace_back( attr->release() );
-                                        attr = instType->attributes.erase( attr );
-                                } else {
-                                        attr++;
-                                }
-                        }
-                        typedefDecl->base = instType;
-                }
-        }
-}
-
 // Get the non-anonymous name of the instance type of the declaration,
 // if one exists.
@@ -800 +838 @@
                 try {
                         bool extracted_named = false;
-                        ast::UnionDecl * unionDecl = nullptr;
 
                         if ( DeclarationNode * extr = cur->extractAggregate() ) {
                                 assert( cur->type );
-                                nameTypedefedDecl( extr, cur );
 
                                 if ( ast::Decl * decl = extr->build() ) {
-                                        // Remember the declaration if it is a union aggregate ?
-                                        unionDecl = dynamic_cast<ast::UnionDecl *>( decl );
-
                                         *out++ = decl;
 
@@ -828 +861 @@
 
                         if ( ast::Decl * decl = cur->build() ) {
-                                moveUnionAttribute( decl, unionDecl );
-
                                 if ( "" == decl->name && !cur->get_inLine() ) {
                                         // Don't include anonymous declaration for named aggregates,