Index: src/ResolvExpr/ConversionCost.cc =================================================================== --- src/ResolvExpr/ConversionCost.cc (revision 1dda8deb7319f77e7c7b69e59e8d2b0cff67847d) +++ src/ResolvExpr/ConversionCost.cc (revision c378e5e0877d4ea4eed80da1d9f0f8e86b94b6f6) @@ -10,6 +10,6 @@ // Created On : Sun May 17 07:06:19 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Feb 14 17:04:31 2019 -// Update Count : 23 +// Last Modified On : Fri Apr 26 16:33:04 2019 +// Update Count : 24 // @@ -28,4 +28,5 @@ namespace ResolvExpr { +#if 0 const Cost Cost::zero = Cost{ 0, 0, 0, 0, 0, 0, 0 }; const Cost Cost::infinity = Cost{ -1, -1, -1, -1, -1, 1, -1 }; @@ -37,4 +38,5 @@ const Cost Cost::spec = Cost{ 0, 0, 0, 0, 0, -1, 0 }; const Cost Cost::reference = Cost{ 0, 0, 0, 0, 0, 0, 1 }; +#endif #if 0 Index: src/ResolvExpr/Cost.h =================================================================== --- src/ResolvExpr/Cost.h (revision 1dda8deb7319f77e7c7b69e59e8d2b0cff67847d) +++ src/ResolvExpr/Cost.h (revision c378e5e0877d4ea4eed80da1d9f0f8e86b94b6f6) @@ -7,9 +7,9 @@ // Cost.h -- // -// Author : Richard C. Bilson +// Author : Peter Buhr and Aaron Moss // Created On : Sun May 17 09:39:50 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Feb 7 20:54:29 2019 -// Update Count : 8 +// Last Modified On : Sun Apr 28 18:26:36 2019 +// Update Count : 29 // @@ -17,10 +17,15 @@ #include +#include namespace ResolvExpr { +#if 0 + + //*************************** OLD *************************** + class Cost { private: Cost( int unsafeCost, int polyCost, int safeCost, int signCost, - int varCost, int specCost, int referenceCost ); + int varCost, int specCost, int referenceCost ); public: Cost & incUnsafe( int inc = 1 ); @@ -71,5 +76,5 @@ inline Cost::Cost( int unsafeCost, int polyCost, int safeCost, int signCost, - int varCost, int specCost, int referenceCost ) + int varCost, int specCost, int referenceCost ) : unsafeCost( unsafeCost ), polyCost( polyCost ), safeCost( safeCost ), signCost( signCost ), varCost( varCost ), specCost( specCost ), referenceCost( referenceCost ) {} @@ -121,6 +126,6 @@ return Cost{ unsafeCost + other.unsafeCost, polyCost + other.polyCost, safeCost + other.safeCost, - signCost + other.signCost, varCost + other.varCost, specCost + other.specCost, - referenceCost + other.referenceCost }; + signCost + other.signCost, varCost + other.varCost, specCost + other.specCost, + referenceCost + other.referenceCost }; } @@ -211,4 +216,149 @@ << cost.referenceCost << " )"; } +#endif // 0 + + //*************************** NEW *************************** + + class Cost { + union { + struct { + #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ + // Little-endian => first value is low priority and last is high priority. + unsigned char padding; ///< unused + unsigned char referenceCost; ///< reference conversions + unsigned char specCost; ///< Polymorphic type specializations (type assertions), negative cost + unsigned char varCost; ///< Count of polymorphic type variables + unsigned char signCost; ///< Count of safe sign conversions + unsigned char safeCost; ///< Safe (widening) conversions + unsigned char polyCost; ///< Count of parameters and return values bound to some poly type + unsigned char unsafeCost; ///< Unsafe (narrowing) conversions + #else + #error BIG_ENDIAN unsupported + #endif + } v; + uint64_t all; + }; + public: + // Compiler adjusts constants for correct endian. + enum : uint64_t { + zero = 0x00'00'00'00'00'ff'00'00, + infinity = 0xff'ff'ff'ff'ff'00'ff'ff, + correction = 0x00'00'00'00'00'ff'00'00, // correct for negative spec cost + unsafe = 0x01'00'00'00'00'ff'00'00, + poly = 0x00'01'00'00'00'ff'00'00, + safe = 0x00'00'01'00'00'ff'00'00, + sign = 0x00'00'00'01'00'ff'00'00, + var = 0x00'00'00'00'01'ff'00'00, + spec = 0x00'00'00'00'00'fe'00'00, + reference = 0x00'00'00'00'00'ff'01'00, + }; // + + Cost( uint64_t all ) { Cost::all = all; } + Cost( int unsafeCost, int polyCost, int safeCost, int signCost, int varCost, int specCost, int referenceCost ) { + // Assume little-endian => first value is low priority and last is high priority. + v = { + (unsigned char)0, // padding + (unsigned char)referenceCost, + (unsigned char)(specCost + 0xff ), // correct for signedness + (unsigned char)varCost, + (unsigned char)signCost, + (unsigned char)safeCost, + (unsigned char)polyCost, + (unsigned char)unsafeCost, + }; + } + + int get_unsafeCost() const { return v.unsafeCost; } + int get_polyCost() const { return v.polyCost; } + int get_safeCost() const { return v.safeCost; } + int get_signCost() const { return v.signCost; } + int get_varCost() const { return v.varCost; } + int get_specCost() const { return -(0xff - v.specCost); } + int get_referenceCost() const { return v.referenceCost; } + + friend bool operator==( const Cost, const Cost ); + friend bool operator!=( const Cost lhs, const Cost rhs ); + // returns negative for *this < rhs, 0 for *this == rhs, positive for *this > rhs + int compare( const Cost rhs ) const { + if ( all == infinity ) return 1; + if ( rhs.all == infinity ) return -1; + return all > rhs.all ? 1 : all == rhs.all ? 0 : -1; + } + friend bool operator<( const Cost lhs, const Cost rhs ); + + friend Cost operator+( const Cost lhs, const Cost rhs ); + + Cost operator+=( const Cost rhs ) { + if ( all == infinity ) return *this; + if ( rhs.all == infinity ) { + all = infinity; + return *this; + } + all += rhs.all - correction; // correct for negative spec cost + return *this; + } + + Cost incUnsafe( int inc = 1 ) { + if ( all != infinity ) { assert( v.unsafeCost + inc < 256 ); v.unsafeCost += inc; } + return *this; + } + + Cost incPoly( int inc = 1 ) { + if ( all != infinity ) { assert( v.polyCost + inc < 256 ); v.polyCost += inc; } + return *this; + } + + Cost incSafe( int inc = 1 ) { + if ( all != infinity ) { assert( v.safeCost + inc < 256 ); v.safeCost += inc; } + return *this; + } + + Cost incSign( int inc = 1 ) { + if ( all != infinity ) { assert( v.signCost + inc < 256 ); v.signCost += inc; } + return *this; + } + + Cost incVar( int inc = 1 ) { + if ( all != infinity ) { assert( v.varCost + inc < 256 ); v.varCost += inc; } + return *this; + } + + Cost decSpec( int dec = 1 ) { + if ( all != infinity ) { v.specCost -= dec; } + return *this; + } + + Cost incReference( int inc = 1 ) { + if ( all != infinity ) { assert( v.referenceCost + inc < 256 ); v.referenceCost += inc; } + return *this; + } + + friend std::ostream & operator<<( std::ostream & os, const Cost cost ); + }; + + inline bool operator==( const Cost lhs, const Cost rhs ) { + return lhs.all == rhs.all; + } + + inline bool operator!=( const Cost lhs, const Cost rhs ) { + return !( lhs.all == rhs.all ); + } + + inline bool operator<( const Cost lhs, const Cost rhs ) { + if ( lhs.all == Cost::infinity ) return false; + if ( rhs.all == Cost::infinity ) return true; + return lhs.all < rhs.all; + } + + inline Cost operator+( const Cost lhs, const Cost rhs ) { + if ( lhs.all == Cost::infinity || rhs.all == Cost::infinity ) return Cost{ Cost::infinity }; + return Cost{ lhs.all + rhs.all - Cost::correction }; // correct for negative spec cost + } + + inline std::ostream & operator<<( std::ostream & os, const Cost cost ) { + return os << "( " << cost.get_unsafeCost() << ", " << cost.get_polyCost() << ", " << cost.get_safeCost() + << ", " << cost.get_signCost() << ", " << cost.get_varCost() << ", " << cost.get_specCost() + << ", " << cost.get_referenceCost() << " )"; + } } // namespace ResolvExpr