Changeset 00ac42e for src/ResolvExpr/Unify.cc

Timestamp:

Jun 1, 2018, 2:54:55 PM (7 years ago)

Author:

Aaron Moss <a3moss@…>

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, with_gc

Children:

262bd63

Parents:

41e16b1

git-author:

Aaron Moss <a3moss@…> (05/31/18 16:24:49)

git-committer:

Aaron Moss <a3moss@…> (06/01/18 14:54:55)

Message:

stop eagerly copying EqvClass? on lookup

File:

• src/ResolvExpr/Unify.cc (modified) (6 diffs)

src/ResolvExpr/Unify.cc

@@ -20 +20 @@
 #include <set>                    // for set
 #include <string>                 // for string, operator==, operator!=, bas...
-#include <utility>                // for pair
+#include <utility>                // for pair, move
 
 #include "Common/PassVisitor.h"   // for PassVisitor
@@ -166 +166 @@
                         return false;
                 } // if
-                EqvClass curClass;
-                if ( env.lookup( typeInst->get_name(), curClass ) ) {
-                        if ( curClass.type ) {
+                if ( const EqvClass *curClass = env.lookup( typeInst->get_name() ) ) {
+                        if ( curClass->type ) {
                                 Type *common = 0;
                                 // attempt to unify equivalence class type (which has qualifiers stripped, so they must be restored) with the type to bind to
-                                std::unique_ptr< Type > newType( curClass.type->clone() );
+                                std::unique_ptr< Type > newType( curClass->type->clone() );
                                 newType->get_qualifiers() = typeInst->get_qualifiers();
-                                if ( unifyInexact( newType.get(), other, env, needAssertions, haveAssertions, openVars, widenMode & WidenMode( curClass.allowWidening, true ), indexer, common ) ) {
+                                if ( unifyInexact( newType.get(), other, env, needAssertions, haveAssertions, openVars, widenMode & WidenMode( curClass->allowWidening, true ), indexer, common ) ) {
                                         if ( common ) {
                                                 common->get_qualifiers() = Type::Qualifiers();
-                                                delete curClass.type;
-                                                curClass.type = common;
-                                                env.add( curClass );
+                                                env.add( EqvClass{ *curClass, common } );
                                         } // if
                                         return true;
@@ -185 +182 @@
                                 } // if
                         } else {
-                                curClass.type = other->clone();
-                                curClass.type->get_qualifiers() = Type::Qualifiers();
-                                curClass.allowWidening = widenMode.widenFirst && widenMode.widenSecond;
-                                env.add( curClass );
+                                EqvClass newClass { *curClass, other };
+                                newClass.type->get_qualifiers() = Type::Qualifiers();
+                                newClass.allowWidening = widenMode.widenFirst && widenMode.widenSecond;
+                                env.add( std::move(newClass) );
                         } // if
                 } else {
@@ -204 +201 @@
         bool bindVarToVar( TypeInstType *var1, TypeInstType *var2, const TypeDecl::Data & data, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
                 bool result = true;
-                EqvClass class1, class2;
-                bool hasClass1 = false, hasClass2 = false;
+                const EqvClass *class1 = env.lookup( var1->get_name() );
+                const EqvClass *class2 = env.lookup( var2->get_name() );
                 bool widen1 = false, widen2 = false;
-                Type *type1 = 0, *type2 = 0;
-
-                if ( env.lookup( var1->get_name(), class1 ) ) {
-                        hasClass1 = true;
-                        if ( class1.type ) {
-                                if ( occurs( class1.type, var2->get_name(), env ) ) {
+                Type *type1 = nullptr, *type2 = nullptr;
+
+                if ( class1 ) {
+                        if ( class1->type ) {
+                                if ( occurs( class1->type, var2->get_name(), env ) ) {
                                         return false;
                                 } // if
-                                type1 = class1.type->clone();
-                        } // if
-                        widen1 = widenMode.widenFirst && class1.allowWidening;
-                } // if
-                if ( env.lookup( var2->get_name(), class2 ) ) {
-                        hasClass2 = true;
-                        if ( class2.type ) {
-                                if ( occurs( class2.type, var1->get_name(), env ) ) {
+                                type1 = class1->type->clone();
+                        } // if
+                        widen1 = widenMode.widenFirst && class1->allowWidening;
+                } // if
+                if ( class2 ) {
+                        if ( class2->type ) {
+                                if ( occurs( class2->type, var1->get_name(), env ) ) {
                                         return false;
                                 } // if
-                                type2 = class2.type->clone();
-                        } // if
-                        widen2 = widenMode.widenSecond && class2.allowWidening;
+                                type2 = class2->type->clone();
+                        } // if
+                        widen2 = widenMode.widenSecond && class2->allowWidening;
                 } // if
 
@@ -235 +230 @@
                         Type *common = 0;
                         if ( unifyInexact( type1, type2, env, needAssertions, haveAssertions, openVars, newWidenMode, indexer, common ) ) {
-                                class1.vars.insert( class2.vars.begin(), class2.vars.end() );
-                                class1.allowWidening = widen1 && widen2;
+                                EqvClass newClass1 = *class1;
+                                newClass1.vars.insert( class2->vars.begin(), class2->vars.end() );
+                                newClass1.allowWidening = widen1 && widen2;
                                 if ( common ) {
                                         common->get_qualifiers() = Type::Qualifiers();
-                                        delete class1.type;
-                                        class1.type = common;
+                                        delete newClass1.type;
+                                        newClass1.type = common;
                                 } // if
-                                env.add( class1 );
+                                env.add( std::move(newClass1) );
                         } else {
                                 result = false;
                         } // if
-                } else if ( hasClass1 && hasClass2 ) {
+                } else if ( class1 && class2 ) {
                         if ( type1 ) {
-                                class1.vars.insert( class2.vars.begin(), class2.vars.end() );
-                                class1.allowWidening = widen1;
-                                env.add( class1 );
+                                EqvClass newClass1 = *class1;
+                                newClass1.vars.insert( class2->vars.begin(), class2->vars.end() );
+                                newClass1.allowWidening = widen1;
+                                env.add( std::move(newClass1) );
                         } else {
-                                class2.vars.insert( class1.vars.begin(), class1.vars.end() );
-                                class2.allowWidening = widen2;
-                                env.add( class2 );
-                        } // if
-                } else if ( hasClass1 ) {
-                        class1.vars.insert( var2->get_name() );
-                        class1.allowWidening = widen1;
-                        env.add( class1 );
-                } else if ( hasClass2 ) {
-                        class2.vars.insert( var1->get_name() );
-                        class2.allowWidening = widen2;
-                        env.add( class2 );
+                                EqvClass newClass2 = *class2;
+                                newClass2.vars.insert( class1->vars.begin(), class1->vars.end() );
+                                newClass2.allowWidening = widen2;
+                                env.add( std::move(newClass2) );
+                        } // if
+                } else if ( class1 ) {
+                        EqvClass newClass1 = *class1;
+                        newClass1.vars.insert( var2->get_name() );
+                        newClass1.allowWidening = widen1;
+                        env.add( std::move(newClass1) );
+                } else if ( class2 ) {
+                        EqvClass newClass2 = *class2;
+                        newClass2.vars.insert( var1->get_name() );
+                        newClass2.allowWidening = widen2;
+                        env.add( std::move(newClass2) );
                 } else {
                         EqvClass newClass;
@@ -539 +539 @@
                 void premutate( TypeInstType * ) { visit_children = false; }
                 Type * postmutate( TypeInstType * typeInst ) {
-                        EqvClass eqvClass;
-                        if ( tenv.lookup( typeInst->get_name(), eqvClass ) ) {
-                                if ( eqvClass.data.kind == TypeDecl::Ttype ) {
-                                        // expand ttype parameter into its actual type
-                                        if ( eqvClass.type ) {
-                                                delete typeInst;
-                                                return eqvClass.type->clone();
-                                        }
+                        if ( const EqvClass *eqvClass = tenv.lookup( typeInst->get_name() ) ) {
+                                // expand ttype parameter into its actual type
+                                if ( eqvClass->data.kind == TypeDecl::Ttype && eqvClass->type ) {
+                                        delete typeInst;
+                                        return eqvClass->type->clone();
                                 }
                         }