Changeset 7ebaa56

Timestamp:

Jul 17, 2017, 3:05:57 PM (8 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:

e6cee92

Parents:

89be1c68

git-author:

Rob Schluntz <rschlunt@…> (07/17/17 14:58:13)

git-committer:

Rob Schluntz <rschlunt@…> (07/17/17 15:05:57)

Message:

Add reference cost field to cost tuple

Location:

src/ResolvExpr

Files:

• ConversionCost.cc (modified) (4 diffs)
• Cost.h (modified) (9 diffs)

src/ResolvExpr/ConversionCost.cc

@@ -21 +21 @@
 
 namespace ResolvExpr {
-        const Cost Cost::zero = Cost( 0, 0, 0 );
-        const Cost Cost::infinity = Cost( -1, -1, -1 );
-        const Cost Cost::unsafe = Cost( 1, 0, 0 );
-        const Cost Cost::poly = Cost( 0, 1, 0 );
-        const Cost Cost::safe = Cost( 0, 0, 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 );
 
 
@@ -80 +81 @@
                         // TODO: document this
                         Cost cost = convertToReferenceCost( safe_dynamic_cast< ReferenceType * >( src )->get_base(), dest, diff-1, indexer, env );
-                        // TODO: increment reference cost
-                        cost.incSafe();
+                        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 );
-                        // TODO: increment reference cost
-                        cost.incSafe();
+                        cost.incReference();
                         return cost;
                 } else if ( diff == 0 ) {
@@ -119 +118 @@
                                         // lvalue-to-reference conversion:  cv lvalue T => cv T &
                                         if ( src->get_qualifiers() == destAsRef->get_base()->get_qualifiers() ) {
-                                                return Cost::safe; // cost needs to be non-zero to add cast
+                                                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::safe; // cost needs to be higher than previous cast to differentiate adding qualifiers vs. keeping same
+                                                return Cost::safe; // cost needs to be higher than previous cast to differentiate adding qualifiers vs. keeping same
                                         } else {
                                                 return Cost::unsafe;
@@ -273 +272 @@
                 // cv can be safely dropped because of 'implicit dereference' behavior.
                 refType->get_base()->accept( *this );
-                // TODO: increment reference cost
-                cost.incSafe();
+                cost.incReference();
         }
 

src/ResolvExpr/Cost.h

@@ -22 +22 @@
         class Cost {
           private:
-                Cost( int unsafeCost, int polyCost, int safeCost );
+                Cost( int unsafeCost, int polyCost, int safeCost, int referenceCost );
 
           public:
@@ -28 +28 @@
                 Cost & incPoly( int inc = 1 );
                 Cost & incSafe( int inc = 1 );
+                Cost & incReference( int inc = 1 );
 
                 Cost operator+( const Cost &other ) const;
@@ -39 +40 @@
                 static const Cost zero;
                 static const Cost infinity;
+
                 static const Cost unsafe;
                 static const Cost poly;
                 static const Cost safe;
+                static const Cost reference;
           private:
                 int compare( const Cost &other ) const;
@@ -48 +51 @@
                 int polyCost;
                 int safeCost;
+                int referenceCost;
         };
 
-        inline Cost::Cost( int unsafeCost, int polyCost, int safeCost ) : unsafeCost( unsafeCost ), polyCost( polyCost ), safeCost( safeCost ) {}
+        inline Cost::Cost( int unsafeCost, int polyCost, int safeCost, int referenceCost ) : unsafeCost( unsafeCost ), polyCost( polyCost ), safeCost( safeCost ), referenceCost( referenceCost ) {}
 
         inline Cost & Cost::incUnsafe( int inc ) {
@@ -67 +71 @@
         }
 
+        inline Cost & Cost::incReference( int inc ) {
+                referenceCost += inc;
+                return *this;
+        }
+
         inline Cost Cost::operator+( const Cost &other ) const {
-                return Cost( unsafeCost + other.unsafeCost, polyCost + other.polyCost, safeCost + other.safeCost );
+                return Cost( unsafeCost + other.unsafeCost, polyCost + other.polyCost, safeCost + other.safeCost, referenceCost + other.referenceCost );
         }
 
         inline Cost Cost::operator-( const Cost &other ) const {
-                return Cost( unsafeCost - other.unsafeCost, polyCost - other.polyCost, safeCost - other.safeCost );
+                return Cost( unsafeCost - other.unsafeCost, polyCost - other.polyCost, safeCost - other.safeCost, referenceCost - other.referenceCost );
         }
 
@@ -79 +88 @@
                 polyCost += other.polyCost;
                 safeCost += other.safeCost;
+                referenceCost += other.referenceCost;
                 return *this;
         }
@@ -98 +108 @@
                 } else if ( safeCost < other.safeCost ) {
                         return true;
+                } else if ( referenceCost > other.referenceCost ) {
+                        return false;
+                } else if ( referenceCost < other.referenceCost ) {
+                        return true;
                 } else {
                         return false;
@@ -106 +120 @@
                 return unsafeCost == other.unsafeCost
                         && polyCost == other.polyCost
-                        && safeCost == other.safeCost;
+                        && safeCost == other.safeCost
+                        && referenceCost == other.referenceCost;
         }
 
@@ -114 +129 @@
 
         inline std::ostream &operator<<( std::ostream &os, const Cost &cost ) {
-                os << "( " << cost.unsafeCost << ", " << cost.polyCost << ", " << cost.safeCost << " )";
+                os << "( " << cost.unsafeCost << ", " << cost.polyCost << ", " << cost.safeCost << ", " << cost.referenceCost << " )";
                 return os;
         }