Changeset 8d182b1 for src/ResolvExpr/CastCost.cc

Timestamp:

Nov 14, 2023, 12:19:09 PM (23 months ago)

Author:

caparson <caparson@…>

Branches:

master

Children:

1ccae59, 89a8bab

Parents:

df8ba61a (diff), 5625427 (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) (4 diffs)

src/ResolvExpr/CastCost.cc

@@ -26 +26 @@
 #include "ResolvExpr/ConversionCost.h"   // for conversionCost
 #include "ResolvExpr/PtrsCastable.hpp"   // for ptrsCastable
-#include "ResolvExpr/TypeEnvironment.h"  // for TypeEnvironment, EqvClass
-#include "ResolvExpr/typeops.h"          // for ptrsCastable
 #include "ResolvExpr/Unify.h"            // for typesCompatibleIgnoreQualifiers
-#include "SymTab/Indexer.h"              // for Indexer
-#include "SynTree/Declaration.h"         // for TypeDecl, NamedTypeDecl
-#include "SynTree/Type.h"                // for PointerType, Type, TypeInstType
 
 #if 0
@@ -40 +35 @@
 
 namespace ResolvExpr {
-        struct CastCost_old : public ConversionCost {
-          public:
-                CastCost_old( const Type * dest, bool srcIsLvalue,
-                        const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc );
 
+namespace {
+        struct CastCost : public ConversionCost {
                 using ConversionCost::previsit;
                 using ConversionCost::postvisit;
-                void postvisit( const BasicType * basicType );
-                void postvisit( const PointerType * pointerType );
-        };
 
-        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, srcIsLvalue, indexer, env );
-                                } else {
-                                        return Cost::infinity;
-                                }
-                        } else if ( const NamedTypeDecl * namedType = indexer.lookupType( destAsTypeInst->name ) ) {
-                                // all typedefs should be gone by this point
-                                const TypeDecl * type = strict_dynamic_cast< const TypeDecl * >( namedType );
-                                if ( type->base ) {
-                                        return castCost( src, type->base, srcIsLvalue, indexer, env ) + Cost::safe;
-                                } // if
-                        } // if
-                } // if
-
-                PRINT(
-                        std::cerr << "castCost ::: src is ";
-                        src->print( std::cerr );
-                        std::cerr << std::endl << "dest is ";
-                        dest->print( std::cerr );
-                        std::cerr << std::endl << "env is" << std::endl;
-                        env.print( std::cerr, 8 );
-                )
-
-                if ( typesCompatibleIgnoreQualifiers( src, dest, indexer, env ) ) {
-                        PRINT( std::cerr << "compatible!" << std::endl; )
-                        return Cost::zero;
-                } else if ( dynamic_cast< const VoidType * >( dest ) ) {
-                        return Cost::safe;
-                } else if ( const ReferenceType * refType = dynamic_cast< const ReferenceType * > ( dest ) ) {
-                        PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
-                        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_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 ) {
-                                return Cost::infinity;
-                        } else {
-                                // xxx - why are we adding cost 0 here?
-                                return converter.pass.get_cost() + Cost::zero;
-                        } // if
-                } // if
-        }
-
-        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 *
-                        cost = Cost::unsafe;
-                } else {
-                        cost = conversionCost( basicType, dest, srcIsLvalue, indexer, env );
-                } // if
-        }
-
-        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 {
-                                TypeEnvironment newEnv( env );
-                                newEnv.add( pointerType->forall );
-                                newEnv.add( pointerType->base->forall );
-                                int castResult = ptrsCastable( pointerType->base, destAsPtr->base, newEnv, indexer );
-                                if ( castResult > 0 ) {
-                                        cost = Cost::safe;
-                                } else if ( castResult < 0 ) {
-                                        cost = Cost::infinity;
-                                } // if
-                        } // if
-                } else if ( const BasicType * destAsBasic = dynamic_cast< const BasicType * >( dest ) ) {
-                        if ( destAsBasic->isInteger() ) {
-                                // 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(
+                CastCost(
                         const ast::Type * dst, bool srcIsLvalue, const ast::SymbolTable & symtab,
                         const ast::TypeEnvironment & env, CostCalculation costFunc )
-                : ConversionCost_new( dst, srcIsLvalue, symtab, env, costFunc ) {}
+                : ConversionCost( dst, srcIsLvalue, symtab, env, costFunc ) {}
 
                 void postvisit( const ast::BasicType * basicType ) {
@@ -189 +84 @@
         };
 
-        #warning For overload resolution between the two versions.
-        int localPtrsCastable(const ast::Type * t1, const ast::Type * t2,
-                        const ast::SymbolTable & symtab, const ast::TypeEnvironment & env ) {
-                return ptrsCastable( t1, t2, symtab, env );
-        }
-        Cost localCastCost(
-                const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
-                const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
-        ) { return castCost( src, dst, srcIsLvalue, symtab, env ); }
 } // anonymous namespace
-
-
 
 Cost castCost(
@@ -242 +126 @@
         } 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, srcIsLvalue, symtab, env, localPtrsCastable );
+                        src, refType, srcIsLvalue, symtab, env, ptrsCastable );
         } else {
-                #warning cast on castCost artifact of having two functions, remove when port done
-                ast::Pass< CastCost_new > converter(
-                        dst, srcIsLvalue, symtab, env, localCastCost );
+                ast::Pass< CastCost > converter(
+                        dst, srcIsLvalue, symtab, env, castCost );
                 src->accept( converter );
                 return converter.core.cost;