Changeset 89be1c68

Timestamp:

Jul 17, 2017, 2:35:52 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:

7ebaa56

Parents:

b46e3bd

Message:

Remove Cost constructors, use only named members

This change makes it easier to read code involving costs, since in almost every case, only a single part of the cost tuple is relevant. Furthermore, this change makes it much simpler to add another dimension to the cost tuple, since only Cost.h needs to be updated, rather than every location using the cost constructor.

Location:

src/ResolvExpr

Files:

• Alternative.cc (modified) (2 diffs)
• Alternative.h (modified) (1 diff)
• AlternativeFinder.cc (modified) (12 diffs)
• CastCost.cc (modified) (6 diffs)
• ConversionCost.cc (modified) (11 diffs)
• Cost.h (modified) (2 diffs)

src/ResolvExpr/Alternative.cc

@@ -28 +28 @@
                 : cost( cost ), cvtCost( cvtCost ), expr( expr ), env( env ) {}
 
-        Alternative::Alternative( const Alternative &other ) {
-                initialize( other, *this );
+        Alternative::Alternative( const Alternative &other ) : cost( other.cost ), cvtCost( other.cvtCost ), expr( maybeClone( other.expr ) ), env( other.env ) {
         }
 
         Alternative &Alternative::operator=( const Alternative &other ) {
                 if ( &other == this ) return *this;
-                initialize( other, *this );
+                delete expr;
+                cost = other.cost;
+                cvtCost = other.cvtCost;
+                expr = maybeClone( other.expr );
+                env = other.env;
                 return *this;
         }
@@ -51 +54 @@
                 other.expr = nullptr;
                 return *this;
-        }
-
-        void Alternative::initialize( const Alternative &src, Alternative &dest ) {
-                dest.cost = src.cost;
-                dest.cvtCost = src.cvtCost;
-                dest.expr = maybeClone( src.expr );
-                dest.env = src.env;
         }
 

src/ResolvExpr/Alternative.h

@@ -36 +36 @@
                 ~Alternative();
 
-                void initialize( const Alternative &src, Alternative &dest );
-
                 void print( std::ostream &os, int indent = 0 ) const;
 

src/ResolvExpr/AlternativeFinder.cc

@@ -67 +67 @@
 
         Cost sumCost( const AltList &in ) {
-                Cost total;
+                Cost total = Cost::zero;
                 for ( AltList::const_iterator i = in.begin(); i != in.end(); ++i ) {
                         total += i->cost;
@@ -218 +218 @@
                 if ( StructInstType *structInst = dynamic_cast< StructInstType* >( expr->get_result() ) ) {
                         NameExpr nameExpr( "" );
-                        addAggMembers( structInst, expr, alt.cost+Cost( 0, 0, 1 ), alt.env, &nameExpr );
+                        addAggMembers( structInst, expr, alt.cost+Cost::safe, alt.env, &nameExpr );
                 } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( expr->get_result() ) ) {
                         NameExpr nameExpr( "" );
-                        addAggMembers( unionInst, expr, alt.cost+Cost( 0, 0, 1 ), alt.env, &nameExpr );
+                        addAggMembers( unionInst, expr, alt.cost+Cost::safe, alt.env, &nameExpr );
                 } // if
         }
@@ -277 +277 @@
                 FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
 
-                Cost convCost( 0, 0, 0 );
+                Cost convCost = Cost::zero;
                 std::list< DeclarationWithType* >& formals = function->get_parameters();
                 std::list< DeclarationWithType* >::iterator formal = formals.begin();
@@ -290 +290 @@
                                 actualType->print( std::cerr, 8 );
                         )
-                        Cost actualCost;
+                        Cost actualCost = Cost::zero;
                         if ( formal == formals.end() ) {
                                 if ( function->get_isVarArgs() ) {
-                                        convCost += Cost( 1, 0, 0 );
+                                        convCost.incUnsafe();
                                         continue;
                                 } else {
@@ -319 +319 @@
                         convCost += newCost;
                         actualCost += newCost;
-                        if ( actualCost != Cost( 0, 0, 0 ) ) {
+                        if ( actualCost != Cost::zero ) {
                                 Type *newType = formalType->clone();
                                 alt.env.apply( newType );
                                 *actualExpr = new CastExpr( *actualExpr, newType );
                         }
-                        convCost += Cost( 0, polyCost( formalType, alt.env, indexer ) + polyCost( actualType, alt.env, indexer ), 0 );
+                        convCost.incPoly( polyCost( formalType, alt.env, indexer ) + polyCost( actualType, alt.env, indexer ) );
                         ++formal; // can't be in for-loop update because of the continue
                 }
@@ -346 +346 @@
                         }
                         convCost += newCost;
-                        convCost += Cost( 0, polyCost( assert->second.formalType, alt.env, indexer ) + polyCost( assert->second.actualType, alt.env, indexer ), 0 );
+                        convCost.incPoly( polyCost( assert->second.formalType, alt.env, indexer ) + polyCost( assert->second.actualType, alt.env, indexer ) );
                 }
 
@@ -456 +456 @@
                         // match flattened actuals with formal parameters - actuals will be grouped to match
                         // with formals as appropriate
-                        Cost cost;
+                        Cost cost = Cost::zero;
                         std::list< Expression * > newExprs;
                         ObjectDecl * obj = safe_dynamic_cast< ObjectDecl * >( formal );
@@ -668 +668 @@
                                 UntypedExpr *vexpr = untypedExpr->clone();
                                 vexpr->set_result( pt.clone() );
-                                alternatives.push_back( Alternative( vexpr, env, Cost()) );
+                                alternatives.push_back( Alternative( vexpr, env, Cost::zero) );
                                 return;
                         }
@@ -869 +869 @@
                         if ( thisCost != Cost::infinity ) {
                                 // count one safe conversion for each value that is thrown away
-                                thisCost += Cost( 0, 0, discardedValues );
+                                thisCost.incSafe( discardedValues );
 
                                 candidates.push_back( Alternative( restructureCast( i->expr->clone(), toType ), i->env, i->cost, thisCost ) );
@@ -916 +916 @@
                 for ( std::list< DeclarationWithType* >::iterator i = declList.begin(); i != declList.end(); ++i ) {
                         VariableExpr newExpr( *i, nameExpr->get_argName() );
-                        alternatives.push_back( Alternative( newExpr.clone(), env, Cost() ) );
+                        alternatives.push_back( Alternative( newExpr.clone(), env, Cost::zero ) );
                         PRINT(
                                 std::cerr << "decl is ";
@@ -1060 +1060 @@
                         for ( std::list< DeclarationWithType* >::iterator i = attrList.begin(); i != attrList.end(); ++i ) {
                                 VariableExpr newExpr( *i );
-                                alternatives.push_back( Alternative( newExpr.clone(), env, Cost() ) );
+                                alternatives.push_back( Alternative( newExpr.clone(), env, Cost::zero ) );
                                 renameTypes( alternatives.back().expr );
                         } // for
@@ -1233 +1233 @@
                                 if ( thisCost != Cost::infinity ) {
                                         // count one safe conversion for each value that is thrown away
-                                        thisCost += Cost( 0, 0, discardedValues );
+                                        thisCost.incSafe( discardedValues );
                                         candidates.push_back( Alternative( new InitExpr( restructureCast( alt.expr->clone(), toType ), initAlt.designation->clone() ), newEnv, alt.cost, thisCost ) );
                                 }

src/ResolvExpr/CastCost.cc

@@ -46 +46 @@
                                 assert( type );
                                 if ( type->get_base() ) {
-                                        return castCost( src, type->get_base(), indexer, env ) + Cost( 0, 0, 1 );
+                                        return castCost( src, type->get_base(), indexer, env ) + Cost::safe;
                                 } // if
                         } // if
                 } // if
                 if ( typesCompatibleIgnoreQualifiers( src, dest, indexer, env ) ) {
-                        return Cost( 0, 0, 0 );
+                        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 ) ) {
                         return convertToReferenceCost( src, refType, indexer, env );
@@ -63 +63 @@
                         } else {
                                 // xxx - why are we adding cost 0 here?
-                                return converter.get_cost() + Cost( 0, 0, 0 );
+                                return converter.get_cost() + Cost::zero;
                         } // if
                 } // if
@@ -76 +76 @@
                 if ( destAsPointer && basicType->isInteger() ) {
                         // necessary for, e.g. unsigned long => void*
-                        cost = Cost( 1, 0, 0 );
+                        cost = Cost::unsafe;
                 } else {
                         cost = conversionCost( basicType, dest, indexer, env );
@@ -85 +85 @@
                 if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
                         if ( pointerType->get_qualifiers() <= destAsPtr->get_qualifiers() && typesCompatibleIgnoreQualifiers( pointerType->get_base(), destAsPtr->get_base(), indexer, env ) ) {
-                                cost = Cost( 0, 0, 1 );
+                                cost = Cost::safe;
                         } else {
                                 TypeEnvironment newEnv( env );
@@ -92 +92 @@
                                 int castResult = ptrsCastable( pointerType->get_base(), destAsPtr->get_base(), newEnv, indexer );
                                 if ( castResult > 0 ) {
-                                        cost = Cost( 0, 0, 1 );
+                                        cost = Cost::safe;
                                 } else if ( castResult < 0 ) {
                                         cost = Cost::infinity;
@@ -100 +100 @@
                         if ( destAsBasic->isInteger() ) {
                                 // necessary for, e.g. void* => unsigned long
-                                cost = Cost( 1, 0, 0 );
+                                cost = Cost::unsafe;
                         } // if
                 }

src/ResolvExpr/ConversionCost.cc

@@ -45 +45 @@
                                 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
@@ -58 +58 @@
                 if ( typesCompatibleIgnoreQualifiers( src, dest, indexer, env ) ) {
 ///     std::cout << "compatible!" << std::endl;
-                        return Cost( 0, 0, 0 );
+                        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 ) ) {
                         // std::cerr << "conversionCost: dest is reference" << std::endl;
@@ -70 +70 @@
                                 return Cost::infinity;
                         } else {
-                                return converter.get_cost() + Cost( 0, 0, 0 );
-                        } // 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
+                                return converter.get_cost() + Cost::zero;
+                        } // if
+                } // if
+        }
+
+        Cost convertToReferenceCost( Type * src, Type * dest, int diff, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
+                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 );
+                        // TODO: increment reference cost
+                        cost.incSafe();
+                        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();
+                        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
+                                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 );
+                                        if ( assignResult < 0 ) {
+                                                return Cost::safe;
+                                        } else if ( assignResult > 0 ) {
+                                                return Cost::unsafe;
+                                        } // if
+                                } // if
+                        } else {
+                                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 ) ) {
+                                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() == destAsRef->get_base()->get_qualifiers() ) {
+                                                return Cost::safe; // 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
+                                        } else {
+                                                return Cost::unsafe;
+                                        } // if
+                                } else if ( destAsRef->get_base()->get_const() ) {
+                                        std::cerr << "rvalue to const ref conversion" << std::endl;
+                                        // rvalue-to-const-reference conversion: T => const T &
+                                        return Cost::safe;
                                 } 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;
+                                        // std::cerr << "rvalue to non-const reference conversion" << std::endl;
+                                        // rvalue-to-reference conversion: T => T &
+                                        return Cost::unsafe;
+                                } // if
+                        } // if
+                        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 );
         }
 
@@ -205 +234 @@
                         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
         }
@@ -220 +250 @@
                 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 );
+                                cost = Cost::safe;
                         } 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 ) {
-                                        cost = Cost( 0, 0, 1 );
+                                        cost = Cost::safe;
                                 } else if ( assignResult > 0 ) {
-                                        cost = Cost( 1, 0, 0 );
+                                        cost = Cost::unsafe;
                                 } // if
                         } // if
                 } else if ( dynamic_cast< ZeroType* >( dest ) != nullptr || dynamic_cast< OneType* >( dest ) != nullptr ) {
-                        cost = Cost( 1, 0, 0 );
+                        cost = Cost::unsafe;
                 } // if
         }
@@ -243 +273 @@
                 // cv can be safely dropped because of 'implicit dereference' behavior.
                 refType->get_base()->accept( *this );
+                // TODO: increment reference cost
+                cost.incSafe();
         }
 
@@ -267 +299 @@
                 static BasicType integer( q, BasicType::SignedInt );
                 integer.accept( *this );  // safe if dest >= int
-                if ( cost < Cost( 1, 0, 0 ) ) {
+                if ( cost < Cost::unsafe ) {
                         cost.incSafe();
                 } // if
@@ -289 +321 @@
                         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
@@ -295 +327 @@
 
         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();
@@ -327 +359 @@
                         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;
                 }
         }
@@ -343 +376 @@
                         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 );
                         }
                 }

src/ResolvExpr/Cost.h

@@ -21 +21 @@
 namespace ResolvExpr {
         class Cost {
-          public:
-                Cost();
+          private:
                 Cost( int unsafeCost, int polyCost, int safeCost );
 
-                void incUnsafe( int inc = 1 );
-                void incPoly( int inc = 1 );
-                void incSafe( int inc = 1 );
+          public:
+                Cost & incUnsafe( int inc = 1 );
+                Cost & incPoly( int inc = 1 );
+                Cost & incSafe( int inc = 1 );
 
                 Cost operator+( const Cost &other ) const;
@@ -50 +50 @@
         };
 
-        inline Cost::Cost() : unsafeCost( 0 ), polyCost( 0 ), safeCost( 0 ) {}
-
         inline Cost::Cost( int unsafeCost, int polyCost, int safeCost ) : unsafeCost( unsafeCost ), polyCost( polyCost ), safeCost( safeCost ) {}
 
-        inline void Cost::incUnsafe( int inc ) {
+        inline Cost & Cost::incUnsafe( int inc ) {
                 unsafeCost += inc;
+                return *this;
         }
 
-        inline void Cost::incPoly( int inc ) {
+        inline Cost & Cost::incPoly( int inc ) {
                 polyCost += inc;
+                return *this;
         }
 
-        inline void Cost::incSafe( int inc ) {
+        inline Cost & Cost::incSafe( int inc ) {
                 safeCost += inc;
+                return *this;
         }