Changeset 28e58fd for src/ResolvExpr/ConversionCost.cc

Timestamp:

Aug 25, 2017, 10:38:34 AM (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:

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/ResolvExpr/ConversionCost.cc (modified) (11 diffs)

src/ResolvExpr/ConversionCost.cc

@@ -28 +28 @@
 
 namespace ResolvExpr {
-        const Cost Cost::zero = Cost( 0, 0, 0 );
-        const Cost Cost::infinity = Cost( -1, -1, -1 );
+        const Cost Cost::zero = Cost( 0, 0, 0, 0 );
+        const Cost Cost::infinity = Cost( -1, -1, -1, -1 );
+        const Cost Cost::unsafe = Cost( 1, 0, 0, 0 );
+        const Cost Cost::poly = Cost( 0, 1, 0, 0 );
+        const Cost Cost::safe = Cost( 0, 0, 1, 0 );
+        const Cost Cost::reference = Cost( 0, 0, 0, 1 );
+
+#if 0
+#define PRINT(x) x
+#else
+#define PRINT(x)
+#endif
 
         Cost conversionCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
@@ -35 +45 @@
                         EqvClass eqvClass;
                         NamedTypeDecl *namedType;
-///     std::cout << "type inst " << destAsTypeInst->get_name();
+                        PRINT( std::cerr << "type inst " << destAsTypeInst->get_name(); )
                         if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
                                 if ( eqvClass.type ) {
@@ -43 +53 @@
                                 }
                         } else if ( ( namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) ) {
-///       std::cout << " found" << std::endl;
+                                PRINT( std::cerr << " found" << std::endl; )
                                 TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );
                                 // all typedefs should be gone by this point
                                 assert( type );
                                 if ( type->get_base() ) {
-                                        return conversionCost( src, type->get_base(), indexer, env ) + Cost( 0, 0, 1 );
+                                        return conversionCost( src, type->get_base(), indexer, env ) + Cost::safe;
                                 } // if
                         } // if
-///     std::cout << " not found" << std::endl;
-                } // if
-///   std::cout << "src is ";
-///   src->print( std::cout );
-///   std::cout << std::endl << "dest is ";
-///   dest->print( std::cout );
-///   std::cout << std::endl << "env is" << std::endl;
-///   env.print( std::cout, 8 );
+                        PRINT( std::cerr << " not found" << std::endl; )
+                } // if
+                PRINT(
+                        std::cerr << "src is ";
+                        src->print( std::cerr );
+                        std::cerr << std::endl << "dest is ";
+                        dest->print( std::cerr );
+                        std::cerr << std::endl << "env is" << std::endl;
+                        env.print( std::cerr, 8 );
+                )
                 if ( typesCompatibleIgnoreQualifiers( src, dest, indexer, env ) ) {
-///     std::cout << "compatible!" << std::endl;
-                        return Cost( 0, 0, 0 );
+                        PRINT( std::cerr << "compatible!" << std::endl; )
+                        return Cost::zero;
                 } else if ( dynamic_cast< VoidType* >( dest ) ) {
-                        return Cost( 0, 0, 1 );
+                        return Cost::safe;
+                } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) {
+                        PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
+                        return convertToReferenceCost( src, refType, indexer, env );
                 } else {
                         ConversionCost converter( dest, indexer, env );
@@ -70 +85 @@
                                 return Cost::infinity;
                         } else {
-                                return converter.get_cost() + Cost( 0, 0, 0 );
-                        } // if
-                } // if
+                                return converter.get_cost() + Cost::zero;
+                        } // if
+                } // if
+        }
+
+        Cost convertToReferenceCost( Type * src, Type * dest, int diff, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
+                PRINT( std::cerr << "convert to reference cost..." << std::endl; )
+                if ( diff > 0 ) {
+                        // TODO: document this
+                        Cost cost = convertToReferenceCost( safe_dynamic_cast< ReferenceType * >( src )->get_base(), dest, diff-1, indexer, env );
+                        cost.incReference();
+                        return cost;
+                } else if ( diff < -1 ) {
+                        // TODO: document this
+                        Cost cost = convertToReferenceCost( src, safe_dynamic_cast< ReferenceType * >( dest )->get_base(), diff+1, indexer, env );
+                        cost.incReference();
+                        return cost;
+                } else if ( diff == 0 ) {
+                        ReferenceType * srcAsRef = dynamic_cast< ReferenceType * >( src );
+                        ReferenceType * destAsRef = dynamic_cast< ReferenceType * >( dest );
+                        if ( srcAsRef && destAsRef ) { // pointer-like conversions between references
+                                PRINT( std::cerr << "converting between references" << std::endl; )
+                                if ( srcAsRef->get_base()->get_qualifiers() <= destAsRef->get_base()->get_qualifiers() && typesCompatibleIgnoreQualifiers( srcAsRef->get_base(), destAsRef->get_base(), indexer, env ) ) {
+                                        return Cost::safe;
+                                } else {  // xxx - this discards reference qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right?
+                                        int assignResult = ptrsAssignable( srcAsRef->get_base(), destAsRef->get_base(), env );
+                                        PRINT( std::cerr << "comparing references: " << assignResult << " " << srcAsRef << " " << destAsRef << std::endl; )
+                                        if ( assignResult < 0 ) {
+                                                return Cost::safe;
+                                        } else if ( assignResult > 0 ) {
+                                                return Cost::unsafe;
+                                        } // if
+                                } // if
+                        } else {
+                                PRINT( std::cerr << "reference to rvalue conversion" << std::endl; )
+                                ConversionCost converter( dest, indexer, env );
+                                src->accept( converter );
+                                return converter.get_cost();
+                        } // if
+                } else {
+                        ReferenceType * destAsRef = dynamic_cast< ReferenceType * >( dest );
+                        assert( diff == -1 && destAsRef );
+                        if ( typesCompatibleIgnoreQualifiers( src, destAsRef->get_base(), indexer, env ) ) {
+                                PRINT( std::cerr << "converting compatible base type" << std::endl; )
+                                if ( src->get_lvalue() ) {
+                                        PRINT(
+                                                std::cerr << "lvalue to reference conversion" << std::endl;
+                                                std::cerr << src << " => " << destAsRef << std::endl;
+                                        )
+                                        // lvalue-to-reference conversion:  cv lvalue T => cv T &
+                                        if ( src->get_qualifiers() == destAsRef->get_base()->get_qualifiers() ) {
+                                                return Cost::reference; // cost needs to be non-zero to add cast
+                                        } if ( src->get_qualifiers() < destAsRef->get_base()->get_qualifiers() ) {
+                                                return Cost::safe; // cost needs to be higher than previous cast to differentiate adding qualifiers vs. keeping same
+                                        } else {
+                                                return Cost::unsafe;
+                                        } // if
+                                } else if ( destAsRef->get_base()->get_const() ) {
+                                        PRINT( std::cerr << "rvalue to const ref conversion" << std::endl; )
+                                        // rvalue-to-const-reference conversion: T => const T &
+                                        return Cost::safe;
+                                } else {
+                                        PRINT( std::cerr << "rvalue to non-const reference conversion" << std::endl; )
+                                        // rvalue-to-reference conversion: T => T &
+                                        return Cost::unsafe;
+                                } // if
+                        } // if
+                        PRINT( std::cerr << "attempting to convert from incompatible base type -- fail" << std::endl; )
+                }
+                return Cost::infinity;
+        }
+
+        Cost convertToReferenceCost( Type * src, ReferenceType * dest, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
+                int sdepth = src->referenceDepth(), ddepth = dest->referenceDepth();
+                return convertToReferenceCost( src, dest, sdepth-ddepth, indexer, env );
         }
 
@@ -164 +251 @@
                         int tableResult = costMatrix[ basicType->get_kind() ][ destAsBasic->get_kind() ];
                         if ( tableResult == -1 ) {
-                                cost = Cost( 1, 0, 0 );
-                        } else {
-                                cost = Cost( 0, 0, tableResult );
+                                cost = Cost::unsafe;
+                        } else {
+                                cost = Cost::zero;
+                                cost.incSafe( tableResult );
                         } // if
                 } else if ( dynamic_cast< EnumInstType *>( dest ) ) {
                         // xxx - not positive this is correct, but appears to allow casting int => enum
-                        cost = Cost( 1, 0, 0 );
+                        cost = Cost::unsafe;
                 } else if ( dynamic_cast< ZeroType* >( dest ) != nullptr || dynamic_cast< OneType* >( dest ) != nullptr ) {
-                        cost = Cost( 1, 0, 0 );
+                        cost = Cost::unsafe;
                 } // if
         }
@@ -178 +266 @@
         void ConversionCost::visit(PointerType *pointerType) {
                 if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
-                        if ( pointerType->get_base()->get_qualifiers() <= destAsPtr->get_base()->get_qualifiers() && typesCompatibleIgnoreQualifiers( pointerType->get_base(), destAsPtr->get_base(), indexer, env ) ) {
-                                cost = Cost( 0, 0, 1 );
-                        } else {
+                        PRINT( std::cerr << pointerType << " ===> " << destAsPtr; )
+                        Type::Qualifiers tq1 = pointerType->get_base()->get_qualifiers();
+                        Type::Qualifiers tq2 = destAsPtr->get_base()->get_qualifiers();
+                        if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( pointerType->get_base(), destAsPtr->get_base(), indexer, env ) ) {
+                                if ( tq1 == tq2 ) {
+                                        // types are the same
+                                        cost = Cost::zero;
+                                } else {
+                                        // types are the same, except otherPointer has more qualifiers
+                                        PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; )
+                                        cost = Cost::safe;
+                                }
+                        } else {  // xxx - this discards qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right?
                                 int assignResult = ptrsAssignable( pointerType->get_base(), destAsPtr->get_base(), env );
-                                if ( assignResult < 0 ) {
-                                        cost = Cost( 0, 0, 1 );
+                                PRINT( std::cerr << " :: " << assignResult << std::endl; )
+                                if ( assignResult < 0 && pointerType->get_base()->get_qualifiers() <= destAsPtr->get_qualifiers() ) {
+                                        cost = Cost::safe;
                                 } else if ( assignResult > 0 ) {
-                                        cost = Cost( 1, 0, 0 );
+                                        cost = Cost::unsafe;
                                 } // if
+                                // assignResult == 0 means Cost::Infinity
                         } // if
                 } else if ( dynamic_cast< ZeroType* >( dest ) != nullptr || dynamic_cast< OneType* >( dest ) != nullptr ) {
-                        cost = Cost( 1, 0, 0 );
+                        cost = Cost::unsafe;
                 } // if
         }
 
         void ConversionCost::visit(__attribute((unused)) ArrayType *arrayType) {}
+
+        void ConversionCost::visit(ReferenceType *refType) {
+                // Note: dest can never be a reference, since it would have been caught in an earlier check
+                assert( ! dynamic_cast< ReferenceType * >( dest ) );
+                // convert reference to rvalue: cv T1 & => T2
+                // recursively compute conversion cost from T1 to T2.
+                // cv can be safely dropped because of 'implicit dereference' behavior.
+                refType->get_base()->accept( *this );
+                if ( refType->get_base()->get_qualifiers() == dest->get_qualifiers() ) {
+                        cost.incReference();  // prefer exact qualifiers
+                } else if ( refType->get_base()->get_qualifiers() < dest->get_qualifiers() ) {
+                        cost.incSafe(); // then gaining qualifiers
+                } else {
+                        cost.incUnsafe(); // lose qualifiers as last resort
+                }
+                PRINT( std::cerr << refType << " ==> " << dest << " " << cost << std::endl; )
+        }
+
         void ConversionCost::visit(__attribute((unused)) FunctionType *functionType) {}
 
@@ -215 +333 @@
                 static Type::Qualifiers q;
                 static BasicType integer( q, BasicType::SignedInt );
-                integer.accept( *this );
-                if ( cost < Cost( 1, 0, 0 ) ) {
+                integer.accept( *this );  // safe if dest >= int
+                if ( cost < Cost::unsafe ) {
                         cost.incSafe();
                 } // if
@@ -238 +356 @@
                         assert( type );
                         if ( type->get_base() ) {
-                                cost = conversionCost( type->get_base(), dest, indexer, env ) + Cost( 0, 0, 1 );
+                                cost = conversionCost( type->get_base(), dest, indexer, env ) + Cost::safe;
                         } // if
                 } // if
@@ -244 +362 @@
 
         void ConversionCost::visit( __attribute((unused)) TupleType *tupleType) {
-                Cost c;
+                Cost c = Cost::zero;
                 if ( TupleType *destAsTuple = dynamic_cast< TupleType* >( dest ) ) {
                         std::list< Type* >::const_iterator srcIt = tupleType->get_types().begin();
@@ -276 +394 @@
                         int tableResult = costMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ];
                         if ( tableResult == -1 ) {
-                                cost = Cost( 1, 0, 0 );
-                        } else {
-                                cost = Cost( 0, 0, tableResult + 1 );
+                                cost = Cost::unsafe;
+                        } else {
+                                cost = Cost::zero;
+                                cost.incSafe( tableResult + 1 );
                         }
                 } else if ( dynamic_cast< PointerType* >( dest ) ) {
-                        cost = Cost( 0, 0, 1 );
+                        cost = Cost::safe;
                 }
         }
@@ -292 +411 @@
                         int tableResult = costMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ];
                         if ( tableResult == -1 ) {
-                                cost = Cost( 1, 0, 0 );
-                        } else {
-                                cost = Cost( 0, 0, tableResult + 1 );
+                                cost = Cost::unsafe;
+                        } else {
+                                cost = Cost::zero;
+                                cost.incSafe( tableResult + 1 );
                         }
                 }