source: src/ResolvExpr/CastCost.cc @ 7d01cf44

arm-ehjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-expr
Last change on this file since 7d01cf44 was 7d01cf44, checked in by Andrew Beach <ajbeach@…>, 2 years ago

lvalue is now read through the expression.

  • Property mode set to 100644
File size: 8.7 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 : Thu Aug  8 16:12:00 2019
13// Update Count     : 8
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, const ast::SymbolTable & symtab,
145                        const ast::TypeEnvironment & env, CostCalculation costFunc )
146                : ConversionCost_new( dst, 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, 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::ParameterizedType >() ) {
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} // anonymous namespace
186
187Cost castCost(
188        const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
189        const ast::TypeEnvironment & env
190) {
191        if ( auto typeInst = dynamic_cast< const ast::TypeInstType * >( dst ) ) {
192                if ( const ast::EqvClass * eqvClass = env.lookup( typeInst->name ) ) {
193                        // check cast cost against bound type, if present
194                        if ( eqvClass->bound ) {
195                                return castCost( src, eqvClass->bound, symtab, env );
196                        } else {
197                                return Cost::infinity;
198                        }
199                } else if ( const ast::NamedTypeDecl * named = symtab.lookupType( typeInst->name ) ) {
200                        // all typedefs should be gone by now
201                        auto type = strict_dynamic_cast< const ast::TypeDecl * >( named );
202                        if ( type->base ) {
203                                return castCost( src, type->base, symtab, env ) + Cost::safe;
204                        }
205                }
206        }
207
208        PRINT(
209                std::cerr << "castCost ::: src is ";
210                ast::print( std::cerr, src );
211                std::cerr << std::endl << "dest is ";
212                ast::print( std::cerr, dst );
213                std::cerr << std::endl << "env is" << std::endl;
214                ast::print( std::cerr, env, 2 );
215        )
216
217        if ( typesCompatibleIgnoreQualifiers( src, dst, symtab, env ) ) {
218                PRINT( std::cerr << "compatible!" << std::endl; )
219                return Cost::zero;
220        } else if ( dynamic_cast< const ast::VoidType * >( dst ) ) {
221                return Cost::safe;
222        } else if ( auto refType = dynamic_cast< const ast::ReferenceType * >( dst ) ) {
223                PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
224                #warning cast on ptrsCastable artifact of having two functions, remove when port done
225                return convertToReferenceCost(
226                        src, refType, symtab, env,
227                        ( int (*)(
228                                const ast::Type *, const ast::Type *, const ast::SymbolTable &,
229                                const ast::TypeEnvironment & )
230                        ) ptrsCastable );
231        } else {
232                #warning cast on castCost artifact of having two functions, remove when port done
233                ast::Pass< CastCost_new > converter{
234                        dst, symtab, env,
235                        ( Cost (*)(
236                                const ast::Type *, const ast::Type *, const ast::SymbolTable &,
237                                const ast::TypeEnvironment & )
238                        ) castCost };
239                src->accept( converter );
240                return converter.pass.cost;
241        }
242}
243
244} // namespace ResolvExpr
245
246// Local Variables: //
247// tab-width: 4 //
248// mode: c++ //
249// compile-command: "make install" //
250// End: //
Note: See TracBrowser for help on using the repository browser.