Changeset 46aa60e for src

Timestamp:

Feb 23, 2024, 11:41:10 PM (11 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

0a9b5c1, 1e93617

Parents:

3d5a8cb (diff), 1761046 (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.

git-author:

Peter A. Buhr <pabuhr@…> (02/23/24 18:54:24)

git-committer:

Peter A. Buhr <pabuhr@…> (02/23/24 23:41:10)

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src

Files:

• GenPoly/Box.cpp (modified) (2 diffs)
• InitTweak/FixInit.cpp (modified) (1 diff)
• InitTweak/GenInit.cc (modified) (2 diffs)
• InitTweak/GenInit.h (modified) (1 diff)
• Parser/parser.yy (modified) (1 diff)
• ResolvExpr/CandidateFinder.cpp (modified) (1 diff)
• SymTab/GenImplicitCall.cpp (modified) (9 diffs)
• SymTab/GenImplicitCall.hpp (modified) (2 diffs)
• Validate/Autogen.cpp (modified) (6 diffs)

src/GenPoly/Box.cpp

@@ -1109 +1109 @@
         );
 
-        for ( auto group : group_iterate( realType->assertions,
-                        adapterType->assertions, adaptee->assertions ) ) {
-                auto assertArg = std::get<0>( group );
-                auto assertParam = std::get<1>( group );
-                auto assertReal = std::get<2>( group );
+        for ( auto const & [assertArg, assertParam, assertReal] : group_iterate(
+                        realType->assertions, adapterType->assertions, adaptee->assertions ) ) {
                 adapteeApp->args.push_back( makeAdapterArg(
                         assertParam->var, assertArg->var->get_type(),
@@ -1970 +1967 @@
         bool hasDynamicLayout = false;
 
-        for ( auto pair : group_iterate( baseParams, typeParams ) ) {
-                auto baseParam = std::get<0>( pair );
-                auto typeParam = std::get<1>( pair );
+        for ( auto const & [baseParam, typeParam] : group_iterate(
+                        baseParams, typeParams ) ) {
                 if ( !baseParam->isComplete() ) continue;
                 ast::TypeExpr const * typeExpr = typeParam.as<ast::TypeExpr>();

src/InitTweak/FixInit.cpp

@@ -1134 +1134 @@
                         ast::Expr * thisExpr = new ast::CastExpr(funcDecl->location, new ast::VariableExpr(funcDecl->location, thisParam ), thisParam->get_type()->stripReferences());
                         ast::Expr * memberDest = new ast::MemberExpr(funcDecl->location, field, thisExpr );
-                        ast::ptr<ast::Stmt> callStmt = SymTab::genImplicitCall( srcParam, memberDest, loc, function->name, field, static_cast<SymTab::LoopDirection>(isCtor) );
+                        const ast::Stmt * callStmt = SymTab::genImplicitCall( srcParam, memberDest, loc, function->name, field, static_cast<SymTab::LoopDirection>(isCtor) );
 
                         if ( callStmt ) {

src/InitTweak/GenInit.cc

@@ -239 +239 @@
                                         if ( varExpr->var == retVal ) return stmt;
                                 }
-                                ast::ptr<ast::Stmt> ctorStmt = genCtorDtor(
+                                const ast::Stmt * ctorStmt = genCtorDtor(
                                         retVal->location, "?{}", retVal, stmt->expr );
                                 assertf( ctorStmt,
@@ -327 +327 @@
 void ManagedTypes::endScope() { managedTypes.endScope(); }
 
-ast::ptr<ast::Stmt> genCtorDtor (const CodeLocation & loc, const std::string & fname, const ast::ObjectDecl * objDecl, const ast::Expr * arg) {
+const ast::Stmt * genCtorDtor( const CodeLocation & loc, const std::string & fname, const ast::ObjectDecl * objDecl, const ast::Expr * arg ) {
         assertf(objDecl, "genCtorDtor passed null objDecl");
         InitExpander srcParam(arg);

src/InitTweak/GenInit.h

@@ -33 +33 @@
 
 /// generates a single ctor/dtor statement using objDecl as the 'this' parameter and arg as the optional argument
-ast::ptr<ast::Stmt> genCtorDtor (const CodeLocation & loc, const std::string & fname, const ast::ObjectDecl * objDecl, const ast::Expr * arg = nullptr);
+const ast::Stmt * genCtorDtor( const CodeLocation & loc, const std::string & fname, const ast::ObjectDecl * objDecl, const ast::Expr * arg = nullptr );
 
 /// creates an appropriate ConstructorInit node which contains a constructor, destructor, and C-initializer

src/Parser/parser.yy

@@ -1081 +1081 @@
         | logical_OR_expression '?' comma_expression ':' conditional_expression
                 { $$ = new ExpressionNode( build_cond( yylloc, $1, $3, $5 ) ); }
-                // FIX ME: computes $1 twice
         | logical_OR_expression '?' /* empty */ ':' conditional_expression // GCC, omitted first operand
-                { $$ = new ExpressionNode( build_cond( yylloc, $1, $1->clone(), $4 ) ); }
+                { $$ = new ExpressionNode( build_cond( yylloc, $1, nullptr, $4 ) ); }
         ;
 

src/ResolvExpr/CandidateFinder.cpp

@@ -1512 +1512 @@
         void Finder::postvisit( const ast::ConditionalExpr * conditionalExpr ) {
                 // candidates for condition
+                ast::ptr<ast::Expr> arg1 = notZeroExpr( conditionalExpr->arg1 );
                 CandidateFinder finder1( context, tenv );
-                ast::ptr<ast::Expr> arg1 = notZeroExpr( conditionalExpr->arg1 );
                 finder1.find( arg1, ResolveMode::withAdjustment() );
                 if ( finder1.candidates.empty() ) return;
 
                 // candidates for true result
+                // FIX ME: resolves and runs arg1 twice when arg2 is missing.
+                ast::Expr const * arg2 = conditionalExpr->arg2;
+                arg2 = arg2 ? arg2 : conditionalExpr->arg1.get();
                 CandidateFinder finder2( context, tenv );
                 finder2.allowVoid = true;
-                finder2.find( conditionalExpr->arg2, ResolveMode::withAdjustment() );
+                finder2.find( arg2, ResolveMode::withAdjustment() );
                 if ( finder2.candidates.empty() ) return;
 

src/SymTab/GenImplicitCall.cpp

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// GenImplicitCall.hpp --
+// GenImplicitCall.cpp -- Generate code for implicit operator calls.
 //
 // Author           : Andrew Beach
@@ -31 +31 @@
 namespace {
 
-template< typename OutIter >
+using Inserter = std::back_insert_iterator<std::list<ast::ptr<ast::Stmt>>>;
+
 ast::ptr< ast::Stmt > genCall(
         InitTweak::InitExpander & srcParam, const ast::Expr * dstParam,
-        const CodeLocation & loc, const std::string & fname, OutIter && out,
+        const CodeLocation & loc, const std::string & fname, Inserter && out,
         const ast::Type * type, const ast::Type * addCast, LoopDirection forward = LoopForward );
 
@@ -41 +42 @@
 /// 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 & srcParam, const ast::Expr * dstParam,
-        const CodeLocation & loc, std::string fname, OutIter && out, const ast::Type * type,
+        const CodeLocation & loc, std::string fname, Inserter && out, const ast::Type * type,
         const ast::Type * addCast = nullptr
 ) {
@@ -97 +97 @@
 /// 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 & srcParam, const ast::Expr * dstParam,
-        const CodeLocation & loc, const std::string & fname, OutIter && out,
+        const CodeLocation & loc, const std::string & fname, Inserter && out,
         const ast::ArrayType * array, const ast::Type * addCast = nullptr,
         LoopDirection forward = LoopForward
@@ -166 +165 @@
 }
 
-template< typename OutIter >
 ast::ptr< ast::Stmt > genCall(
         InitTweak::InitExpander & srcParam, const ast::Expr * dstParam,
-        const CodeLocation & loc, const std::string & fname, OutIter && out,
+        const CodeLocation & loc, const std::string & fname, Inserter && 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,
+                        srcParam, dstParam, loc, fname, std::forward< Inserter&& >( out ), at, addCast,
                         forward );
                 return {};
         } else {
                 return genScalarCall(
-                        srcParam, dstParam, loc, fname, std::forward< OutIter >( out ), type, addCast );
+                        srcParam, dstParam, loc, fname, std::forward< Inserter&& >( out ), type, addCast );
         }
 }
@@ -185 +183 @@
 } // namespace
 
-ast::ptr< ast::Stmt > genImplicitCall(
+const ast::Stmt * genImplicitCall(
         InitTweak::InitExpander & srcParam, const ast::Expr * dstParam,
         const CodeLocation & loc, const std::string & fname, const ast::ObjectDecl * obj,
@@ -191 +189 @@
 ) {
         // unnamed bit fields are not copied as they cannot be accessed
-        if ( isUnnamedBitfield( obj ) ) return {};
+        if ( isUnnamedBitfield( obj ) ) return nullptr;
 
         ast::ptr< ast::Type > addCast;
@@ -199 +197 @@
         }
 
-        std::vector< ast::ptr< ast::Stmt > > stmts;
+        std::list< 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 {};
-        }
+        if ( stmts.empty() ) return nullptr;
+        assert( stmts.size() == 1 );
+
+        const ast::Stmt * callStmt = stmts.front().release();
+        // Implicitly generated ctor/dtor calls should be wrapped so that
+        // later passes are aware they were generated.
+        if ( addCast ) {
+                callStmt = new ast::ImplicitCtorDtorStmt( callStmt->location, callStmt );
+        }
+        return callStmt;
 }
 
@@ -226 +220 @@
 // compile-command: "make install" //
 // End: //
-
-

src/SymTab/GenImplicitCall.hpp

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// GenImplicitCall.hpp --
+// GenImplicitCall.hpp -- Generate code for implicit operator calls.
 //
 // Author           : Andrew Beach
@@ -25 +25 @@
 /// Returns a generated call expression to function fname with srcParam and
 /// dstParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls.
-ast::ptr<ast::Stmt> genImplicitCall(
+const ast::Stmt * genImplicitCall(
         InitTweak::InitExpander & srcParam, const ast::Expr * dstParam,
         const CodeLocation & loc, const std::string & fname, const ast::ObjectDecl * obj,

src/Validate/Autogen.cpp

@@ -133 +133 @@
         /// Generates a single struct member operation.
         /// (constructor call, destructor call, assignment call)
-        // This is managed because it uses another helper that returns a ast::ptr.
-        ast::ptr<ast::Stmt> makeMemberOp(
+        const ast::Stmt * makeMemberOp(
                 const CodeLocation& location,
                 const ast::ObjectDecl * dstParam, const ast::Expr * src,
@@ -524 +523 @@
 }
 
-ast::ptr<ast::Stmt> StructFuncGenerator::makeMemberOp(
+const ast::Stmt * StructFuncGenerator::makeMemberOp(
                 const CodeLocation& location, const ast::ObjectDecl * dstParam,
                 const ast::Expr * src, const ast::ObjectDecl * field,
@@ -539 +538 @@
                 )
         );
-        auto stmt = genImplicitCall(
+        const ast::Stmt * stmt = genImplicitCall(
                 srcParam, dstSelect, location, func->name,
                 field, direction
@@ -597 +596 @@
                         location, field, new ast::VariableExpr( location, srcParam )
                 ) : nullptr;
-                ast::ptr<ast::Stmt> stmt =
+                const ast::Stmt * stmt =
                         makeMemberOp( location, dstParam, srcSelect, field, func, direction );
 
                 if ( nullptr != stmt ) {
-                        stmts->kids.push_back( stmt );
+                        stmts->kids.emplace_back( stmt );
                 }
         }
@@ -622 +621 @@
         for ( auto param = params.begin() + 1 ; current != end ; ++current ) {
                 const ast::ptr<ast::Decl> & member = *current;
-                ast::ptr<ast::Stmt> stmt = nullptr;
+                const ast::Stmt * stmt = nullptr;
                 auto field = member.as<ast::ObjectDecl>();
                 // Not sure why it could be null.
@@ -640 +639 @@
 
                 if ( nullptr != stmt ) {
-                        stmts->kids.push_back( stmt );
+                        stmts->kids.emplace_back( stmt );
                 }
         }