Changeset c831073

Timestamp:

Apr 15, 2023, 4:53:13 PM (2 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, ast-experimental, master

Children:

6349929

Parents:

8a2f7f1 (diff), d859a30 (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:

• AST/Inspect.cpp (modified) (2 diffs)
• AST/Inspect.hpp (modified) (2 diffs)
• AST/SymbolTable.cpp (modified) (4 diffs)
• AST/SymbolTable.hpp (modified) (1 diff)
• InitTweak/FixInitNew.cpp (modified) (8 diffs)
• InitTweak/GenInit.cc (modified) (1 diff)
• SymTab/Autogen.cc (modified) (4 diffs)
• SymTab/Autogen.h (modified) (8 diffs)
• SymTab/GenImplicitCall.cpp (added)
• SymTab/GenImplicitCall.hpp (added)
• SymTab/module.mk (modified) (1 diff)
• Validate/Autogen.cpp (modified) (3 diffs)

src/AST/Inspect.cpp ¶

@@ -10 +10 @@
 // Created On       : Fri Jun 24 13:16:31 2022
 // Last Modified By : Andrew Beach
-// Last Modified On : Mon Oct  3 11:04:00 2022
-// Update Count     : 3
+// Last Modified On : Fri Apr 14 15:09:00 2023
+// Update Count     : 4
 //
 
@@ -168 +168 @@
 }
 
+bool isUnnamedBitfield( const ast::ObjectDecl * obj ) {
+        return obj && obj->name.empty() && obj->bitfieldWidth;
+}
+
 } // namespace ast

src/AST/Inspect.hpp ¶

@@ -10 +10 @@
 // Created On       : Fri Jun 24 13:16:31 2022
 // Last Modified By : Andrew Beach
-// Last Modified On : Thr Sep 22 13:44:00 2022
-// Update Count     : 2
+// Last Modified On : Fri Apr 14 15:09:00 2023
+// Update Count     : 3
 //
 
@@ -38 +38 @@
 const ApplicationExpr * isIntrinsicCallExpr( const Expr * expr );
 
+/// Returns true if obj's name is the empty string and it has a bitfield width.
+bool isUnnamedBitfield( const ObjectDecl * obj );
+
 }

src/AST/SymbolTable.cpp ¶

@@ -260 +260 @@
 void SymbolTable::addId( const DeclWithType * decl, const Expr * baseExpr ) {
         // default handling of conflicts is to raise an error
-        addId( decl, OnConflict::error(), baseExpr, decl->isDeleted ? decl : nullptr );
+        addIdCommon( decl, OnConflict::error(), baseExpr, decl->isDeleted ? decl : nullptr );
 }
 
 void SymbolTable::addDeletedId( const DeclWithType * decl, const Decl * deleter ) {
         // default handling of conflicts is to raise an error
-        addId( decl, OnConflict::error(), nullptr, deleter );
+        addIdCommon( decl, OnConflict::error(), nullptr, deleter );
 }
 
@@ -677 +677 @@
 }
 
-void SymbolTable::addId(
-                const DeclWithType * decl, SymbolTable::OnConflict handleConflicts, const Expr * baseExpr,
-                const Decl * deleter ) {
+void SymbolTable::addIdCommon(
+                const DeclWithType * decl, SymbolTable::OnConflict handleConflicts,
+                const Expr * baseExpr, const Decl * deleter ) {
         SpecialFunctionKind kind = getSpecialFunctionKind(decl->name);
         if (kind == NUMBER_OF_KINDS) { // not a special decl
-                addId(decl, decl->name, idTable, handleConflicts, baseExpr, deleter);
+                addIdToTable(decl, decl->name, idTable, handleConflicts, baseExpr, deleter);
         }
         else {
@@ -695 +695 @@
                         assertf(false, "special decl with non-function type");
                 }
-                addId(decl, key, specialFunctionTable[kind], handleConflicts, baseExpr, deleter);
-        }
-}
-
-void SymbolTable::addId(
-                const DeclWithType * decl, const std::string & lookupKey, IdTable::Ptr & table, SymbolTable::OnConflict handleConflicts, const Expr * baseExpr,
-                const Decl * deleter ) {
+                addIdToTable(decl, key, specialFunctionTable[kind], handleConflicts, baseExpr, deleter);
+        }
+}
+
+void SymbolTable::addIdToTable(
+                const DeclWithType * decl, const std::string & lookupKey,
+                IdTable::Ptr & table, SymbolTable::OnConflict handleConflicts,
+                const Expr * baseExpr, const Decl * deleter ) {
         ++*stats().add_calls;
         const std::string &name = decl->name;
@@ -778 +779 @@
 void SymbolTable::addMembers(
                 const AggregateDecl * aggr, const Expr * expr, SymbolTable::OnConflict handleConflicts ) {
-        for ( const Decl * decl : aggr->members ) {
-                if ( auto dwt = dynamic_cast< const DeclWithType * >( decl ) ) {
-                        addId( dwt, handleConflicts, expr );
-                        if ( dwt->name == "" ) {
-                                const Type * t = dwt->get_type()->stripReferences();
-                                if ( auto rty = dynamic_cast<const BaseInstType *>( t ) ) {
-                                        if ( ! dynamic_cast<const StructInstType *>(rty)
-                                                && ! dynamic_cast<const UnionInstType *>(rty) ) continue;
-                                        ResolvExpr::Cost cost = ResolvExpr::Cost::zero;
-                                        ast::ptr<ast::TypeSubstitution> tmp = expr->env;
-                                        expr = mutate_field(expr, &Expr::env, nullptr);
-                                        const Expr * base = ResolvExpr::referenceToRvalueConversion( expr, cost );
-                                        base = mutate_field(base, &Expr::env, tmp);
-
-                                        addMembers(
-                                                rty->aggr(), new MemberExpr{ base->location, dwt, base }, handleConflicts );
-                                }
-                        }
+        for ( const ptr<Decl> & decl : aggr->members ) {
+                auto dwt = decl.as<DeclWithType>();
+                if ( nullptr == dwt ) continue;
+                addIdCommon( dwt, handleConflicts, expr );
+                // Inline through unnamed struct/union members.
+                if ( "" != dwt->name ) continue;
+                const Type * t = dwt->get_type()->stripReferences();
+                if ( auto rty = dynamic_cast<const BaseInstType *>( t ) ) {
+                        if ( ! dynamic_cast<const StructInstType *>(rty)
+                                && ! dynamic_cast<const UnionInstType *>(rty) ) continue;
+                        ResolvExpr::Cost cost = ResolvExpr::Cost::zero;
+                        ast::ptr<ast::TypeSubstitution> tmp = expr->env;
+                        expr = mutate_field(expr, &Expr::env, nullptr);
+                        const Expr * base = ResolvExpr::referenceToRvalueConversion( expr, cost );
+                        base = mutate_field(base, &Expr::env, tmp);
+
+                        addMembers(
+                                rty->aggr(), new MemberExpr{ base->location, dwt, base }, handleConflicts );
                 }
         }

src/AST/SymbolTable.hpp ¶

@@ -192 +192 @@
 
         /// common code for addId, addDeletedId, etc.
-        void addId(
-                const DeclWithType * decl, OnConflict handleConflicts, const Expr * baseExpr = nullptr,
-                const Decl * deleter = nullptr );
+        void addIdCommon(
+                const DeclWithType * decl, OnConflict handleConflicts,
+                const Expr * baseExpr = nullptr, const Decl * deleter = nullptr );
 
         /// common code for addId when special decls are placed into separate tables
-        void addId(
-                const DeclWithType * decl, const std::string & lookupKey, IdTable::Ptr & idTable, OnConflict handleConflicts, 
+        void addIdToTable(
+                const DeclWithType * decl, const std::string & lookupKey,
+                IdTable::Ptr & idTable, OnConflict handleConflicts,
                 const Expr * baseExpr = nullptr, const Decl * deleter = nullptr);
-        
+
         /// adds all of the members of the Aggregate (addWith helper)
         void addMembers( const AggregateDecl * aggr, const Expr * expr, OnConflict handleConflicts );

src/InitTweak/FixInitNew.cpp ¶

@@ -14 +14 @@
 #include <utility>                     // for pair
 
+#include "AST/DeclReplacer.hpp"
+#include "AST/Expr.hpp"
 #include "AST/Inspect.hpp"             // for getFunction, getPointerBase, g...
+#include "AST/Node.hpp"
+#include "AST/Pass.hpp"
+#include "AST/Print.hpp"
+#include "AST/SymbolTable.hpp"
+#include "AST/Type.hpp"
 #include "CodeGen/GenType.h"           // for genPrettyType
 #include "CodeGen/OperatorTable.h"
-#include "Common/CodeLocationTools.hpp"
 #include "Common/PassVisitor.h"        // for PassVisitor, WithStmtsToAdd
 #include "Common/SemanticError.h"      // for SemanticError
@@ -28 +34 @@
 #include "ResolvExpr/Unify.h"          // for typesCompatible
 #include "SymTab/Autogen.h"            // for genImplicitCall
+#include "SymTab/GenImplicitCall.hpp"  // for genImplicitCall
 #include "SymTab/Indexer.h"            // for Indexer
 #include "SymTab/Mangler.h"            // for Mangler
@@ -45 +52 @@
 #include "Validate/FindSpecialDecls.h" // for dtorStmt, dtorStructDestroy
 
-#include "AST/Expr.hpp"
-#include "AST/Node.hpp"
-#include "AST/Pass.hpp"
-#include "AST/Print.hpp"
-#include "AST/SymbolTable.hpp"
-#include "AST/Type.hpp"
-#include "AST/DeclReplacer.hpp"
-
 extern bool ctordtorp; // print all debug
 extern bool ctorp; // print ctor debug
@@ -63 +62 @@
 namespace InitTweak {
 namespace {
+
+        // Shallow copy the pointer list for return.
+        std::vector<ast::ptr<ast::TypeDecl>> getGenericParams( const ast::Type * t ) {
+                if ( auto inst = dynamic_cast<const ast::StructInstType *>( t ) ) {
+                        return inst->base->params;
+                }
+                if ( auto inst = dynamic_cast<const ast::UnionInstType *>( t ) ) {
+                        return inst->base->params;
+                }
+                return {};
+        }
+
+        /// Given type T, generate type of default ctor/dtor, i.e. function type void (*) (T &).
+        ast::FunctionDecl * genDefaultFunc(
+                        const CodeLocation loc,
+                        const std::string fname,
+                        const ast::Type * paramType,
+                        bool maybePolymorphic = true) {
+                std::vector<ast::ptr<ast::TypeDecl>> typeParams;
+                if ( maybePolymorphic ) typeParams = getGenericParams( paramType );
+                auto dstParam = new ast::ObjectDecl( loc,
+                        "_dst",
+                        new ast::ReferenceType( paramType ),
+                        nullptr,
+                        {},
+                        ast::Linkage::Cforall
+                );
+                return new ast::FunctionDecl( loc,
+                        fname,
+                        std::move(typeParams),
+                        {dstParam},
+                        {},
+                        new ast::CompoundStmt(loc),
+                        {},
+                        ast::Linkage::Cforall
+                );
+        }
+
         struct SelfAssignChecker {
                 void previsit( const ast::ApplicationExpr * appExpr );
@@ -121 +158 @@
                 void previsit( const ast::FunctionDecl * ) { visit_children = false; }
 
-          protected:
+        protected:
                 ObjectSet curVars;
         };
@@ -202 +239 @@
 
                 SemanticErrorException errors;
-          private:
+        private:
                 template< typename... Params >
                 void emit( CodeLocation, const Params &... params );
@@ -288 +325 @@
                 static UniqueName dtorNamer( "__cleanup_dtor" );
                 std::string name = dtorNamer.newName();
-                ast::FunctionDecl * dtorFunc = SymTab::genDefaultFunc( loc, name, objDecl->type->stripReferences(), false );
+                ast::FunctionDecl * dtorFunc = genDefaultFunc( loc, name, objDecl->type->stripReferences(), false );
                 stmtsToAdd.push_back( new ast::DeclStmt(loc, dtorFunc ) );
 
@@ -1080 +1117 @@
         void InsertDtors::previsit( const ast::BranchStmt * stmt ) {
                 switch( stmt->kind ) {
-                  case ast::BranchStmt::Continue:
-                  case ast::BranchStmt::Break:
+                case ast::BranchStmt::Continue:
+                case ast::BranchStmt::Break:
                         // could optimize the break/continue case, because the S_L-S_G check is unnecessary (this set should
                         // always be empty), but it serves as a small sanity check.
-                  case ast::BranchStmt::Goto:
+                case ast::BranchStmt::Goto:
                         handleGoto( stmt );
                         break;
-                  default:
+                default:
                         assert( false );
                 } // switch

src/InitTweak/GenInit.cc ¶

@@ -39 +39 @@
 #include "ResolvExpr/Resolver.h"
 #include "SymTab/Autogen.h"            // for genImplicitCall
+#include "SymTab/GenImplicitCall.hpp"  // for genImplicitCall
 #include "SymTab/Mangler.h"            // for Mangler
 #include "SynTree/LinkageSpec.h"       // for isOverridable, C

src/SymTab/Autogen.cc ¶

@@ -10 +10 @@
 // Created On       : Thu Mar 03 15:45:56 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Apr 27 14:39:06 2018
-// Update Count     : 63
+// Last Modified On : Fri Apr 14 15:03:00 2023
+// Update Count     : 64
 //
 
@@ -211 +211 @@
         }
 
-        bool isUnnamedBitfield( const ast::ObjectDecl * obj ) {
-                return obj && obj->name.empty() && obj->bitfieldWidth;
-        }
-
         /// inserts a forward declaration for functionDecl into declsToAdd
         void addForwardDecl( FunctionDecl * functionDecl, std::list< Declaration * > & declsToAdd ) {
@@ -234 +230 @@
         }
 
-        // shallow copy the pointer list for return
-        std::vector<ast::ptr<ast::TypeDecl>> getGenericParams (const ast::Type * t) {
-                if (auto structInst = dynamic_cast<const ast::StructInstType*>(t)) {
-                        return structInst->base->params;
-                }
-                if (auto unionInst = dynamic_cast<const ast::UnionInstType*>(t)) {
-                        return unionInst->base->params;
-                }
-                return {};
-        }
-
         /// given type T, generate type of default ctor/dtor, i.e. function type void (*) (T *)
         FunctionType * genDefaultType( Type * paramType, bool maybePolymorphic ) {
@@ -256 +241 @@
                 ftype->parameters.push_back( dstParam );
                 return ftype;
-        }
-
-        /// Given type T, generate type of default ctor/dtor, i.e. function type void (*) (T &).
-        ast::FunctionDecl * genDefaultFunc(const CodeLocation loc, const std::string fname, const ast::Type * paramType, bool maybePolymorphic) {
-                std::vector<ast::ptr<ast::TypeDecl>> typeParams;
-                if (maybePolymorphic) typeParams = getGenericParams(paramType);
-                auto dstParam = new ast::ObjectDecl(loc, "_dst", new ast::ReferenceType(paramType), nullptr, {}, ast::Linkage::Cforall);
-                return new ast::FunctionDecl(loc, fname, std::move(typeParams), {dstParam}, {}, new ast::CompoundStmt(loc), {}, ast::Linkage::Cforall);
         }
 

src/SymTab/Autogen.h ¶

@@ -9 +9 @@
 // Author           : Rob Schluntz
 // Created On       : Sun May 17 21:53:34 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Dec 13 16:38:06 2019
-// Update Count     : 16
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Apr 14 15:06:00 2023
+// Update Count     : 17
 //
 
@@ -45 +45 @@
         /// returns true if obj's name is the empty string and it has a bitfield width
         bool isUnnamedBitfield( ObjectDecl * obj );
-        bool isUnnamedBitfield( const ast::ObjectDecl * obj );
 
         /// generate the type of an assignment function for paramType.
@@ -55 +54 @@
         FunctionType * genDefaultType( Type * paramType, bool maybePolymorphic = true );
 
-        ast::FunctionDecl * genDefaultFunc(const CodeLocation loc, const std::string fname, const ast::Type * paramType, bool maybePolymorphic = true);
-
         /// generate the type of a copy constructor for paramType.
         /// maybePolymorphic is true if the resulting FunctionType is allowed to be polymorphic
@@ -67 +64 @@
         template< typename OutputIterator >
         Statement * genCall( InitTweak::InitExpander_old & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast = nullptr, bool forward = true );
-
-        template< typename OutIter >
-        ast::ptr< ast::Stmt > genCall(
-                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam,
-                const CodeLocation & loc, const std::string & fname, OutIter && out,
-                const ast::Type * type, const ast::Type * addCast, LoopDirection forward = LoopForward );
 
         /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Should only be called with non-array types.
@@ -121 +112 @@
 
                 *out++ = new ExprStmt( fExpr );
-
-                srcParam.clearArrayIndices();
-
-                return listInit;
-        }
-
-        /// 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 OutIter >
-        ast::ptr< ast::Stmt > genScalarCall(
-                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam,
-                const CodeLocation & loc, std::string fname, OutIter && out, const ast::Type * type,
-                const ast::Type * addCast = nullptr
-        ) {
-                bool isReferenceCtorDtor = false;
-                if ( dynamic_cast< const ast::ReferenceType * >( type ) && CodeGen::isCtorDtor( fname ) ) {
-                        // reference constructors are essentially application of the rebind operator.
-                        // apply & to both arguments, do not need a cast
-                        fname = "?=?";
-                        dstParam = new ast::AddressExpr{ dstParam };
-                        addCast = nullptr;
-                        isReferenceCtorDtor = true;
-                }
-
-                // want to be able to generate assignment, ctor, and dtor generically, so fname is one of
-                // "?=?", "?{}", or "^?{}"
-                ast::UntypedExpr * fExpr = new ast::UntypedExpr{ loc, new ast::NameExpr{ loc, fname } };
-
-                if ( addCast ) {
-                        // cast to T& with qualifiers removed, so that qualified objects can be constructed and
-                        // destructed with the same functions as non-qualified objects. Unfortunately, lvalue
-                        // is considered a qualifier - for AddressExpr to resolve, its argument must have an
-                        // lvalue-qualified type, so remove all qualifiers except lvalue.
-                        // xxx -- old code actually removed lvalue too...
-                        ast::ptr< ast::Type > guard = addCast;  // prevent castType from mutating addCast
-                        ast::ptr< ast::Type > castType = addCast;
-                        ast::remove_qualifiers(
-                                castType,
-                                ast::CV::Const | ast::CV::Volatile | ast::CV::Restrict | ast::CV::Atomic );
-                        dstParam = new ast::CastExpr{ dstParam, new ast::ReferenceType{ castType } };
-                }
-                fExpr->args.emplace_back( dstParam );
-
-                ast::ptr<ast::Stmt> listInit = srcParam.buildListInit( fExpr );
-
-                // fetch next set of arguments
-                ++srcParam;
-
-                // return if adding reference fails -- will happen on default ctor and dtor
-                if ( isReferenceCtorDtor && ! srcParam.addReference() ) return listInit;
-
-                std::vector< ast::ptr< ast::Expr > > args = *srcParam;
-                splice( fExpr->args, args );
-
-                *out++ = new ast::ExprStmt{ loc, fExpr };
 
                 srcParam.clearArrayIndices();
@@ -248 +182 @@
         }
 
-        /// Store in out a loop which calls fname on each element of the array with srcParam and
-        /// dstParam as arguments. If forward is true, loop goes from 0 to N-1, else N-1 to 0
-        template< typename OutIter >
-        void genArrayCall(
-                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam,
-                const CodeLocation & loc, const std::string & fname, OutIter && out,
-                const ast::ArrayType * array, const ast::Type * addCast = nullptr,
-                LoopDirection forward = LoopForward
-        ) {
-                static UniqueName indexName( "_index" );
-
-                // for a flexible array member nothing is done -- user must define own assignment
-                if ( ! array->dimension ) return;
-
-                if ( addCast ) {
-                        // peel off array layer from cast
-                        addCast = strict_dynamic_cast< const ast::ArrayType * >( addCast )->base;
-                }
-
-                ast::ptr< ast::Expr > begin, end;
-                std::string cmp, update;
-
-                if ( forward ) {
-                        // generate: for ( int i = 0; i < N; ++i )
-                        begin = ast::ConstantExpr::from_int( loc, 0 );
-                        end = array->dimension;
-                        cmp = "?<?";
-                        update = "++?";
-                } else {
-                        // generate: for ( int i = N-1; i >= 0; --i )
-                        begin = ast::UntypedExpr::createCall( loc, "?-?",
-                                { array->dimension, ast::ConstantExpr::from_int( loc, 1 ) } );
-                        end = ast::ConstantExpr::from_int( loc, 0 );
-                        cmp = "?>=?";
-                        update = "--?";
-                }
-
-                ast::ptr< ast::DeclWithType > index = new ast::ObjectDecl{
-                        loc, indexName.newName(), new ast::BasicType{ ast::BasicType::SignedInt },
-                        new ast::SingleInit{ loc, begin } };
-                ast::ptr< ast::Expr > indexVar = new ast::VariableExpr{ loc, index };
-
-                ast::ptr< ast::Expr > cond = ast::UntypedExpr::createCall(
-                        loc, cmp, { indexVar, end } );
-
-                ast::ptr< ast::Expr > inc = ast::UntypedExpr::createCall(
-                        loc, update, { indexVar } );
-
-                ast::ptr< ast::Expr > dstIndex = ast::UntypedExpr::createCall(
-                        loc, "?[?]", { dstParam, indexVar } );
-
-                // srcParam must keep track of the array indices to build the source parameter and/or
-                // array list initializer
-                srcParam.addArrayIndex( indexVar, array->dimension );
-
-                // for stmt's body, eventually containing call
-                ast::CompoundStmt * body = new ast::CompoundStmt{ loc };
-                ast::ptr< ast::Stmt > listInit = genCall(
-                        srcParam, dstIndex, loc, fname, std::back_inserter( body->kids ), array->base, addCast,
-                        forward );
-
-                // block containing the stmt and index variable
-                ast::CompoundStmt * block = new ast::CompoundStmt{ loc };
-                block->push_back( new ast::DeclStmt{ loc, index } );
-                if ( listInit ) { block->push_back( listInit ); }
-                block->push_back( new ast::ForStmt{ loc, {}, cond, inc, body } );
-
-                *out++ = block;
-        }
-
         template< typename OutputIterator >
         Statement * genCall( InitTweak::InitExpander_old & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast, bool forward ) {
@@ -325 +189 @@
                 } else {
                         return genScalarCall( srcParam, dstParam, fname, out, type, addCast );
-                }
-        }
-
-        template< typename OutIter >
-        ast::ptr< ast::Stmt > genCall(
-                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam,
-                const CodeLocation & loc, const std::string & fname, OutIter && out,
-                const ast::Type * type, const ast::Type * addCast, LoopDirection forward
-        ) {
-                if ( auto at = dynamic_cast< const ast::ArrayType * >( type ) ) {
-                        genArrayCall(
-                                srcParam, dstParam, loc, fname, std::forward< OutIter >(out), at, addCast,
-                                forward );
-                        return {};
-                } else {
-                        return genScalarCall(
-                                srcParam, dstParam, loc, fname, std::forward< OutIter >( out ), type, addCast );
                 }
         }
@@ -379 +226 @@
         }
 
-        static inline ast::ptr< ast::Stmt > genImplicitCall(
-                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam,
-                const CodeLocation & loc, const std::string & fname, const ast::ObjectDecl * obj,
-                LoopDirection forward = LoopForward
-        ) {
-                // unnamed bit fields are not copied as they cannot be accessed
-                if ( isUnnamedBitfield( obj ) ) return {};
-
-                ast::ptr< ast::Type > addCast;
-                if ( (fname == "?{}" || fname == "^?{}") && ( ! obj || ( obj && ! obj->bitfieldWidth ) ) ) {
-                        assert( dstParam->result );
-                        addCast = dstParam->result;
-                }
-
-                std::vector< ast::ptr< ast::Stmt > > stmts;
-                genCall(
-                        srcParam, dstParam, loc, fname, back_inserter( stmts ), obj->type, addCast, forward );
-
-                if ( stmts.empty() ) {
-                        return {};
-                } else if ( stmts.size() == 1 ) {
-                        const ast::Stmt * callStmt = stmts.front();
-                        if ( addCast ) {
-                                // implicitly generated ctor/dtor calls should be wrapped so that later passes are
-                                // aware they were generated.
-                                callStmt = new ast::ImplicitCtorDtorStmt{ callStmt->location, callStmt };
-                        }
-                        return callStmt;
-                } else {
-                        assert( false );
-                        return {};
-                }
-        }
 } // namespace SymTab
 

src/SymTab/module.mk ¶

@@ -20 +20 @@
         SymTab/FixFunction.cc \
         SymTab/FixFunction.h \
+        SymTab/GenImplicitCall.cpp \
+        SymTab/GenImplicitCall.hpp \
         SymTab/Indexer.cc \
         SymTab/Indexer.h \

src/Validate/Autogen.cpp ¶

@@ -39 +39 @@
 #include "InitTweak/GenInit.h"     // for fixReturnStatements
 #include "InitTweak/InitTweak.h"   // for isAssignment, isCopyConstructor
+#include "SymTab/GenImplicitCall.hpp"  // for genImplicitCall
 #include "SymTab/Mangler.h"        // for Mangler
 #include "CompilationState.h"
@@ -423 +424 @@
         for ( unsigned int index = 0 ; index < fields ; ++index ) {
                 auto member = aggr->members[index].strict_as<ast::DeclWithType>();
-                if ( SymTab::isUnnamedBitfield(
+                if ( ast::isUnnamedBitfield(
                                 dynamic_cast<const ast::ObjectDecl *>( member ) ) ) {
                         if ( index == fields - 1 ) {
@@ -599 +600 @@
                 // Not sure why it could be null.
                 // Don't make a function for a parameter that is an unnamed bitfield.
-                if ( nullptr == field || SymTab::isUnnamedBitfield( field ) ) {
+                if ( nullptr == field || ast::isUnnamedBitfield( field ) ) {
                         continue;
                 // Matching Parameter: Initialize the field by copy.