Changeset caa649b for src/InitTweak

Timestamp:

Mar 6, 2018, 12:11:11 PM (8 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:

520145b, e5d4e5c, e6c5e79

Parents:

094476d (diff), 1feb535f (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) (6 diffs)

src/InitTweak/FixInit.cc

@@ -68 +68 @@
                 typedef std::unordered_map< int, int > UnqCount;
 
+                struct SelfAssignChecker {
+                        void previsit( ApplicationExpr * appExpr );
+                };
+
                 struct InsertImplicitCalls : public WithTypeSubstitution {
                         /// wrap function application expressions as ImplicitCopyCtorExpr nodes so that it is easy to identify which
@@ -183 +187 @@
                 };
 
-                class FixCopyCtors final : public WithStmtsToAdd, public WithShortCircuiting, public WithVisitorRef<FixCopyCtors> {
+                class FixCopyCtors final : public WithStmtsToAdd, public WithShortCircuiting, public WithVisitorRef<FixCopyCtors>, public WithTypeSubstitution {
                   public:
                         FixCopyCtors( UnqCount & unqCount ) : unqCount( unqCount ){}
@@ -235 +239 @@
 
         void fix( std::list< Declaration * > & translationUnit, const std::string & filename, bool inLibrary ) {
+                PassVisitor<SelfAssignChecker> checker;
+                acceptAll( translationUnit, checker );
+
                 // fixes ConstructorInit for global variables. should happen before fixInitializers.
                 InitTweak::fixGlobalInit( translationUnit, filename, inLibrary );
@@ -311 +318 @@
                 }
 
+                namespace {
+                        // Relatively simple structural comparison for expressions, needed to determine
+                        // if two expressions are "the same" (used to determine if self assignment occurs)
+                        struct StructuralChecker {
+                                Expression * stripCasts( Expression * expr ) {
+                                        // this might be too permissive. It's possible that only particular casts are relevant.
+                                        while ( CastExpr * cast = dynamic_cast< CastExpr * >( expr ) ) {
+                                                expr = cast->arg;
+                                        }
+                                        return expr;
+                                }
+
+                                void previsit( Expression * ) {
+                                        // anything else does not qualify
+                                        isSimilar = false;
+                                }
+
+                                template<typename T>
+                                T * cast( Expression * node ) {
+                                        // all expressions need to ignore casts, so this bit has been factored out
+                                        return dynamic_cast< T * >( stripCasts( node ) );
+                                }
+
+                                // ignore casts
+                                void previsit( CastExpr * ) {}
+
+                                void previsit( MemberExpr * memExpr ) {
+                                        if ( MemberExpr * otherMember = cast< MemberExpr >( other ) ) {
+                                                if ( otherMember->member == memExpr->member ) {
+                                                        other = otherMember->aggregate;
+                                                        return;
+                                                }
+                                        }
+                                        isSimilar = false;
+                                }
+
+                                void previsit( VariableExpr * varExpr ) {
+                                        if ( VariableExpr * otherVar = cast< VariableExpr >( other ) ) {
+                                                if ( otherVar->var == varExpr->var ) {
+                                                        return;
+                                                }
+                                        }
+                                        isSimilar = false;
+                                }
+
+                                void previsit( AddressExpr * ) {
+                                        if ( AddressExpr * addrExpr = cast< AddressExpr >( other ) ) {
+                                                other = addrExpr->arg;
+                                                return;
+                                        }
+                                        isSimilar = false;
+                                }
+
+                                Expression * other = nullptr;
+                                bool isSimilar = true;
+                        };
+
+                        bool structurallySimilar( Expression * e1, Expression * e2 ) {
+                                PassVisitor<StructuralChecker> checker;
+                                checker.pass.other = e2;
+                                e1->accept( checker );
+                                return checker.pass.isSimilar;
+                        }
+                }
+
+                void SelfAssignChecker::previsit( ApplicationExpr * appExpr ) {
+                        DeclarationWithType * function = getFunction( appExpr );
+                        if ( isAssignment( function ) ) {
+                                if ( appExpr->args.size() == 2 ) {
+                                        // check for structural similarity (same variable use, ignore casts, etc. - but does not look too deeply, anything looking like a function is off limits)
+                                        if ( structurallySimilar( appExpr->args.front(), appExpr->args.back() ) ) {
+                                                SemanticWarning( appExpr->location, Warning::SelfAssignment, toCString( appExpr->args.front() ) );
+                                        }
+                                }
+                        }
+                }
+
                 Expression * InsertImplicitCalls::postmutate( ApplicationExpr * appExpr ) {
                         if ( VariableExpr * function = dynamic_cast< VariableExpr * > ( appExpr->get_function() ) ) {
@@ -364 +448 @@
                         ResolvExpr::findVoidExpression( resolved, indexer );
                         assert( resolved );
-                        if ( resolved->get_env() ) {
+                        if ( resolved->env ) {
                                 // Extract useful information and discard new environments. Keeping them causes problems in PolyMutator passes.
-                                env->add( *resolved->get_env() );
-                                delete resolved->get_env();
-                                resolved->set_env( nullptr );
+                                env->add( *resolved->env );
+                                delete resolved->env;
+                                resolved->env = nullptr;
                         } // if
                         delete stmt;
@@ -550 +634 @@
                         // add destructors after current statement
                         for ( Expression * dtor : dtors ) {
+                                // take relevant bindings from environment
+                                assert( ! dtor->env );
+                                dtor->env =  maybeClone( env );
                                 stmtsToAddAfter.push_back( new ExprStmt( dtor ) );
                         } // for