source: src/ResolvExpr/CastCost.cc @ 7870799

arm-ehjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-expr
Last change on this file since 7870799 was 7870799, checked in by Thierry Delisle <tdelisle@…>, 2 years ago

Cast cost and conversion cost now take constant parameters.
This required supporting visiting const node.
The PassVisitor? can now visit const nodes but not when using the Indexer

  • Property mode set to 100644
File size: 8.5 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// CastCost.cc --
8//
9// Author           : Richard C. Bilson
10// Created On       : Sun May 17 06:57:43 2015
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Tue Feb  2 15:34:36 2016
13// Update Count     : 7
14//
15
16#include <cassert>                       // for assert
17
18#include "AST/Print.hpp"
19#include "AST/SymbolTable.hpp"
20#include "AST/Type.hpp"
21#include "AST/TypeEnvironment.hpp"
22#include "ConversionCost.h"              // for ConversionCost
23#include "Cost.h"                        // for Cost, Cost::infinity
24#include "ResolvExpr/TypeEnvironment.h"  // for TypeEnvironment, EqvClass
25#include "SymTab/Indexer.h"              // for Indexer
26#include "SynTree/Declaration.h"         // for TypeDecl, NamedTypeDecl
27#include "SynTree/Type.h"                // for PointerType, Type, TypeInstType
28#include "typeops.h"                     // for typesCompatibleIgnoreQualifiers
29
30#if 0
31#define PRINT(x) x
32#else
33#define PRINT(x)
34#endif
35
36namespace ResolvExpr {
37        struct CastCost_old : public ConversionCost {
38          public:
39                CastCost_old( const Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc );
40
41                using ConversionCost::previsit;
42                using ConversionCost::postvisit;
43                void postvisit( const BasicType * basicType );
44                void postvisit( const PointerType * pointerType );
45        };
46
47        Cost castCost( const Type *src, const Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
48                if ( const TypeInstType *destAsTypeInst = dynamic_cast< const TypeInstType* >( dest ) ) {
49                        if ( const EqvClass* eqvClass = env.lookup( destAsTypeInst->name ) ) {
50                                if ( eqvClass->type ) {
51                                        return castCost( src, eqvClass->type, indexer, env );
52                                } else {
53                                        return Cost::infinity;
54                                }
55                        } else if ( NamedTypeDecl *namedType = indexer.lookupType( destAsTypeInst->name ) ) {
56                                // all typedefs should be gone by this point
57                                const TypeDecl * type = strict_dynamic_cast< const TypeDecl* >( namedType );
58                                if ( type->base ) {
59                                        return castCost( src, type->base, indexer, env ) + Cost::safe;
60                                } // if
61                        } // if
62                } // if
63
64                PRINT(
65                        std::cerr << "castCost ::: src is ";
66                        src->print( std::cerr );
67                        std::cerr << std::endl << "dest is ";
68                        dest->print( std::cerr );
69                        std::cerr << std::endl << "env is" << std::endl;
70                        env.print( std::cerr, 8 );
71                )
72
73                if ( typesCompatibleIgnoreQualifiers( src, dest, indexer, env ) ) {
74                        PRINT( std::cerr << "compatible!" << std::endl; )
75                        return Cost::zero;
76                } else if ( dynamic_cast< const VoidType* >( dest ) ) {
77                        return Cost::safe;
78                } else if ( const ReferenceType * refType = dynamic_cast< const ReferenceType * > ( dest ) ) {
79                        PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
80                        return convertToReferenceCost( src, refType, indexer, env, [](const Type * t1, const Type * t2, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
81                                return ptrsCastable( t1, t2, env, indexer );
82                        });
83                } else {
84                        PassVisitor<CastCost_old> converter(
85                                dest, indexer, env,
86                                (Cost (*)( const Type *, const Type *, const SymTab::Indexer &, const TypeEnvironment & ))
87                                        castCost );
88                        src->accept( converter );
89                        if ( converter.pass.get_cost() == Cost::infinity ) {
90                                return Cost::infinity;
91                        } else {
92                                // xxx - why are we adding cost 0 here?
93                                return converter.pass.get_cost() + Cost::zero;
94                        } // if
95                } // if
96        }
97
98        CastCost_old::CastCost_old( const Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc )
99                : ConversionCost( dest, indexer, env, costFunc ) {
100        }
101
102        void CastCost_old::postvisit( const BasicType *basicType ) {
103                const PointerType *destAsPointer = dynamic_cast< const PointerType* >( dest );
104                if ( destAsPointer && basicType->isInteger() ) {
105                        // necessary for, e.g. unsigned long => void*
106                        cost = Cost::unsafe;
107                } else {
108                        cost = conversionCost( basicType, dest, indexer, env );
109                } // if
110        }
111
112        void CastCost_old::postvisit( const PointerType *pointerType ) {
113                if ( const PointerType *destAsPtr = dynamic_cast< const PointerType* >( dest ) ) {
114                        if ( pointerType->tq <= destAsPtr->tq && typesCompatibleIgnoreQualifiers( pointerType->base, destAsPtr->base, indexer, env ) ) {
115                                cost = Cost::safe;
116                        } else {
117                                TypeEnvironment newEnv( env );
118                                newEnv.add( pointerType->forall );
119                                newEnv.add( pointerType->base->forall );
120                                int castResult = ptrsCastable( pointerType->base, destAsPtr->base, newEnv, indexer );
121                                if ( castResult > 0 ) {
122                                        cost = Cost::safe;
123                                } else if ( castResult < 0 ) {
124                                        cost = Cost::infinity;
125                                } // if
126                        } // if
127                } else if ( const BasicType * destAsBasic = dynamic_cast< const BasicType * >( dest ) ) {
128                        if ( destAsBasic->isInteger() ) {
129                                // necessary for, e.g. void* => unsigned long
130                                cost = Cost::unsafe;
131                        } // if
132                }
133        }
134
135namespace {
136        struct CastCost_new : public ConversionCost_new {
137                using ConversionCost_new::previsit;
138                using ConversionCost_new::postvisit;
139
140                CastCost_new(
141                        const ast::Type * dst, const ast::SymbolTable & symtab,
142                        const ast::TypeEnvironment & env, CostCalculation costFunc )
143                : ConversionCost_new( dst, symtab, env, costFunc ) {}
144
145                void postvisit( const ast::BasicType * basicType ) {
146                        auto ptr = dynamic_cast< const ast::PointerType * >( dst );
147                        if ( ptr && basicType->isInteger() ) {
148                                // needed for, e.g. unsigned long => void *
149                                cost = Cost::unsafe;
150                        } else {
151                                cost = conversionCost( basicType, dst, symtab, env );
152                        }
153                }
154
155                void postvisit( const ast::PointerType * pointerType ) {
156                        if ( auto ptr = dynamic_cast< const ast::PointerType * >( dst ) ) {
157                                if (
158                                        pointerType->qualifiers <= ptr->qualifiers
159                                        && typesCompatibleIgnoreQualifiers( pointerType->base, ptr->base, symtab, env )
160                                ) {
161                                        cost = Cost::safe;
162                                } else {
163                                        ast::TypeEnvironment newEnv{ env };
164                                        if ( auto wParams = pointerType->base.as< ast::ParameterizedType >() ) {
165                                                newEnv.add( wParams->forall );
166                                        }
167                                        int castResult = ptrsCastable( pointerType->base, ptr->base, symtab, newEnv );
168                                        if ( castResult > 0 ) {
169                                                cost = Cost::safe;
170                                        } else if ( castResult < 0 ) {
171                                                cost = Cost::infinity;
172                                        }
173                                }
174                        } else if ( auto basic = dynamic_cast< const ast::BasicType * >( dst ) ) {
175                                if ( basic->isInteger() ) {
176                                        // necessary for, e.g. void * => unsigned long
177                                        cost = Cost::unsafe;
178                                }
179                        }
180                }
181        };
182} // anonymous namespace
183
184Cost castCost(
185        const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
186        const ast::TypeEnvironment & env
187) {
188        if ( auto typeInst = dynamic_cast< const ast::TypeInstType * >( dst ) ) {
189                if ( const ast::EqvClass * eqvClass = env.lookup( typeInst->name ) ) {
190                        // check cast cost against bound type, if present
191                        if ( eqvClass->bound ) {
192                                return castCost( src, eqvClass->bound, symtab, env );
193                        } else {
194                                return Cost::infinity;
195                        }
196                } else if ( const ast::NamedTypeDecl * named = symtab.lookupType( typeInst->name ) ) {
197                        // all typedefs should be gone by now
198                        auto type = strict_dynamic_cast< const ast::TypeDecl * >( named );
199                        if ( type->base ) {
200                                return castCost( src, type->base, symtab, env ) + Cost::safe;
201                        }
202                }
203        }
204
205        PRINT(
206                std::cerr << "castCost ::: src is ";
207                ast::print( std::cerr, src );
208                std::cerr << std::endl << "dest is ";
209                ast::print( std::cerr, dst );
210                std::cerr << std::endl << "env is" << std::endl;
211                ast::print( std::cerr, env, 2 );
212        )
213
214        if ( typesCompatibleIgnoreQualifiers( src, dst, symtab, env ) ) {
215                PRINT( std::cerr << "compatible!" << std::endl; )
216                return Cost::zero;
217        } else if ( dynamic_cast< const ast::VoidType * >( dst ) ) {
218                return Cost::safe;
219        } else if ( auto refType = dynamic_cast< const ast::ReferenceType * >( dst ) ) {
220                PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
221                #warning cast on ptrsCastable artifact of having two functions, remove when port done
222                return convertToReferenceCost(
223                        src, refType, symtab, env,
224                        ( int (*)(
225                                const ast::Type *, const ast::Type *, const ast::SymbolTable &,
226                                const ast::TypeEnvironment & )
227                        ) ptrsCastable );
228        } else {
229                #warning cast on castCost artifact of having two functions, remove when port done
230                ast::Pass< CastCost_new > converter{
231                        dst, symtab, env,
232                        ( Cost (*)(
233                                const ast::Type *, const ast::Type *, const ast::SymbolTable &,
234                                const ast::TypeEnvironment & )
235                        ) castCost };
236                src->accept( converter );
237                return converter.pass.cost;
238        }
239}
240
241} // namespace ResolvExpr
242
243// Local Variables: //
244// tab-width: 4 //
245// mode: c++ //
246// compile-command: "make install" //
247// End: //
Note: See TracBrowser for help on using the repository browser.