source: src/ResolvExpr/CastCost.cc @ 361bf01

arm-ehjacob/cs343-translationnew-ast-unique-expr
Last change on this file since 361bf01 was 361bf01, checked in by Fangren Yu <f37yu@…>, 10 months ago

remove ParameterizedType? and put content into FunctionType?

  • Property mode set to 100644
File size: 9.0 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 : Andrew Beach
12// Last Modified On : Tue Oct  4 15:00:00 2019
13// Update Count     : 9
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, bool srcIsLvalue,
40                        const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc );
41
42                using ConversionCost::previsit;
43                using ConversionCost::postvisit;
44                void postvisit( const BasicType * basicType );
45                void postvisit( const PointerType * pointerType );
46        };
47
48        Cost castCost( const Type * src, const Type * dest, bool srcIsLvalue,
49                        const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
50                if ( const TypeInstType * destAsTypeInst = dynamic_cast< const TypeInstType * >( dest ) ) {
51                        if ( const EqvClass * eqvClass = env.lookup( destAsTypeInst->name ) ) {
52                                if ( eqvClass->type ) {
53                                        return castCost( src, eqvClass->type, srcIsLvalue, indexer, env );
54                                } else {
55                                        return Cost::infinity;
56                                }
57                        } else if ( const NamedTypeDecl * namedType = indexer.lookupType( destAsTypeInst->name ) ) {
58                                // all typedefs should be gone by this point
59                                const TypeDecl * type = strict_dynamic_cast< const TypeDecl * >( namedType );
60                                if ( type->base ) {
61                                        return castCost( src, type->base, srcIsLvalue, indexer, env ) + Cost::safe;
62                                } // if
63                        } // if
64                } // if
65
66                PRINT(
67                        std::cerr << "castCost ::: src is ";
68                        src->print( std::cerr );
69                        std::cerr << std::endl << "dest is ";
70                        dest->print( std::cerr );
71                        std::cerr << std::endl << "env is" << std::endl;
72                        env.print( std::cerr, 8 );
73                )
74
75                if ( typesCompatibleIgnoreQualifiers( src, dest, indexer, env ) ) {
76                        PRINT( std::cerr << "compatible!" << std::endl; )
77                        return Cost::zero;
78                } else if ( dynamic_cast< const VoidType * >( dest ) ) {
79                        return Cost::safe;
80                } else if ( const ReferenceType * refType = dynamic_cast< const ReferenceType * > ( dest ) ) {
81                        PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
82                        return convertToReferenceCost( src, refType, srcIsLvalue, indexer, env, [](const Type * t1, const Type * t2, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
83                                return ptrsCastable( t1, t2, env, indexer );
84                        });
85                } else {
86                        PassVisitor<CastCost_old> converter(
87                                dest, srcIsLvalue, indexer, env,
88                                (Cost (*)( const Type *, const Type *, bool, const SymTab::Indexer &, const TypeEnvironment & ))
89                                        castCost );
90                        src->accept( converter );
91                        if ( converter.pass.get_cost() == Cost::infinity ) {
92                                return Cost::infinity;
93                        } else {
94                                // xxx - why are we adding cost 0 here?
95                                return converter.pass.get_cost() + Cost::zero;
96                        } // if
97                } // if
98        }
99
100        CastCost_old::CastCost_old( const Type * dest, bool srcIsLvalue,
101                        const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc )
102                : ConversionCost( dest, srcIsLvalue, indexer, env, costFunc ) {
103        }
104
105        void CastCost_old::postvisit( const BasicType * basicType ) {
106                const PointerType * destAsPointer = dynamic_cast< const PointerType * >( dest );
107                if ( destAsPointer && basicType->isInteger() ) {
108                        // necessary for, e.g. unsigned long => void *
109                        cost = Cost::unsafe;
110                } else {
111                        cost = conversionCost( basicType, dest, srcIsLvalue, indexer, env );
112                } // if
113        }
114
115        void CastCost_old::postvisit( const PointerType * pointerType ) {
116                if ( const PointerType * destAsPtr = dynamic_cast< const PointerType * >( dest ) ) {
117                        if ( pointerType->tq <= destAsPtr->tq && typesCompatibleIgnoreQualifiers( pointerType->base, destAsPtr->base, indexer, env ) ) {
118                                cost = Cost::safe;
119                        } else {
120                                TypeEnvironment newEnv( env );
121                                newEnv.add( pointerType->forall );
122                                newEnv.add( pointerType->base->forall );
123                                int castResult = ptrsCastable( pointerType->base, destAsPtr->base, newEnv, indexer );
124                                if ( castResult > 0 ) {
125                                        cost = Cost::safe;
126                                } else if ( castResult < 0 ) {
127                                        cost = Cost::infinity;
128                                } // if
129                        } // if
130                } else if ( const BasicType * destAsBasic = dynamic_cast< const BasicType * >( dest ) ) {
131                        if ( destAsBasic->isInteger() ) {
132                                // necessary for, e.g. void * => unsigned long
133                                cost = Cost::unsafe;
134                        } // if
135                }
136        }
137
138namespace {
139        struct CastCost_new : public ConversionCost_new {
140                using ConversionCost_new::previsit;
141                using ConversionCost_new::postvisit;
142
143                CastCost_new(
144                        const ast::Type * dst, bool srcIsLvalue, const ast::SymbolTable & symtab,
145                        const ast::TypeEnvironment & env, CostCalculation costFunc )
146                : ConversionCost_new( dst, srcIsLvalue, symtab, env, costFunc ) {}
147
148                void postvisit( const ast::BasicType * basicType ) {
149                        auto ptr = dynamic_cast< const ast::PointerType * >( dst );
150                        if ( ptr && basicType->isInteger() ) {
151                                // needed for, e.g. unsigned long => void *
152                                cost = Cost::unsafe;
153                        } else {
154                                cost = conversionCost( basicType, dst, srcIsLvalue, symtab, env );
155                        }
156                }
157
158                void postvisit( const ast::PointerType * pointerType ) {
159                        if ( auto ptr = dynamic_cast< const ast::PointerType * >( dst ) ) {
160                                if (
161                                        pointerType->qualifiers <= ptr->qualifiers
162                                        && typesCompatibleIgnoreQualifiers( pointerType->base, ptr->base, symtab, env )
163                                ) {
164                                        cost = Cost::safe;
165                                } else {
166                                        ast::TypeEnvironment newEnv{ env };
167                                        if ( auto wParams = pointerType->base.as< ast::FunctionType >() ) {
168                                                newEnv.add( wParams->forall );
169                                        }
170                                        int castResult = ptrsCastable( pointerType->base, ptr->base, symtab, newEnv );
171                                        if ( castResult > 0 ) {
172                                                cost = Cost::safe;
173                                        } else if ( castResult < 0 ) {
174                                                cost = Cost::infinity;
175                                        }
176                                }
177                        } else if ( auto basic = dynamic_cast< const ast::BasicType * >( dst ) ) {
178                                if ( basic->isInteger() ) {
179                                        // necessary for, e.g. void * => unsigned long
180                                        cost = Cost::unsafe;
181                                }
182                        }
183                }
184        };
185
186        #warning For overload resolution between the two versions.
187        int localPtrsCastable(const ast::Type * t1, const ast::Type * t2,
188                        const ast::SymbolTable & symtab, const ast::TypeEnvironment & env ) {
189                return ptrsCastable( t1, t2, symtab, env );
190        }
191        Cost localCastCost(
192                const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
193                const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
194        ) { return castCost( src, dst, srcIsLvalue, symtab, env ); }
195} // anonymous namespace
196
197
198
199Cost castCost(
200        const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
201        const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
202) {
203        if ( auto typeInst = dynamic_cast< const ast::TypeInstType * >( dst ) ) {
204                if ( const ast::EqvClass * eqvClass = env.lookup( typeInst->name ) ) {
205                        // check cast cost against bound type, if present
206                        if ( eqvClass->bound ) {
207                                return castCost( src, eqvClass->bound, srcIsLvalue, symtab, env );
208                        } else {
209                                return Cost::infinity;
210                        }
211                } else if ( const ast::NamedTypeDecl * named = symtab.lookupType( typeInst->name ) ) {
212                        // all typedefs should be gone by now
213                        auto type = strict_dynamic_cast< const ast::TypeDecl * >( named );
214                        if ( type->base ) {
215                                return castCost( src, type->base, srcIsLvalue, symtab, env ) + Cost::safe;
216                        }
217                }
218        }
219
220        PRINT(
221                std::cerr << "castCost ::: src is ";
222                ast::print( std::cerr, src );
223                std::cerr << std::endl << "dest is ";
224                ast::print( std::cerr, dst );
225                std::cerr << std::endl << "env is" << std::endl;
226                ast::print( std::cerr, env, 2 );
227        )
228
229        if ( typesCompatibleIgnoreQualifiers( src, dst, symtab, env ) ) {
230                PRINT( std::cerr << "compatible!" << std::endl; )
231                return Cost::zero;
232        } else if ( dynamic_cast< const ast::VoidType * >( dst ) ) {
233                return Cost::safe;
234        } else if ( auto refType = dynamic_cast< const ast::ReferenceType * >( dst ) ) {
235                PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
236                #warning cast on ptrsCastable artifact of having two functions, remove when port done
237                return convertToReferenceCost(
238                        src, refType, srcIsLvalue, symtab, env, localPtrsCastable );
239        } else {
240                #warning cast on castCost artifact of having two functions, remove when port done
241                ast::Pass< CastCost_new > converter(
242                        dst, srcIsLvalue, symtab, env, localCastCost );
243                src->accept( converter );
244                return converter.core.cost;
245        }
246}
247
248} // namespace ResolvExpr
249
250// Local Variables: //
251// tab-width: 4 //
252// mode: c++ //
253// compile-command: "make install" //
254// End: //
Note: See TracBrowser for help on using the repository browser.