Changeset 2463d0e for src/ResolvExpr

Timestamp:

Jul 13, 2017, 2:27:58 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

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:

65cec25

Parents:

0a81c3f

Message:

Add conversion & cast cost for reference conversions

Location:

src/ResolvExpr

Files:

• CastCost.cc (modified) (2 diffs)
• ConversionCost.cc (modified) (5 diffs)
• ConversionCost.h (modified) (4 diffs)

src/ResolvExpr/CastCost.cc

@@ -54 +54 @@
                 } else if ( dynamic_cast< VoidType* >( dest ) ) {
                         return Cost( 0, 0, 1 );
+                } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) {
+                        return convertToReferenceCost( src, refType, indexer, env );
                 } else {
                         CastCost converter( dest, indexer, env );
@@ -76 +78 @@
                         cost = Cost( 1, 0, 0 );
                 } else {
-                        ConversionCost::visit( basicType );
+                        cost = conversionCost( basicType, dest, indexer, env );
                 } // if
         }

src/ResolvExpr/ConversionCost.cc

@@ -57 +57 @@
                 } else if ( dynamic_cast< VoidType* >( dest ) ) {
                         return Cost( 0, 0, 1 );
+                } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) {
+                        // std::cerr << "conversionCost: dest is reference" << std::endl;
+                        return convertToReferenceCost( src, refType, indexer, env );
                 } else {
                         ConversionCost converter( dest, indexer, env );
@@ -66 +69 @@
                         } // if
                 } // if
+        }
+
+        Cost convertToReferenceCost( Type * src, ReferenceType * dest, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
+                // std::cerr << "convert to reference cost..." << std::endl;
+                if ( ReferenceType *srcAsRef = dynamic_cast< ReferenceType * >( src ) ) { // pointer-like conversions between references
+                        // std::cerr << "converting between references" << std::endl;
+                        if ( srcAsRef->get_base()->get_qualifiers() <= dest->get_base()->get_qualifiers() && typesCompatibleIgnoreQualifiers( srcAsRef->get_base(), dest->get_base(), indexer, env ) ) {
+                                return Cost( 0, 0, 1 );
+                        } else {  // xxx - this discards reference qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right?
+                                int assignResult = ptrsAssignable( srcAsRef->get_base(), dest->get_base(), env );
+                                if ( assignResult < 0 ) {
+                                        return Cost( 0, 0, 1 );
+                                } else if ( assignResult > 0 ) {
+                                        return Cost( 1, 0, 0 );
+                                } // if
+                        } // if
+                } else if ( typesCompatibleIgnoreQualifiers( src, dest->get_base(), indexer, env ) ) {
+                        // std::cerr << "converting compatible base type" << std::endl;
+                        if ( src->get_lvalue() ) {
+                                // std::cerr << "lvalue to reference conversion" << std::endl;
+                                // lvalue-to-reference conversion:  cv lvalue T => cv T &
+                                if ( src->get_qualifiers() == dest->get_base()->get_qualifiers() ) {
+                                        return Cost( 0, 0, 1 ); // cost needs to be non-zero to add cast
+                                } if ( src->get_qualifiers() < dest->get_base()->get_qualifiers() ) {
+                                        return Cost( 0, 0, 2 ); // cost needs to be higher than previous cast to differentiate adding qualifiers vs. keeping same
+                                } else {
+                                        return Cost( 1, 0, 0 );
+                                }
+                        } else if ( dest->get_base()->get_const() ) {
+                                // std::cerr << "rvalue to const ref conversion" << std::endl;
+                                // rvalue-to-const-reference conversion: T => const T &
+                                return Cost( 0, 0, 1 );
+                        } else {
+                                // std::cerr << "rvalue to non-const reference conversion" << std::endl;
+                                // rvalue-to-reference conversion: T => T &
+                                return Cost( 1, 0, 0 );
+                        }
+                } else {
+                        // std::cerr << "attempting to convert from incompatible base type -- fail" << std::endl;
+                }
+                return Cost::infinity;
         }
 
@@ -173 +217 @@
                         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 {
+                        } else {  // xxx - this discards pointer 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 ) {
@@ -187 +231 @@
 
         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 );
+        }
+
         void ConversionCost::visit(__attribute((unused)) FunctionType *functionType) {}
 
@@ -208 +262 @@
                 static Type::Qualifiers q;
                 static BasicType integer( q, BasicType::SignedInt );
-                integer.accept( *this );
+                integer.accept( *this );  // safe if dest >= int
                 if ( cost < Cost( 1, 0, 0 ) ) {
                         cost.incSafe();

src/ResolvExpr/ConversionCost.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// ConversionCost.h -- 
+// ConversionCost.h --
 //
 // Author           : Richard C. Bilson
@@ -26 +26 @@
           public:
                 ConversionCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env );
-  
+
                 Cost get_cost() const { return cost; }
 
@@ -33 +33 @@
                 virtual void visit(PointerType *pointerType);
                 virtual void visit(ArrayType *arrayType);
+                virtual void visit(ReferenceType *refType);
                 virtual void visit(FunctionType *functionType);
                 virtual void visit(StructInstType *aggregateUseType);
@@ -49 +50 @@
                 const TypeEnvironment &env;
         };
+
+        Cost convertToReferenceCost( Type * src, ReferenceType * dest, const SymTab::Indexer & indexer, const TypeEnvironment & env );
 } // namespace ResolvExpr