Changeset d8a3073 for src/Validate/Autogen.cpp

Timestamp:

Apr 26, 2026, 5:46:08 PM (6 weeks ago)

Author:

Matthew Au-Yeung <mw2auyeu@…>

Branches:

stuck-waitfor-destruct

Parents:

88bb0b4

git-author:

Matthew Au-Yeung <mw2auyeu@…> (04/26/26 17:44:48)

git-committer:

Matthew Au-Yeung <mw2auyeu@…> (04/26/26 17:46:08)

Message:

Set top level autogen cfa_linkonce

• Remove default static and inline
• Add pass to autogen functions in lib to have default visibility
• Add fix for union ctor with array constructor passing pointer to array instead of array itself. Previous changes brought light the compilation error.
• Note: found compilation trying to invoke union operator with array in cfa

File:

• src/Validate/Autogen.cpp (modified) (4 diffs)

src/Validate/Autogen.cpp

@@ -352 +352 @@
         replaceAll( assertions, oldToNew );
 
+        bool isTopLevel = ( 0 == functionNesting );
+        bool isCfaLinkage = getDecl()->linkage.is_mangled;
+
+        ast::Storage::Classes storage = ast::Storage::Classes(); // Default no static
+        ast::Function::Specs funcSpec; // Default no inline
+        std::vector<ast::ptr<ast::Attribute>> attributes;
+        if ( !isTopLevel ) {
+                // Nested: use inline, no linkonce needed for local types.
+                funcSpec = ast::Function::Specs( ast::Function::Inline );
+        } else if ( isCfaLinkage ) {
+                // Top-level CFA type: use linkonce for cross-TU deduplication.
+                attributes.push_back( new ast::Attribute( "cfa_linkonce" ) );
+        } else {
+                // Top-level C type: keep original static inline to avoid
+                // exposing latent issues in auto-generated code for system types.
+                storage = ast::Storage::Static;
+                funcSpec = ast::Function::Specs( ast::Function::Inline );
+        }
+
         ast::FunctionDecl * decl = new ast::FunctionDecl(
                 // Auto-generated routines use the type declaration's location.
@@ -362 +381 @@
                 // Only a prototype, no body.
                 nullptr,
-                // Use static storage if we are at the top level.
-                (0 < functionNesting) ? ast::Storage::Classes() : ast::Storage::Static,
+                storage,
                 proto_linkage,
-                std::vector<ast::ptr<ast::Attribute>>(),
-                // Auto-generated routines are inline to avoid conflicts.
-                ast::Function::Specs( ast::Function::Inline ) );
+                std::move( attributes ),
+                funcSpec );
         decl->fixUniqueId();
         return decl;
@@ -401 +418 @@
                 add_qualifiers( dst->type, ast::CV::Qualifiers( ast::CV::Mutex ) );
         }
-
-        ast::FunctionDecl * decl = genProto( "^?{}", { dst }, {} );
-        // For concurrent types, remove static storage and inline specifier, and add
-        // cfa_linkonce attribute so the destructor has linkonce semantics.
-        // This is required to share the same function pointer across TUs.
-        if ( isConcurrentType() ) {
-                auto mut = ast::mutate( decl );
-                mut->storage = ast::Storage::Classes();
-                mut->funcSpec = ast::Function::Specs();
-                mut->attributes.push_back( new ast::Attribute( "cfa_linkonce" ) );
-        }
-        return decl;
+        return genProto( "^?{}", { dst }, {} );
 }
 
@@ -697 +703 @@
                         new ast::AddressExpr( location,
                                 new ast::VariableExpr( location, dstParam ) ),
-                        new ast::AddressExpr( location,
-                                new ast::VariableExpr( location, srcParam ) ),
+                        // For array types, the parameter decays to a pointer, so the
+                        // variable already points to the data. For other types, take &src.
+                        dynamic_cast<const ast::ArrayType *>( srcParam->type.get() )
+                                ? (ast::Expr *)new ast::CastExpr( location,
+                                        new ast::VariableExpr( location, srcParam ),
+                                        new ast::PointerType( new ast::VoidType() ) )
+                                : (ast::Expr *)new ast::AddressExpr( location,
+                                        new ast::VariableExpr( location, srcParam ) ),
                         new ast::SizeofExpr( location, srcParam->type ),
                 } ) );