Changeset 28e58fd for src/InitTweak/FixInit.cc

Timestamp:

Aug 25, 2017, 10:38:34 AM (7 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

800d275

Parents:

af08051 (diff), 3eab308c (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/InitTweak/FixInit.cc (modified) (15 diffs)

src/InitTweak/FixInit.cc

@@ -29 +29 @@
 
 #include "CodeGen/GenType.h"           // for genPrettyType
+#include "CodeGen/OperatorTable.h"
 #include "Common/PassVisitor.h"        // for PassVisitor, WithStmtsToAdd
 #include "Common/SemanticError.h"      // for SemanticError
@@ -254 +255 @@
                         SemanticError errors;
                   private:
-                        void handleFirstParam( Expression * firstParam );
                         template< typename... Params >
                         void emit( CodeLocation, const Params &... params );
@@ -379 +379 @@
                                         FunctionType * ftype = dynamic_cast< FunctionType * >( GenPoly::getFunctionType( funcDecl->get_type() ) );
                                         assert( ftype );
-                                        if ( isConstructor( funcDecl->get_name() ) && ftype->get_parameters().size() == 2 ) {
-                                                Type * t1 = ftype->get_parameters().front()->get_type();
+                                        if ( CodeGen::isConstructor( funcDecl->get_name() ) && ftype->get_parameters().size() == 2 ) {
+                                                Type * t1 = getPointerBase( ftype->get_parameters().front()->get_type() );
                                                 Type * t2 = ftype->get_parameters().back()->get_type();
-                                                PointerType * ptrType = safe_dynamic_cast< PointerType * > ( t1 );
-
-                                                if ( ResolvExpr::typesCompatible( ptrType->get_base(), t2, SymTab::Indexer() ) ) {
+                                                assert( t1 );
+
+                                                if ( ResolvExpr::typesCompatible( t1, t2, SymTab::Indexer() ) ) {
                                                         // optimization: don't need to copy construct in order to call a copy constructor
                                                         return appExpr;
                                                 } // if
-                                        } else if ( isDestructor( funcDecl->get_name() ) ) {
+                                        } else if ( CodeGen::isDestructor( funcDecl->get_name() ) ) {
                                                 // correctness: never copy construct arguments to a destructor
                                                 return appExpr;
@@ -417 +417 @@
 
                 bool ResolveCopyCtors::skipCopyConstruct( Type * type ) {
-                        return dynamic_cast< VarArgsType * >( type ) || GenPoly::getFunctionType( type ) || Tuples::isTtype( type );
+                        return dynamic_cast< VarArgsType * >( type ) || dynamic_cast< ReferenceType * >( type ) || GenPoly::getFunctionType( type ) || Tuples::isTtype( type );
                 }
 
@@ -505 +505 @@
                                 impCpCtorExpr->get_returnDecls().push_back( ret );
                                 CP_CTOR_PRINT( std::cerr << "makeCtorDtor for a return" << std::endl; )
-                                if ( ! result->get_lvalue() ) {
+                                if ( ! dynamic_cast< ReferenceType * >( result ) ) {
                                         // destructing lvalue returns is bad because it can cause multiple destructor calls to the same object - the returned object is not a temporary
                                         destructRet( ret, impCpCtorExpr );
@@ -607 +607 @@
 
                                 Expression * retExpr = new CommaExpr( assign, new VariableExpr( returnDecl ) );
-                                if ( callExpr->get_result()->get_lvalue() ) {
-                                        // lvalue returning functions are funny. Lvalue.cc inserts a *? in front of any lvalue returning
-                                        // non-intrinsic function. Add an AddressExpr to the call to negate the derefence and change the
-                                        // type of the return temporary from T to T* to properly capture the return value. Then dereference
-                                        // the result of the comma expression, since the lvalue returning call was originally wrapped with
-                                        // an AddressExpr.  Effectively, this turns
-                                        //   lvalue T f();
-                                        //   &*f();
-                                        // into
-                                        //   T * f();
-                                        //   T * tmp_cp_retN;
-                                        //   &*(tmp_cp_retN = &*f(), tmp_cp_retN);              // the first * and second & are generated here
-                                        // which work out in terms of types, but is pretty messy. It would be nice to find a better way.
-                                        assign->get_args().back() = new AddressExpr( assign->get_args().back() );
-
-                                        returnDecl->set_type( new PointerType( Type::Qualifiers(), returnDecl->get_type() ) );
-                                        retExpr->set_result( new PointerType( Type::Qualifiers(), retExpr->get_result() ) );
-                                        retExpr = UntypedExpr::createDeref( retExpr );
-                                } // if
                                 // move env from callExpr to retExpr
                                 retExpr->set_env( callExpr->get_env() );
@@ -991 +972 @@
                         if ( ! funcDecl ) return false;
                         if ( ! funcDecl->get_statements() ) return false;
-                        return isCtorDtor( funcDecl->get_name() ) && ! LinkageSpec::isOverridable( funcDecl->get_linkage() );
+                        return CodeGen::isCtorDtor( funcDecl->get_name() ) && ! LinkageSpec::isOverridable( funcDecl->get_linkage() );
                 }
 
@@ -1008 +989 @@
 
                         function = funcDecl;
-                        isCtor = isConstructor( function->get_name() );
+                        isCtor = CodeGen::isConstructor( function->get_name() );
                         if ( checkWarnings( function ) ) {
                                 FunctionType * type = function->get_functionType();
                                 assert( ! type->get_parameters().empty() );
                                 thisParam = safe_dynamic_cast< ObjectDecl * >( type->get_parameters().front() );
-                                PointerType * ptrType = safe_dynamic_cast< PointerType * > ( thisParam->get_type() );
-                                StructInstType * structType = dynamic_cast< StructInstType * >( ptrType->get_base() );
+                                Type * thisType = getPointerBase( thisParam->get_type() );
+                                StructInstType * structType = dynamic_cast< StructInstType * >( thisType );
                                 if ( structType ) {
                                         structDecl = structType->get_baseStruct();
@@ -1047 +1028 @@
 
                         if ( ! unhandled.empty() ) {
-                                // need to explicitly re-add function parameters in order to resolve copy constructors
+                                // need to explicitly re-add function parameters to the indexer in order to resolve copy constructors
                                 enterScope();
                                 maybeAccept( function->get_functionType(), *this );
@@ -1062 +1043 @@
                                         // insert and resolve default/copy constructor call for each field that's unhandled
                                         std::list< Statement * > stmt;
-                                        UntypedExpr * deref = UntypedExpr::createDeref( new VariableExpr( thisParam ) );
-
                                         Expression * arg2 = 0;
                                         if ( isCopyConstructor( function ) ) {
@@ -1072 +1051 @@
                                         }
                                         InitExpander srcParam( arg2 );
-                                        SymTab::genImplicitCall( srcParam, new MemberExpr( field, deref ), function->get_name(), back_inserter( stmt ), field, isCtor );
+                                        // cast away reference type and construct field.
+                                        Expression * thisExpr = new CastExpr( new VariableExpr( thisParam ), thisParam->get_type()->stripReferences()->clone() );
+                                        Expression * memberDest = new MemberExpr( field, thisExpr );
+                                        SymTab::genImplicitCall( srcParam, memberDest, function->get_name(), back_inserter( stmt ), field, isCtor );
 
                                         assert( stmt.size() <= 1 );
@@ -1099 +1081 @@
                 }
 
+                /// true if expr is effectively just the 'this' parameter
+                bool isThisExpression( Expression * expr, DeclarationWithType * thisParam ) {
+                        // TODO: there are more complicated ways to pass 'this' to a constructor, e.g. &*, *&, etc.
+                        if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( expr ) ) {
+                                return varExpr->get_var() == thisParam;
+                        } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * > ( expr ) ) {
+                                return isThisExpression( castExpr->get_arg(), thisParam );
+                        }
+                        return false;
+                }
+
+                /// returns a MemberExpr if expr is effectively just member access on the 'this' parameter, else nullptr
+                MemberExpr * isThisMemberExpr( Expression * expr, DeclarationWithType * thisParam ) {
+                        if ( MemberExpr * memberExpr = dynamic_cast< MemberExpr * >( expr ) ) {
+                                if ( isThisExpression( memberExpr->get_aggregate(), thisParam ) ) {
+                                        return memberExpr;
+                                }
+                        } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
+                                return isThisMemberExpr( castExpr->get_arg(), thisParam );
+                        }
+                        return nullptr;
+                }
+
                 void GenStructMemberCalls::visit( ApplicationExpr * appExpr ) {
                         if ( ! checkWarnings( function ) ) return;
@@ -1107 +1112 @@
                                 Expression * firstParam = appExpr->get_args().front();
 
-                                if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( firstParam ) ) {
+                                if ( isThisExpression( firstParam, thisParam ) ) {
                                         // if calling another constructor on thisParam, assume that function handles
                                         // all members - if it doesn't a warning will appear in that function.
-                                        if ( varExpr->get_var() == thisParam ) {
-                                                unhandled.clear();
-                                        }
-                                } else {
-                                        // if first parameter is a member expression then
-                                        // remove the member from unhandled set.
-                                        handleFirstParam( firstParam );
-                                }
-                        }
-
-                        Parent::visit( appExpr );
-                }
-
-                void GenStructMemberCalls::handleFirstParam( Expression * firstParam ) {
-                        using namespace std;
-                        if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( firstParam ) ) {
-                                if ( MemberExpr * memberExpr = dynamic_cast< MemberExpr * >( addrExpr->get_arg() ) ) {
-                                        if ( ApplicationExpr * deref = dynamic_cast< ApplicationExpr * >( memberExpr->get_aggregate() ) ) {
-                                                if ( getFunctionName( deref ) == "*?" && deref->get_args().size() == 1 ) {
-                                                        if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( deref->get_args().front() ) ) {
-                                                                if ( varExpr->get_var() == thisParam ) {
-                                                                        unhandled.erase( memberExpr->get_member() );
-                                                                }
-                                                        }
-                                                }
+                                        unhandled.clear();
+                                } else if ( MemberExpr * memberExpr = isThisMemberExpr( firstParam, thisParam ) ) {
+                                        // if first parameter is a member expression on the this parameter,
+                                        // then remove the member from unhandled set.
+                                        if ( isThisExpression( memberExpr->get_aggregate(), thisParam ) ) {
+                                                unhandled.erase( memberExpr->get_member() );
                                         }
                                 }
                         }
+                        Parent::visit( appExpr );
                 }
 
@@ -1144 +1131 @@
                         if ( ! isCtor ) return;
 
-                        if ( ApplicationExpr * deref = dynamic_cast< ApplicationExpr * >( memberExpr->get_aggregate() ) ) {
-                                if ( getFunctionName( deref ) == "*?" && deref->get_args().size() == 1 ) {
-                                        if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( deref->get_args().front() ) ) {
-                                                if ( varExpr->get_var() == thisParam ) {
-                                                        if ( unhandled.count( memberExpr->get_member() ) ) {
-                                                                // emit a warning because a member was used before it was constructed
-                                                                usedUninit.insert( { memberExpr->get_member(), memberExpr->location } );
-                                                        }
-                                                }
-                                        }
+                        if ( isThisExpression( memberExpr->get_aggregate(), thisParam ) ) {
+                                if ( unhandled.count( memberExpr->get_member() ) ) {
+                                        // emit a warning because a member was used before it was constructed
+                                        usedUninit.insert( { memberExpr->get_member(), memberExpr->location } );
                                 }
                         }
@@ -1199 +1180 @@
                         ctorExpr->set_callExpr( nullptr );
                         ctorExpr->set_env( nullptr );
+                        delete ctorExpr;
 
                         Expression *& firstArg = callExpr->get_args().front();
-                        UntypedExpr * assign = new UntypedExpr( new NameExpr( "?=?" ) );
-                        assign->get_args().push_back( new VariableExpr( tmp ) );
-                        assign->get_args().push_back( firstArg );
-                        assign->set_result( ctorExpr->get_result()->clone() );
-                        firstArg = assign;
-
-                        CommaExpr * commaExpr = new CommaExpr( callExpr, new VariableExpr( tmp ) );
+
+                        // xxx - hack in 'fake' assignment operator until resolver can easily be called in this pass. Once the resolver can be used in PassVisitor, this hack goes away.
+
+                        // generate the type of assignment operator using the type of tmp minus any reference types
+                        Type * type = tmp->get_type()->stripReferences();
+                        FunctionType * ftype = SymTab::genAssignType( type );
+
+                        // generate fake assignment decl and call it using &tmp and &firstArg
+                        // since tmp is guaranteed to be a reference and we want to assign pointers
+                        FunctionDecl * assignDecl = new FunctionDecl( "?=?", Type::StorageClasses(), LinkageSpec::Intrinsic, ftype, nullptr );
+                        ApplicationExpr * assign = new ApplicationExpr( VariableExpr::functionPointer( assignDecl ) );
+                        assign->get_args().push_back( new AddressExpr( new VariableExpr( tmp ) ) );
+                        Expression * addrArg = new AddressExpr( firstArg );
+                        // if firstArg has type T&&, then &firstArg has type T*&.
+                        // Cast away the reference to a value type so that the argument
+                        // matches the assignment's parameter types
+                        if ( dynamic_cast<ReferenceType *>( addrArg->get_result() ) ) {
+                                addrArg = new CastExpr( addrArg, addrArg->get_result()->stripReferences()->clone() );
+                        }
+                        assign->get_args().push_back( addrArg );
+                        firstArg = new VariableExpr( tmp );
+
+                        // for constructor expr:
+                        //   T x;
+                        //   x{};
+                        // results in:
+                        //   T x;
+                        //   T & tmp;
+                        //   &tmp = &x, ?{}(tmp), tmp
+                        CommaExpr * commaExpr = new CommaExpr( assign, new CommaExpr( callExpr, new VariableExpr( tmp ) ) );
                         commaExpr->set_env( env );
-                        delete ctorExpr;
                         return commaExpr;
                 }