Changeset b067d9b for src/ResolvExpr/CastCost.cc

Timestamp:

Oct 29, 2019, 4:01:24 PM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

773db65, 9421f3d8

Parents:

7951100 (diff), 8364209 (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/CastCost.cc (modified) (5 diffs)

src/ResolvExpr/CastCost.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 06:57:43 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb  2 15:34:36 2016
-// Update Count     : 7
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu Aug  8 16:12:00 2019
+// Update Count     : 8
 //
 
 #include <cassert>                       // for assert
 
+#include "AST/Print.hpp"
+#include "AST/SymbolTable.hpp"
+#include "AST/Type.hpp"
+#include "AST/TypeEnvironment.hpp"
 #include "ConversionCost.h"              // for ConversionCost
 #include "Cost.h"                        // for Cost, Cost::infinity
@@ -31 +35 @@
 
 namespace ResolvExpr {
-        struct CastCost : public ConversionCost {
+        struct CastCost_old : public ConversionCost {
           public:
-                CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc );
+                CastCost_old( const Type * dest, bool srcIsLvalue,
+                        const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc );
 
                 using ConversionCost::previsit;
                 using ConversionCost::postvisit;
-                void postvisit( BasicType * basicType );
-                void postvisit( PointerType * pointerType );
+                void postvisit( const BasicType * basicType );
+                void postvisit( const PointerType * pointerType );
         };
 
-        Cost castCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
-                if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
-                        if ( const EqvClass* eqvClass = env.lookup( destAsTypeInst->get_name() ) ) {
+        Cost castCost( const Type * src, const Type * dest, bool srcIsLvalue,
+                        const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
+                if ( const TypeInstType * destAsTypeInst = dynamic_cast< const TypeInstType * >( dest ) ) {
+                        if ( const EqvClass * eqvClass = env.lookup( destAsTypeInst->name ) ) {
                                 if ( eqvClass->type ) {
-                                        return castCost( src, eqvClass->type, indexer, env );
+                                        return castCost( src, eqvClass->type, srcIsLvalue, indexer, env );
                                 } else {
                                         return Cost::infinity;
                                 }
-                        } else if ( NamedTypeDecl *namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) {
+                        } else if ( const NamedTypeDecl * namedType = indexer.lookupType( destAsTypeInst->name ) ) {
                                 // all typedefs should be gone by this point
-                                TypeDecl *type = strict_dynamic_cast< TypeDecl* >( namedType );
+                                const TypeDecl * type = strict_dynamic_cast< const TypeDecl * >( namedType );
                                 if ( type->base ) {
-                                        return castCost( src, type->base, indexer, env ) + Cost::safe;
+                                        return castCost( src, type->base, srcIsLvalue, indexer, env ) + Cost::safe;
                                 } // if
                         } // if
@@ -70 +76 @@
                         PRINT( std::cerr << "compatible!" << std::endl; )
                         return Cost::zero;
-                } else if ( dynamic_cast< VoidType* >( dest ) ) {
+                } else if ( dynamic_cast< const VoidType * >( dest ) ) {
                         return Cost::safe;
-                } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) {
+                } else if ( const ReferenceType * refType = dynamic_cast< const ReferenceType * > ( dest ) ) {
                         PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
-                        return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
+                        return convertToReferenceCost( src, refType, srcIsLvalue, indexer, env, [](const Type * t1, const Type * t2, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
                                 return ptrsCastable( t1, t2, env, indexer );
                         });
                 } else {
-                        PassVisitor<CastCost> converter( dest, indexer, env, castCost );
+                        PassVisitor<CastCost_old> converter(
+                                dest, srcIsLvalue, indexer, env,
+                                (Cost (*)( const Type *, const Type *, bool, const SymTab::Indexer &, const TypeEnvironment & ))
+                                        castCost );
                         src->accept( converter );
                         if ( converter.pass.get_cost() == Cost::infinity ) {
@@ -89 +98 @@
         }
 
-        CastCost::CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc )
-                : ConversionCost( dest, indexer, env, costFunc ) {
-        }
-
-        void CastCost::postvisit( BasicType *basicType ) {
-                PointerType *destAsPointer = dynamic_cast< PointerType* >( dest );
+        CastCost_old::CastCost_old( const Type * dest, bool srcIsLvalue,
+                        const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc )
+                : ConversionCost( dest, srcIsLvalue, indexer, env, costFunc ) {
+        }
+
+        void CastCost_old::postvisit( const BasicType * basicType ) {
+                const PointerType * destAsPointer = dynamic_cast< const PointerType * >( dest );
                 if ( destAsPointer && basicType->isInteger() ) {
-                        // necessary for, e.g. unsigned long => void*
+                        // necessary for, e.g. unsigned long => void *
                         cost = Cost::unsafe;
                 } else {
-                        cost = conversionCost( basicType, dest, indexer, env );
+                        cost = conversionCost( basicType, dest, srcIsLvalue, indexer, env );
                 } // if
         }
 
-        void CastCost::postvisit( PointerType *pointerType ) {
-                if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
-                        if ( pointerType->get_qualifiers() <= destAsPtr->get_qualifiers() && typesCompatibleIgnoreQualifiers( pointerType->base, destAsPtr->base, indexer, env ) ) {
+        void CastCost_old::postvisit( const PointerType * pointerType ) {
+                if ( const PointerType * destAsPtr = dynamic_cast< const PointerType * >( dest ) ) {
+                        if ( pointerType->tq <= destAsPtr->tq && typesCompatibleIgnoreQualifiers( pointerType->base, destAsPtr->base, indexer, env ) ) {
                                 cost = Cost::safe;
                         } else {
@@ -118 +128 @@
                                 } // if
                         } // if
-                } else if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) {
+                } else if ( const BasicType * destAsBasic = dynamic_cast< const BasicType * >( dest ) ) {
                         if ( destAsBasic->isInteger() ) {
-                                // necessary for, e.g. void* => unsigned long
+                                // necessary for, e.g. void * => unsigned long
                                 cost = Cost::unsafe;
                         } // if
                 }
         }
+
+namespace {
+        struct CastCost_new : public ConversionCost_new {
+                using ConversionCost_new::previsit;
+                using ConversionCost_new::postvisit;
+
+                CastCost_new(
+                        const ast::Type * dst, const ast::SymbolTable & symtab,
+                        const ast::TypeEnvironment & env, CostCalculation costFunc )
+                : ConversionCost_new( dst, symtab, env, costFunc ) {}
+
+                void postvisit( const ast::BasicType * basicType ) {
+                        auto ptr = dynamic_cast< const ast::PointerType * >( dst );
+                        if ( ptr && basicType->isInteger() ) {
+                                // needed for, e.g. unsigned long => void *
+                                cost = Cost::unsafe;
+                        } else {
+                                cost = conversionCost( basicType, dst, symtab, env );
+                        }
+                }
+
+                void postvisit( const ast::PointerType * pointerType ) {
+                        if ( auto ptr = dynamic_cast< const ast::PointerType * >( dst ) ) {
+                                if (
+                                        pointerType->qualifiers <= ptr->qualifiers
+                                        && typesCompatibleIgnoreQualifiers( pointerType->base, ptr->base, symtab, env )
+                                ) {
+                                        cost = Cost::safe;
+                                } else {
+                                        ast::TypeEnvironment newEnv{ env };
+                                        if ( auto wParams = pointerType->base.as< ast::ParameterizedType >() ) {
+                                                newEnv.add( wParams->forall );
+                                        }
+                                        int castResult = ptrsCastable( pointerType->base, ptr->base, symtab, newEnv );
+                                        if ( castResult > 0 ) {
+                                                cost = Cost::safe;
+                                        } else if ( castResult < 0 ) {
+                                                cost = Cost::infinity;
+                                        }
+                                }
+                        } else if ( auto basic = dynamic_cast< const ast::BasicType * >( dst ) ) {
+                                if ( basic->isInteger() ) {
+                                        // necessary for, e.g. void * => unsigned long
+                                        cost = Cost::unsafe;
+                                }
+                        }
+                }
+        };
+} // anonymous namespace
+
+Cost castCost(
+        const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
+        const ast::TypeEnvironment & env
+) {
+        if ( auto typeInst = dynamic_cast< const ast::TypeInstType * >( dst ) ) {
+                if ( const ast::EqvClass * eqvClass = env.lookup( typeInst->name ) ) {
+                        // check cast cost against bound type, if present
+                        if ( eqvClass->bound ) {
+                                return castCost( src, eqvClass->bound, symtab, env );
+                        } else {
+                                return Cost::infinity;
+                        }
+                } else if ( const ast::NamedTypeDecl * named = symtab.lookupType( typeInst->name ) ) {
+                        // all typedefs should be gone by now
+                        auto type = strict_dynamic_cast< const ast::TypeDecl * >( named );
+                        if ( type->base ) {
+                                return castCost( src, type->base, symtab, env ) + Cost::safe;
+                        }
+                }
+        }
+
+        PRINT(
+                std::cerr << "castCost ::: src is ";
+                ast::print( std::cerr, src );
+                std::cerr << std::endl << "dest is ";
+                ast::print( std::cerr, dst );
+                std::cerr << std::endl << "env is" << std::endl;
+                ast::print( std::cerr, env, 2 );
+        )
+
+        if ( typesCompatibleIgnoreQualifiers( src, dst, symtab, env ) ) {
+                PRINT( std::cerr << "compatible!" << std::endl; )
+                return Cost::zero;
+        } else if ( dynamic_cast< const ast::VoidType * >( dst ) ) {
+                return Cost::safe;
+        } else if ( auto refType = dynamic_cast< const ast::ReferenceType * >( dst ) ) {
+                PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
+                #warning cast on ptrsCastable artifact of having two functions, remove when port done
+                return convertToReferenceCost(
+                        src, refType, symtab, env,
+                        ( int (*)(
+                                const ast::Type *, const ast::Type *, const ast::SymbolTable &,
+                                const ast::TypeEnvironment & )
+                        ) ptrsCastable );
+        } else {
+                #warning cast on castCost artifact of having two functions, remove when port done
+                ast::Pass< CastCost_new > converter{
+                        dst, symtab, env,
+                        ( Cost (*)(
+                                const ast::Type *, const ast::Type *, const ast::SymbolTable &,
+                                const ast::TypeEnvironment & )
+                        ) castCost };
+                src->accept( converter );
+                return converter.pass.cost;
+        }
+}
+
 } // namespace ResolvExpr