source: src/ResolvExpr/Resolver.cc@ 5684736

ADT arm-eh ast-experimental enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox new-ast new-ast-unique-expr pthread-emulation qualifiedEnum
Last change on this file since 5684736 was 2b59f55, checked in by Aaron Moss <a3moss@…>, 6 years ago

More resolver porting
  • Property mode set to 100644
File size: 53.2 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// Resolver.cc --
8//
9// Author : Aaron B. Moss
10// Created On : Sun May 17 12:17:01 2015
11// Last Modified By : Aaron B. Moss
12// Last Modified On : Wed May 29 11:00:00 2019
13// Update Count : 241
14//
15
16#include <cassert> // for strict_dynamic_cast, assert
17#include <memory> // for allocator, allocator_traits<...
18#include <tuple> // for get
19#include <vector> // for vector
20
21#include "Alternative.h" // for Alternative, AltList
22#include "AlternativeFinder.h" // for AlternativeFinder, resolveIn...
23#include "Candidate.hpp"
24#include "CandidateFinder.hpp"
25#include "CurrentObject.h" // for CurrentObject
26#include "RenameVars.h" // for RenameVars, global_renamer
27#include "Resolver.h"
28#include "ResolvMode.h" // for ResolvMode
29#include "typeops.h" // for extractResultType
30#include "Unify.h" // for unify
31#include "AST/Chain.hpp"
32#include "AST/Decl.hpp"
33#include "AST/Init.hpp"
34#include "AST/Pass.hpp"
35#include "AST/Print.hpp"
36#include "AST/SymbolTable.hpp"
37#include "Common/PassVisitor.h" // for PassVisitor
38#include "Common/SemanticError.h" // for SemanticError
39#include "Common/utility.h" // for ValueGuard, group_iterate
40#include "InitTweak/GenInit.h"
41#include "InitTweak/InitTweak.h" // for isIntrinsicSingleArgCallStmt
42#include "ResolvExpr/TypeEnvironment.h" // for TypeEnvironment
43#include "SymTab/Autogen.h" // for SizeType
44#include "SymTab/Indexer.h" // for Indexer
45#include "SynTree/Declaration.h" // for ObjectDecl, TypeDecl, Declar...
46#include "SynTree/Expression.h" // for Expression, CastExpr, InitExpr
47#include "SynTree/Initializer.h" // for ConstructorInit, SingleInit
48#include "SynTree/Statement.h" // for ForStmt, Statement, BranchStmt
49#include "SynTree/Type.h" // for Type, BasicType, PointerType
50#include "SynTree/TypeSubstitution.h" // for TypeSubstitution
51#include "SynTree/Visitor.h" // for acceptAll, maybeAccept
52#include "Tuples/Tuples.h"
53#include "Validate/FindSpecialDecls.h" // for SizeType
54
55using namespace std;
56
57namespace ResolvExpr {
58 struct Resolver_old final : public WithIndexer, public WithGuards, public WithVisitorRef<Resolver_old>, public WithShortCircuiting, public WithStmtsToAdd {
59 Resolver_old() {}
60 Resolver_old( const SymTab::Indexer & other ) {
61 indexer = other;
62 }
63
64 void previsit( FunctionDecl * functionDecl );
65 void postvisit( FunctionDecl * functionDecl );
66 void previsit( ObjectDecl * objectDecll );
67 void previsit( EnumDecl * enumDecl );
68 void previsit( StaticAssertDecl * assertDecl );
69
70 void previsit( ArrayType * at );
71 void previsit( PointerType * at );
72
73 void previsit( ExprStmt * exprStmt );
74 void previsit( AsmExpr * asmExpr );
75 void previsit( AsmStmt * asmStmt );
76 void previsit( IfStmt * ifStmt );
77 void previsit( WhileStmt * whileStmt );
78 void previsit( ForStmt * forStmt );
79 void previsit( SwitchStmt * switchStmt );
80 void previsit( CaseStmt * caseStmt );
81 void previsit( BranchStmt * branchStmt );
82 void previsit( ReturnStmt * returnStmt );
83 void previsit( ThrowStmt * throwStmt );
84 void previsit( CatchStmt * catchStmt );
85 void previsit( WaitForStmt * stmt );
86
87 void previsit( SingleInit * singleInit );
88 void previsit( ListInit * listInit );
89 void previsit( ConstructorInit * ctorInit );
90 private:
91 typedef std::list< Initializer * >::iterator InitIterator;
92
93 template< typename PtrType >
94 void handlePtrType( PtrType * type );
95
96 void fallbackInit( ConstructorInit * ctorInit );
97
98 Type * functionReturn = nullptr;
99 CurrentObject currentObject = nullptr;
100 bool inEnumDecl = false;
101 };
102
103 struct ResolveWithExprs : public WithIndexer, public WithGuards, public WithVisitorRef<ResolveWithExprs>, public WithShortCircuiting, public WithStmtsToAdd {
104 void previsit( FunctionDecl * );
105 void previsit( WithStmt * );
106
107 void resolveWithExprs( std::list< Expression * > & withExprs, std::list< Statement * > & newStmts );
108 };
109
110 void resolve( std::list< Declaration * > translationUnit ) {
111 PassVisitor<Resolver_old> resolver;
112 acceptAll( translationUnit, resolver );
113 }
114
115 void resolveDecl( Declaration * decl, const SymTab::Indexer & indexer ) {
116 PassVisitor<Resolver_old> resolver( indexer );
117 maybeAccept( decl, resolver );
118 }
119
120 namespace {
121 struct DeleteFinder_old : public WithShortCircuiting {
122 DeletedExpr * delExpr = nullptr;
123 void previsit( DeletedExpr * expr ) {
124 if ( delExpr ) visit_children = false;
125 else delExpr = expr;
126 }
127
128 void previsit( Expression * ) {
129 if ( delExpr ) visit_children = false;
130 }
131 };
132 }
133
134 DeletedExpr * findDeletedExpr( Expression * expr ) {
135 PassVisitor<DeleteFinder_old> finder;
136 expr->accept( finder );
137 return finder.pass.delExpr;
138 }
139
140 namespace {
141 struct StripCasts_old {
142 Expression * postmutate( CastExpr * castExpr ) {
143 if ( castExpr->isGenerated && ResolvExpr::typesCompatible( castExpr->arg->result, castExpr->result, SymTab::Indexer() ) ) {
144 // generated cast is to the same type as its argument, so it's unnecessary -- remove it
145 Expression * expr = castExpr->arg;
146 castExpr->arg = nullptr;
147 std::swap( expr->env, castExpr->env );
148 return expr;
149 }
150 return castExpr;
151 }
152
153 static void strip( Expression *& expr ) {
154 PassVisitor<StripCasts_old> stripper;
155 expr = expr->acceptMutator( stripper );
156 }
157 };
158
159 void finishExpr( Expression *& expr, const TypeEnvironment & env, TypeSubstitution * oldenv = nullptr ) {
160 expr->env = oldenv ? oldenv->clone() : new TypeSubstitution;
161 env.makeSubstitution( *expr->env );
162 StripCasts_old::strip( expr ); // remove unnecessary casts that may be buried in an expression
163 }
164
165 void removeExtraneousCast( Expression *& expr, const SymTab::Indexer & indexer ) {
166 if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
167 if ( typesCompatible( castExpr->arg->result, castExpr->result, indexer ) ) {
168 // cast is to the same type as its argument, so it's unnecessary -- remove it
169 expr = castExpr->arg;
170 castExpr->arg = nullptr;
171 std::swap( expr->env, castExpr->env );
172 delete castExpr;
173 }
174 }
175 }
176 } // namespace
177
178 namespace {
179 void findUnfinishedKindExpression(Expression * untyped, Alternative & alt, const SymTab::Indexer & indexer, const std::string & kindStr, std::function<bool(const Alternative &)> pred, ResolvMode mode = ResolvMode{} ) {
180 assertf( untyped, "expected a non-null expression." );
181
182 // xxx - this isn't thread-safe, but should work until we parallelize the resolver
183 static unsigned recursion_level = 0;
184
185 ++recursion_level;
186 TypeEnvironment env;
187 AlternativeFinder finder( indexer, env );
188 finder.find( untyped, recursion_level == 1 ? mode.atTopLevel() : mode );
189 --recursion_level;
190
191 #if 0
192 if ( finder.get_alternatives().size() != 1 ) {
193 std::cerr << "untyped expr is ";
194 untyped->print( std::cerr );
195 std::cerr << std::endl << "alternatives are:";
196 for ( const Alternative & alt : finder.get_alternatives() ) {
197 alt.print( std::cerr );
198 } // for
199 } // if
200 #endif
201
202 // produce filtered list of alternatives
203 AltList candidates;
204 for ( Alternative & alt : finder.get_alternatives() ) {
205 if ( pred( alt ) ) {
206 candidates.push_back( std::move( alt ) );
207 }
208 }
209
210 // produce invalid error if no candidates
211 if ( candidates.empty() ) {
212 SemanticError( untyped, toString( "No reasonable alternatives for ", kindStr, (kindStr != "" ? " " : ""), "expression: ") );
213 }
214
215 // search for cheapest candidate
216 AltList winners;
217 bool seen_undeleted = false;
218 for ( unsigned i = 0; i < candidates.size(); ++i ) {
219 int c = winners.empty() ? -1 : candidates[i].cost.compare( winners.front().cost );
220
221 if ( c > 0 ) continue; // skip more expensive than winner
222
223 if ( c < 0 ) {
224 // reset on new cheapest
225 seen_undeleted = ! findDeletedExpr( candidates[i].expr );
226 winners.clear();
227 } else /* if ( c == 0 ) */ {
228 if ( findDeletedExpr( candidates[i].expr ) ) {
229 // skip deleted expression if already seen one equivalent-cost not
230 if ( seen_undeleted ) continue;
231 } else if ( ! seen_undeleted ) {
232 // replace list of equivalent-cost deleted expressions with one non-deleted
233 winners.clear();
234 seen_undeleted = true;
235 }
236 }
237
238 winners.emplace_back( std::move( candidates[i] ) );
239 }
240
241 // promote alternative.cvtCost to .cost
242 // xxx - I don't know why this is done, but I'm keeping the behaviour from findMinCost
243 for ( Alternative& winner : winners ) {
244 winner.cost = winner.cvtCost;
245 }
246
247 // produce ambiguous errors, if applicable
248 if ( winners.size() != 1 ) {
249 std::ostringstream stream;
250 stream << "Cannot choose between " << winners.size() << " alternatives for " << kindStr << (kindStr != "" ? " " : "") << "expression\n";
251 untyped->print( stream );
252 stream << " Alternatives are:\n";
253 printAlts( winners, stream, 1 );
254 SemanticError( untyped->location, stream.str() );
255 }
256
257 // single selected choice
258 Alternative& choice = winners.front();
259
260 // fail on only expression deleted
261 if ( ! seen_undeleted ) {
262 SemanticError( untyped->location, choice.expr, "Unique best alternative includes deleted identifier in " );
263 }
264
265 // xxx - check for ambiguous expressions
266
267 // output selected choice
268 alt = std::move( choice );
269 }
270
271 /// resolve `untyped` to the expression whose alternative satisfies `pred` with the lowest cost; kindStr is used for providing better error messages
272 void findKindExpression(Expression *& untyped, const SymTab::Indexer & indexer, const std::string & kindStr, std::function<bool(const Alternative &)> pred, ResolvMode mode = ResolvMode{}) {
273 if ( ! untyped ) return;
274 Alternative choice;
275 findUnfinishedKindExpression( untyped, choice, indexer, kindStr, pred, mode );
276 finishExpr( choice.expr, choice.env, untyped->env );
277 delete untyped;
278 untyped = choice.expr;
279 choice.expr = nullptr;
280 }
281
282 bool standardAlternativeFilter( const Alternative & ) {
283 // currently don't need to filter, under normal circumstances.
284 // in the future, this may be useful for removing deleted expressions
285 return true;
286 }
287 } // namespace
288
289 // used in resolveTypeof
290 Expression * resolveInVoidContext( Expression * expr, const SymTab::Indexer & indexer ) {
291 TypeEnvironment env;
292 return resolveInVoidContext( expr, indexer, env );
293 }
294
295 Expression * resolveInVoidContext( Expression * expr, const SymTab::Indexer & indexer, TypeEnvironment & env ) {
296 // it's a property of the language that a cast expression has either 1 or 0 interpretations; if it has 0
297 // interpretations, an exception has already been thrown.
298 assertf( expr, "expected a non-null expression." );
299
300 CastExpr * untyped = new CastExpr( expr ); // cast to void
301 untyped->location = expr->location;
302
303 // set up and resolve expression cast to void
304 Alternative choice;
305 findUnfinishedKindExpression( untyped, choice, indexer, "", standardAlternativeFilter, ResolvMode::withAdjustment() );
306 CastExpr * castExpr = strict_dynamic_cast< CastExpr * >( choice.expr );
307 assert( castExpr );
308 env = std::move( choice.env );
309
310 // clean up resolved expression
311 Expression * ret = castExpr->arg;
312 castExpr->arg = nullptr;
313
314 // unlink the arg so that it isn't deleted twice at the end of the program
315 untyped->arg = nullptr;
316 return ret;
317 }
318
319 void findVoidExpression( Expression *& untyped, const SymTab::Indexer & indexer ) {
320 resetTyVarRenaming();
321 TypeEnvironment env;
322 Expression * newExpr = resolveInVoidContext( untyped, indexer, env );
323 finishExpr( newExpr, env, untyped->env );
324 delete untyped;
325 untyped = newExpr;
326 }
327
328 void findSingleExpression( Expression *& untyped, const SymTab::Indexer & indexer ) {
329 findKindExpression( untyped, indexer, "", standardAlternativeFilter );
330 }
331
332 void findSingleExpression( Expression *& untyped, Type * type, const SymTab::Indexer & indexer ) {
333 assert( untyped && type );
334 // transfer location to generated cast for error purposes
335 CodeLocation location = untyped->location;
336 untyped = new CastExpr( untyped, type );
337 untyped->location = location;
338 findSingleExpression( untyped, indexer );
339 removeExtraneousCast( untyped, indexer );
340 }
341
342 namespace {
343 bool isIntegralType( const Alternative & alt ) {
344 Type * type = alt.expr->result;
345 if ( dynamic_cast< EnumInstType * >( type ) ) {
346 return true;
347 } else if ( BasicType * bt = dynamic_cast< BasicType * >( type ) ) {
348 return bt->isInteger();
349 } else if ( dynamic_cast< ZeroType* >( type ) != nullptr || dynamic_cast< OneType* >( type ) != nullptr ) {
350 return true;
351 } else {
352 return false;
353 } // if
354 }
355
356 void findIntegralExpression( Expression *& untyped, const SymTab::Indexer & indexer ) {
357 findKindExpression( untyped, indexer, "condition", isIntegralType );
358 }
359 }
360
361
362 bool isStructOrUnion( const Alternative & alt ) {
363 Type * t = alt.expr->result->stripReferences();
364 return dynamic_cast< StructInstType * >( t ) || dynamic_cast< UnionInstType * >( t );
365 }
366
367 void resolveWithExprs( std::list< Declaration * > & translationUnit ) {
368 PassVisitor<ResolveWithExprs> resolver;
369 acceptAll( translationUnit, resolver );
370 }
371
372 void ResolveWithExprs::resolveWithExprs( std::list< Expression * > & withExprs, std::list< Statement * > & newStmts ) {
373 for ( Expression *& expr : withExprs ) {
374 // only struct- and union-typed expressions are viable candidates
375 findKindExpression( expr, indexer, "with statement", isStructOrUnion );
376
377 // if with expression might be impure, create a temporary so that it is evaluated once
378 if ( Tuples::maybeImpure( expr ) ) {
379 static UniqueName tmpNamer( "_with_tmp_" );
380 ObjectDecl * tmp = ObjectDecl::newObject( tmpNamer.newName(), expr->result->clone(), new SingleInit( expr ) );
381 expr = new VariableExpr( tmp );
382 newStmts.push_back( new DeclStmt( tmp ) );
383 if ( InitTweak::isConstructable( tmp->type ) ) {
384 // generate ctor/dtor and resolve them
385 tmp->init = InitTweak::genCtorInit( tmp );
386 tmp->accept( *visitor );
387 }
388 }
389 }
390 }
391
392 void ResolveWithExprs::previsit( WithStmt * withStmt ) {
393 resolveWithExprs( withStmt->exprs, stmtsToAddBefore );
394 }
395
396 void ResolveWithExprs::previsit( FunctionDecl * functionDecl ) {
397 {
398 // resolve with-exprs with parameters in scope and add any newly generated declarations to the
399 // front of the function body.
400 auto guard = makeFuncGuard( [this]() { indexer.enterScope(); }, [this](){ indexer.leaveScope(); } );
401 indexer.addFunctionType( functionDecl->type );
402 std::list< Statement * > newStmts;
403 resolveWithExprs( functionDecl->withExprs, newStmts );
404 if ( functionDecl->statements ) {
405 functionDecl->statements->kids.splice( functionDecl->statements->kids.begin(), newStmts );
406 } else {
407 assertf( functionDecl->withExprs.empty() && newStmts.empty(), "Function %s without a body has with-clause and/or generated with declarations.", functionDecl->name.c_str() );
408 }
409 }
410 }
411
412 void Resolver_old::previsit( ObjectDecl * objectDecl ) {
413 // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that
414 // class-variable initContext is changed multiple time because the LHS is analysed twice.
415 // The second analysis changes initContext because of a function type can contain object
416 // declarations in the return and parameter types. So each value of initContext is
417 // retained, so the type on the first analysis is preserved and used for selecting the RHS.
418 GuardValue( currentObject );
419 currentObject = CurrentObject( objectDecl->get_type() );
420 if ( inEnumDecl && dynamic_cast< EnumInstType * >( objectDecl->get_type() ) ) {
421 // enumerator initializers should not use the enum type to initialize, since
422 // the enum type is still incomplete at this point. Use signed int instead.
423 currentObject = CurrentObject( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
424 }
425 }
426
427 template< typename PtrType >
428 void Resolver_old::handlePtrType( PtrType * type ) {
429 if ( type->get_dimension() ) {
430 findSingleExpression( type->dimension, Validate::SizeType->clone(), indexer );
431 }
432 }
433
434 void Resolver_old::previsit( ArrayType * at ) {
435 handlePtrType( at );
436 }
437
438 void Resolver_old::previsit( PointerType * pt ) {
439 handlePtrType( pt );
440 }
441
442 void Resolver_old::previsit( FunctionDecl * functionDecl ) {
443#if 0
444 std::cerr << "resolver visiting functiondecl ";
445 functionDecl->print( std::cerr );
446 std::cerr << std::endl;
447#endif
448 GuardValue( functionReturn );
449 functionReturn = ResolvExpr::extractResultType( functionDecl->type );
450 }
451
452 void Resolver_old::postvisit( FunctionDecl * functionDecl ) {
453 // default value expressions have an environment which shouldn't be there and trips up
454 // later passes.
455 // xxx - it might be necessary to somehow keep the information from this environment, but I
456 // can't currently see how it's useful.
457 for ( Declaration * d : functionDecl->type->parameters ) {
458 if ( ObjectDecl * obj = dynamic_cast< ObjectDecl * >( d ) ) {
459 if ( SingleInit * init = dynamic_cast< SingleInit * >( obj->init ) ) {
460 delete init->value->env;
461 init->value->env = nullptr;
462 }
463 }
464 }
465 }
466
467 void Resolver_old::previsit( EnumDecl * ) {
468 // in case we decide to allow nested enums
469 GuardValue( inEnumDecl );
470 inEnumDecl = true;
471 }
472
473 void Resolver_old::previsit( StaticAssertDecl * assertDecl ) {
474 findIntegralExpression( assertDecl->condition, indexer );
475 }
476
477 void Resolver_old::previsit( ExprStmt * exprStmt ) {
478 visit_children = false;
479 assertf( exprStmt->expr, "ExprStmt has null Expression in resolver" );
480 findVoidExpression( exprStmt->expr, indexer );
481 }
482
483 void Resolver_old::previsit( AsmExpr * asmExpr ) {
484 visit_children = false;
485 findVoidExpression( asmExpr->operand, indexer );
486 if ( asmExpr->get_inout() ) {
487 findVoidExpression( asmExpr->inout, indexer );
488 } // if
489 }
490
491 void Resolver_old::previsit( AsmStmt * asmStmt ) {
492 visit_children = false;
493 acceptAll( asmStmt->get_input(), *visitor );
494 acceptAll( asmStmt->get_output(), *visitor );
495 }
496
497 void Resolver_old::previsit( IfStmt * ifStmt ) {
498 findIntegralExpression( ifStmt->condition, indexer );
499 }
500
501 void Resolver_old::previsit( WhileStmt * whileStmt ) {
502 findIntegralExpression( whileStmt->condition, indexer );
503 }
504
505 void Resolver_old::previsit( ForStmt * forStmt ) {
506 if ( forStmt->condition ) {
507 findIntegralExpression( forStmt->condition, indexer );
508 } // if
509
510 if ( forStmt->increment ) {
511 findVoidExpression( forStmt->increment, indexer );
512 } // if
513 }
514
515 void Resolver_old::previsit( SwitchStmt * switchStmt ) {
516 GuardValue( currentObject );
517 findIntegralExpression( switchStmt->condition, indexer );
518
519 currentObject = CurrentObject( switchStmt->condition->result );
520 }
521
522 void Resolver_old::previsit( CaseStmt * caseStmt ) {
523 if ( caseStmt->condition ) {
524 std::list< InitAlternative > initAlts = currentObject.getOptions();
525 assertf( initAlts.size() == 1, "SwitchStmt did not correctly resolve an integral expression." );
526 // must remove cast from case statement because RangeExpr cannot be cast.
527 Expression * newExpr = new CastExpr( caseStmt->condition, initAlts.front().type->clone() );
528 findSingleExpression( newExpr, indexer );
529 // case condition cannot have a cast in C, so it must be removed, regardless of whether it performs a conversion.
530 // Ideally we would perform the conversion internally here.
531 if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( newExpr ) ) {
532 newExpr = castExpr->arg;
533 castExpr->arg = nullptr;
534 std::swap( newExpr->env, castExpr->env );
535 delete castExpr;
536 }
537 caseStmt->condition = newExpr;
538 }
539 }
540
541 void Resolver_old::previsit( BranchStmt * branchStmt ) {
542 visit_children = false;
543 // must resolve the argument for a computed goto
544 if ( branchStmt->get_type() == BranchStmt::Goto ) { // check for computed goto statement
545 if ( branchStmt->computedTarget ) {
546 // computed goto argument is void *
547 findSingleExpression( branchStmt->computedTarget, new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), indexer );
548 } // if
549 } // if
550 }
551
552 void Resolver_old::previsit( ReturnStmt * returnStmt ) {
553 visit_children = false;
554 if ( returnStmt->expr ) {
555 findSingleExpression( returnStmt->expr, functionReturn->clone(), indexer );
556 } // if
557 }
558
559 void Resolver_old::previsit( ThrowStmt * throwStmt ) {
560 visit_children = false;
561 // TODO: Replace *exception type with &exception type.
562 if ( throwStmt->get_expr() ) {
563 StructDecl * exception_decl =
564 indexer.lookupStruct( "__cfaabi_ehm__base_exception_t" );
565 assert( exception_decl );
566 Type * exceptType = new PointerType( noQualifiers, new StructInstType( noQualifiers, exception_decl ) );
567 findSingleExpression( throwStmt->expr, exceptType, indexer );
568 }
569 }
570
571 void Resolver_old::previsit( CatchStmt * catchStmt ) {
572 if ( catchStmt->cond ) {
573 findSingleExpression( catchStmt->cond, new BasicType( noQualifiers, BasicType::Bool ), indexer );
574 }
575 }
576
577 template< typename iterator_t >
578 inline bool advance_to_mutex( iterator_t & it, const iterator_t & end ) {
579 while( it != end && !(*it)->get_type()->get_mutex() ) {
580 it++;
581 }
582
583 return it != end;
584 }
585
586 void Resolver_old::previsit( WaitForStmt * stmt ) {
587 visit_children = false;
588
589 // Resolve all clauses first
590 for( auto& clause : stmt->clauses ) {
591
592 TypeEnvironment env;
593 AlternativeFinder funcFinder( indexer, env );
594
595 // Find all alternatives for a function in canonical form
596 funcFinder.findWithAdjustment( clause.target.function );
597
598 if ( funcFinder.get_alternatives().empty() ) {
599 stringstream ss;
600 ss << "Use of undeclared indentifier '";
601 ss << strict_dynamic_cast<NameExpr*>( clause.target.function )->name;
602 ss << "' in call to waitfor";
603 SemanticError( stmt->location, ss.str() );
604 }
605
606 if(clause.target.arguments.empty()) {
607 SemanticError( stmt->location, "Waitfor clause must have at least one mutex parameter");
608 }
609
610 // Find all alternatives for all arguments in canonical form
611 std::vector< AlternativeFinder > argAlternatives;
612 funcFinder.findSubExprs( clause.target.arguments.begin(), clause.target.arguments.end(), back_inserter( argAlternatives ) );
613
614 // List all combinations of arguments
615 std::vector< AltList > possibilities;
616 combos( argAlternatives.begin(), argAlternatives.end(), back_inserter( possibilities ) );
617
618 AltList func_candidates;
619 std::vector< AltList > args_candidates;
620
621 // For every possible function :
622 // try matching the arguments to the parameters
623 // not the other way around because we have more arguments than parameters
624 SemanticErrorException errors;
625 for ( Alternative & func : funcFinder.get_alternatives() ) {
626 try {
627 PointerType * pointer = dynamic_cast< PointerType* >( func.expr->get_result()->stripReferences() );
628 if( !pointer ) {
629 SemanticError( func.expr->get_result(), "candidate not viable: not a pointer type\n" );
630 }
631
632 FunctionType * function = dynamic_cast< FunctionType* >( pointer->get_base() );
633 if( !function ) {
634 SemanticError( pointer->get_base(), "candidate not viable: not a function type\n" );
635 }
636
637
638 {
639 auto param = function->parameters.begin();
640 auto param_end = function->parameters.end();
641
642 if( !advance_to_mutex( param, param_end ) ) {
643 SemanticError(function, "candidate function not viable: no mutex parameters\n");
644 }
645 }
646
647 Alternative newFunc( func );
648 // Strip reference from function
649 referenceToRvalueConversion( newFunc.expr, newFunc.cost );
650
651 // For all the set of arguments we have try to match it with the parameter of the current function alternative
652 for ( auto & argsList : possibilities ) {
653
654 try {
655 // Declare data structures need for resolution
656 OpenVarSet openVars;
657 AssertionSet resultNeed, resultHave;
658 TypeEnvironment resultEnv( func.env );
659 makeUnifiableVars( function, openVars, resultNeed );
660 // add all type variables as open variables now so that those not used in the parameter
661 // list are still considered open.
662 resultEnv.add( function->forall );
663
664 // Load type variables from arguemnts into one shared space
665 simpleCombineEnvironments( argsList.begin(), argsList.end(), resultEnv );
666
667 // Make sure we don't widen any existing bindings
668 resultEnv.forbidWidening();
669
670 // Find any unbound type variables
671 resultEnv.extractOpenVars( openVars );
672
673 auto param = function->parameters.begin();
674 auto param_end = function->parameters.end();
675
676 int n_mutex_param = 0;
677
678 // For every arguments of its set, check if it matches one of the parameter
679 // The order is important
680 for( auto & arg : argsList ) {
681
682 // Ignore non-mutex arguments
683 if( !advance_to_mutex( param, param_end ) ) {
684 // We ran out of parameters but still have arguments
685 // this function doesn't match
686 SemanticError( function, toString("candidate function not viable: too many mutex arguments, expected ", n_mutex_param, "\n" ));
687 }
688
689 n_mutex_param++;
690
691 // Check if the argument matches the parameter type in the current scope
692 if( ! unify( arg.expr->get_result(), (*param)->get_type(), resultEnv, resultNeed, resultHave, openVars, this->indexer ) ) {
693 // Type doesn't match
694 stringstream ss;
695 ss << "candidate function not viable: no known convertion from '";
696 (*param)->get_type()->print( ss );
697 ss << "' to '";
698 arg.expr->get_result()->print( ss );
699 ss << "' with env '";
700 resultEnv.print(ss);
701 ss << "'\n";
702 SemanticError( function, ss.str() );
703 }
704
705 param++;
706 }
707
708 // All arguments match !
709
710 // Check if parameters are missing
711 if( advance_to_mutex( param, param_end ) ) {
712 do {
713 n_mutex_param++;
714 param++;
715 } while( advance_to_mutex( param, param_end ) );
716
717 // We ran out of arguments but still have parameters left
718 // this function doesn't match
719 SemanticError( function, toString("candidate function not viable: too few mutex arguments, expected ", n_mutex_param, "\n" ));
720 }
721
722 // All parameters match !
723
724 // Finish the expressions to tie in the proper environments
725 finishExpr( newFunc.expr, resultEnv );
726 for( Alternative & alt : argsList ) {
727 finishExpr( alt.expr, resultEnv );
728 }
729
730 // This is a match store it and save it for later
731 func_candidates.push_back( newFunc );
732 args_candidates.push_back( argsList );
733
734 }
735 catch( SemanticErrorException & e ) {
736 errors.append( e );
737 }
738 }
739 }
740 catch( SemanticErrorException & e ) {
741 errors.append( e );
742 }
743 }
744
745 // Make sure we got the right number of arguments
746 if( func_candidates.empty() ) { SemanticErrorException top( stmt->location, "No alternatives for function in call to waitfor" ); top.append( errors ); throw top; }
747 if( args_candidates.empty() ) { SemanticErrorException top( stmt->location, "No alternatives for arguments in call to waitfor" ); top.append( errors ); throw top; }
748 if( func_candidates.size() > 1 ) { SemanticErrorException top( stmt->location, "Ambiguous function in call to waitfor" ); top.append( errors ); throw top; }
749 if( args_candidates.size() > 1 ) { SemanticErrorException top( stmt->location, "Ambiguous arguments in call to waitfor" ); top.append( errors ); throw top; }
750 // TODO: need to use findDeletedExpr to ensure no deleted identifiers are used.
751
752 // Swap the results from the alternative with the unresolved values.
753 // Alternatives will handle deletion on destruction
754 std::swap( clause.target.function, func_candidates.front().expr );
755 for( auto arg_pair : group_iterate( clause.target.arguments, args_candidates.front() ) ) {
756 std::swap ( std::get<0>( arg_pair), std::get<1>( arg_pair).expr );
757 }
758
759 // Resolve the conditions as if it were an IfStmt
760 // Resolve the statments normally
761 findSingleExpression( clause.condition, this->indexer );
762 clause.statement->accept( *visitor );
763 }
764
765
766 if( stmt->timeout.statement ) {
767 // Resolve the timeout as an size_t for now
768 // Resolve the conditions as if it were an IfStmt
769 // Resolve the statments normally
770 findSingleExpression( stmt->timeout.time, new BasicType( noQualifiers, BasicType::LongLongUnsignedInt ), this->indexer );
771 findSingleExpression( stmt->timeout.condition, this->indexer );
772 stmt->timeout.statement->accept( *visitor );
773 }
774
775 if( stmt->orelse.statement ) {
776 // Resolve the conditions as if it were an IfStmt
777 // Resolve the statments normally
778 findSingleExpression( stmt->orelse.condition, this->indexer );
779 stmt->orelse.statement->accept( *visitor );
780 }
781 }
782
783 template< typename T >
784 bool isCharType( T t ) {
785 if ( BasicType * bt = dynamic_cast< BasicType * >( t ) ) {
786 return bt->get_kind() == BasicType::Char || bt->get_kind() == BasicType::SignedChar ||
787 bt->get_kind() == BasicType::UnsignedChar;
788 }
789 return false;
790 }
791
792 void Resolver_old::previsit( SingleInit * singleInit ) {
793 visit_children = false;
794 // resolve initialization using the possibilities as determined by the currentObject cursor
795 Expression * newExpr = new UntypedInitExpr( singleInit->value, currentObject.getOptions() );
796 findSingleExpression( newExpr, indexer );
797 InitExpr * initExpr = strict_dynamic_cast< InitExpr * >( newExpr );
798
799 // move cursor to the object that is actually initialized
800 currentObject.setNext( initExpr->get_designation() );
801
802 // discard InitExpr wrapper and retain relevant pieces
803 newExpr = initExpr->expr;
804 initExpr->expr = nullptr;
805 std::swap( initExpr->env, newExpr->env );
806 // InitExpr may have inferParams in the case where the expression specializes a function
807 // pointer, and newExpr may already have inferParams of its own, so a simple swap is not
808 // sufficient.
809 newExpr->spliceInferParams( initExpr );
810 delete initExpr;
811
812 // get the actual object's type (may not exactly match what comes back from the resolver
813 // due to conversions)
814 Type * initContext = currentObject.getCurrentType();
815
816 removeExtraneousCast( newExpr, indexer );
817
818 // check if actual object's type is char[]
819 if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) {
820 if ( isCharType( at->get_base() ) ) {
821 // check if the resolved type is char *
822 if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) {
823 if ( isCharType( pt->get_base() ) ) {
824 if ( CastExpr * ce = dynamic_cast< CastExpr * >( newExpr ) ) {
825 // strip cast if we're initializing a char[] with a char *,
826 // e.g. char x[] = "hello";
827 newExpr = ce->get_arg();
828 ce->set_arg( nullptr );
829 std::swap( ce->env, newExpr->env );
830 delete ce;
831 }
832 }
833 }
834 }
835 }
836
837 // set initializer expr to resolved express
838 singleInit->value = newExpr;
839
840 // move cursor to next object in preparation for next initializer
841 currentObject.increment();
842 }
843
844 void Resolver_old::previsit( ListInit * listInit ) {
845 visit_children = false;
846 // move cursor into brace-enclosed initializer-list
847 currentObject.enterListInit();
848 // xxx - fix this so that the list isn't copied, iterator should be used to change current
849 // element
850 std::list<Designation *> newDesignations;
851 for ( auto p : group_iterate(listInit->get_designations(), listInit->get_initializers()) ) {
852 // iterate designations and initializers in pairs, moving the cursor to the current
853 // designated object and resolving the initializer against that object.
854 Designation * des = std::get<0>(p);
855 Initializer * init = std::get<1>(p);
856 newDesignations.push_back( currentObject.findNext( des ) );
857 init->accept( *visitor );
858 }
859 // set the set of 'resolved' designations and leave the brace-enclosed initializer-list
860 listInit->get_designations() = newDesignations; // xxx - memory management
861 currentObject.exitListInit();
862
863 // xxx - this part has not be folded into CurrentObject yet
864 // } else if ( TypeInstType * tt = dynamic_cast< TypeInstType * >( initContext ) ) {
865 // Type * base = tt->get_baseType()->get_base();
866 // if ( base ) {
867 // // know the implementation type, so try using that as the initContext
868 // ObjectDecl tmpObj( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, base->clone(), nullptr );
869 // currentObject = &tmpObj;
870 // visit( listInit );
871 // } else {
872 // // missing implementation type -- might be an unknown type variable, so try proceeding with the current init context
873 // Parent::visit( listInit );
874 // }
875 // } else {
876 }
877
878 // ConstructorInit - fall back on C-style initializer
879 void Resolver_old::fallbackInit( ConstructorInit * ctorInit ) {
880 // could not find valid constructor, or found an intrinsic constructor
881 // fall back on C-style initializer
882 delete ctorInit->get_ctor();
883 ctorInit->set_ctor( nullptr );
884 delete ctorInit->get_dtor();
885 ctorInit->set_dtor( nullptr );
886 maybeAccept( ctorInit->get_init(), *visitor );
887 }
888
889 // needs to be callable from outside the resolver, so this is a standalone function
890 void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer ) {
891 assert( ctorInit );
892 PassVisitor<Resolver_old> resolver( indexer );
893 ctorInit->accept( resolver );
894 }
895
896 void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer ) {
897 assert( stmtExpr );
898 PassVisitor<Resolver_old> resolver( indexer );
899 stmtExpr->accept( resolver );
900 stmtExpr->computeResult();
901 // xxx - aggregate the environments from all statements? Possibly in AlternativeFinder instead?
902 }
903
904 void Resolver_old::previsit( ConstructorInit * ctorInit ) {
905 visit_children = false;
906 // xxx - fallback init has been removed => remove fallbackInit function and remove complexity from FixInit and remove C-init from ConstructorInit
907 maybeAccept( ctorInit->ctor, *visitor );
908 maybeAccept( ctorInit->dtor, *visitor );
909
910 // found a constructor - can get rid of C-style initializer
911 delete ctorInit->init;
912 ctorInit->init = nullptr;
913
914 // intrinsic single parameter constructors and destructors do nothing. Since this was
915 // implicitly generated, there's no way for it to have side effects, so get rid of it
916 // to clean up generated code.
917 if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->ctor ) ) {
918 delete ctorInit->ctor;
919 ctorInit->ctor = nullptr;
920 }
921
922 if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->dtor ) ) {
923 delete ctorInit->dtor;
924 ctorInit->dtor = nullptr;
925 }
926
927 // xxx - todo -- what about arrays?
928 // if ( dtor == nullptr && InitTweak::isIntrinsicCallStmt( ctorInit->get_ctor() ) ) {
929 // // can reduce the constructor down to a SingleInit using the
930 // // second argument from the ctor call, since
931 // delete ctorInit->get_ctor();
932 // ctorInit->set_ctor( nullptr );
933
934 // Expression * arg =
935 // ctorInit->set_init( new SingleInit( arg ) );
936 // }
937 }
938
939 ///////////////////////////////////////////////////////////////////////////
940 //
941 // *** NEW RESOLVER ***
942 //
943 ///////////////////////////////////////////////////////////////////////////
944
945 namespace {
946 /// Finds deleted expressions in an expression tree
947 struct DeleteFinder_new final : public ast::WithShortCircuiting {
948 const ast::DeletedExpr * delExpr = nullptr;
949
950 void previsit( const ast::DeletedExpr * expr ) {
951 if ( delExpr ) { visit_children = false; }
952 else { delExpr = expr; }
953 }
954
955 void previsit( const ast::Expr * ) {
956 if ( delExpr ) { visit_children = false; }
957 }
958 };
959
960 /// Check if this expression is or includes a deleted expression
961 const ast::DeletedExpr * findDeletedExpr( const ast::Expr * expr ) {
962 ast::Pass<DeleteFinder_new> finder;
963 expr->accept( finder );
964 return finder.pass.delExpr;
965 }
966
967 /// always-accept candidate filter
968 bool anyCandidate( const Candidate & ) { return true; }
969
970 /// Calls the CandidateFinder and finds the single best candidate
971 CandidateRef findUnfinishedKindExpression(
972 const ast::Expr * untyped, const ast::SymbolTable & symtab, const std::string & kind,
973 std::function<bool(const Candidate &)> pred = anyCandidate, ResolvMode mode = {}
974 ) {
975 if ( ! untyped ) return nullptr;
976
977 // xxx - this isn't thread-safe, but should work until we parallelize the resolver
978 static unsigned recursion_level = 0;
979
980 ++recursion_level;
981 ast::TypeEnvironment env;
982 CandidateFinder finder{ symtab, env };
983 finder.find( untyped, recursion_level == 1 ? mode.atTopLevel() : mode );
984 --recursion_level;
985
986 // produce a filtered list of candidates
987 CandidateList candidates;
988 for ( auto & cand : finder.candidates ) {
989 if ( pred( *cand ) ) { candidates.emplace_back( cand ); }
990 }
991
992 // produce invalid error if no candidates
993 if ( candidates.empty() ) {
994 SemanticError( untyped,
995 toString( "No reasonable alternatives for ", kind, (kind != "" ? " " : ""),
996 "expression: ") );
997 }
998
999 // search for cheapest candidate
1000 CandidateList winners;
1001 bool seen_undeleted = false;
1002 for ( CandidateRef & cand : candidates ) {
1003 int c = winners.empty() ? -1 : cand->cost.compare( winners.front()->cost );
1004
1005 if ( c > 0 ) continue; // skip more expensive than winner
1006
1007 if ( c < 0 ) {
1008 // reset on new cheapest
1009 seen_undeleted = ! findDeletedExpr( cand->expr );
1010 winners.clear();
1011 } else /* if ( c == 0 ) */ {
1012 if ( findDeletedExpr( cand->expr ) ) {
1013 // skip deleted expression if already seen one equivalent-cost not
1014 if ( seen_undeleted ) continue;
1015 } else if ( ! seen_undeleted ) {
1016 // replace list of equivalent-cost deleted expressions with one non-deleted
1017 winners.clear();
1018 seen_undeleted = true;
1019 }
1020 }
1021
1022 winners.emplace_back( std::move( cand ) );
1023 }
1024
1025 // promote candidate.cvtCost to .cost
1026 for ( CandidateRef & cand : winners ) {
1027 cand->cost = cand->cvtCost;
1028 }
1029
1030 // produce ambiguous errors, if applicable
1031 if ( winners.size() != 1 ) {
1032 std::ostringstream stream;
1033 stream << "Cannot choose between " << winners.size() << " alternatives for "
1034 << kind << (kind != "" ? " " : "") << "expression\n";
1035 ast::print( stream, untyped );
1036 stream << " Alternatives are:\n";
1037 print( stream, winners, 1 );
1038 SemanticError( untyped->location, stream.str() );
1039 }
1040
1041 // single selected choice
1042 CandidateRef & choice = winners.front();
1043
1044 // fail on only expression deleted
1045 if ( ! seen_undeleted ) {
1046 SemanticError( untyped->location, choice->expr.get(), "Unique best alternative "
1047 "includes deleted identifier in " );
1048 }
1049
1050 return std::move( choice );
1051 }
1052
1053 /// Strips extraneous casts out of an expression
1054 struct StripCasts_new final {
1055 const ast::Expr * postmutate( const ast::CastExpr * castExpr ) {
1056 if (
1057 castExpr->isGenerated
1058 && typesCompatible( castExpr->arg->result, castExpr->result )
1059 ) {
1060 // generated cast is the same type as its argument, remove it after keeping env
1061 return ast::mutate_field(
1062 castExpr->arg.get(), &ast::Expr::env, castExpr->env );
1063 }
1064 return castExpr;
1065 }
1066
1067 static void strip( ast::ptr< ast::Expr > & expr ) {
1068 ast::Pass< StripCasts_new > stripper;
1069 expr = expr->accept( stripper );
1070 }
1071 };
1072
1073 /// Removes cast to type of argument (unlike StripCasts, also handles non-generated casts)
1074 void removeExtraneousCast( ast::ptr<ast::Expr> & expr, const ast::SymbolTable & symtab ) {
1075 if ( const ast::CastExpr * castExpr = expr.as< ast::CastExpr >() ) {
1076 if ( typesCompatible( castExpr->arg->result, castExpr->result, symtab ) ) {
1077 // cast is to the same type as its argument, remove it
1078 ast::ptr< ast::TypeSubstitution > env = castExpr->env;
1079 expr.set_and_mutate( castExpr->arg )->env = env;
1080 }
1081 }
1082 }
1083
1084 /// Establish post-resolver invariants for expressions
1085 void finishExpr(
1086 ast::ptr< ast::Expr > & expr, const ast::TypeEnvironment & env,
1087 const ast::TypeSubstitution * oldenv = nullptr
1088 ) {
1089 // set up new type substitution for expression
1090 ast::ptr< ast::TypeSubstitution > newenv =
1091 oldenv ? oldenv : new ast::TypeSubstitution{};
1092 env.writeToSubstitution( *newenv.get_and_mutate() );
1093 expr.get_and_mutate()->env = std::move( newenv );
1094 // remove unncecessary casts
1095 StripCasts_new::strip( expr );
1096 }
1097
1098 /// Find the expression candidate that is the unique best match for `untyped` in a `void`
1099 /// context.
1100 ast::ptr< ast::Expr > resolveInVoidContext(
1101 const ast::Expr * expr, const ast::SymbolTable & symtab, ast::TypeEnvironment & env
1102 ) {
1103 assertf( expr, "expected a non-null expression" );
1104
1105 // set up and resolve expression cast to void
1106 ast::CastExpr * untyped = new ast::CastExpr{ expr->location, expr };
1107 CandidateRef choice = findUnfinishedKindExpression(
1108 untyped, symtab, "", anyCandidate, ResolvMode::withAdjustment() );
1109
1110 // a cast expression has either 0 or 1 interpretations (by language rules);
1111 // if 0, an exception has already been thrown, and this code will not run
1112 const ast::CastExpr * castExpr = choice->expr.strict_as< ast::CastExpr >();
1113 env = std::move( choice->env );
1114
1115 return castExpr->arg;
1116 }
1117
1118 /// Resolve `untyped` to the expression whose candidate is the best match for a `void`
1119 /// context.
1120 ast::ptr< ast::Expr > findVoidExpression(
1121 const ast::Expr * untyped, const ast::SymbolTable & symtab
1122 ) {
1123 resetTyVarRenaming();
1124 ast::TypeEnvironment env;
1125 ast::ptr< ast::Expr > newExpr = resolveInVoidContext( untyped, symtab, env );
1126 finishExpr( newExpr, env, untyped->env );
1127 return newExpr;
1128 }
1129
1130 /// resolve `untyped` to the expression whose candidate satisfies `pred` with the
1131 /// lowest cost, returning the resolved version
1132 ast::ptr< ast::Expr > findKindExpression(
1133 const ast::Expr * untyped, const ast::SymbolTable & symtab,
1134 std::function<bool(const Candidate &)> pred = anyCandidate,
1135 const std::string & kind = "", ResolvMode mode = {}
1136 ) {
1137 if ( ! untyped ) return {};
1138 CandidateRef choice =
1139 findUnfinishedKindExpression( untyped, symtab, kind, pred, mode );
1140 finishExpr( choice->expr, choice->env, untyped->env );
1141 return std::move( choice->expr );
1142 }
1143
1144 /// Resolve `untyped` to the single expression whose candidate is the best match for the
1145 /// given type.
1146 ast::ptr< ast::Expr > findSingleExpression(
1147 const ast::Expr * untyped, const ast::Type * type, const ast::SymbolTable & symtab
1148 ) {
1149 assert( untyped && type );
1150 const ast::Expr * castExpr = new ast::CastExpr{ untyped->location, untyped, type };
1151 ast::ptr< ast::Expr > newExpr = findKindExpression( castExpr, symtab );
1152 removeExtraneousCast( newExpr, symtab );
1153 return newExpr;
1154 }
1155
1156 /// Predicate for "Candidate has integral type"
1157 bool hasIntegralType( const Candidate & i ) {
1158 const ast::Type * type = i.expr->result;
1159
1160 if ( auto bt = dynamic_cast< const ast::BasicType * >( type ) ) {
1161 return bt->isInteger();
1162 } else if (
1163 dynamic_cast< const ast::EnumInstType * >( type )
1164 || dynamic_cast< const ast::ZeroType * >( type )
1165 || dynamic_cast< const ast::OneType * >( type )
1166 ) {
1167 return true;
1168 } else return false;
1169 }
1170
1171 /// Resolve `untyped` as an integral expression, returning the resolved version
1172 ast::ptr< ast::Expr > findIntegralExpression(
1173 const ast::Expr * untyped, const ast::SymbolTable & symtab
1174 ) {
1175 return findKindExpression( untyped, symtab, hasIntegralType, "condition" );
1176 }
1177 }
1178
1179 class Resolver_new final
1180 : public ast::WithSymbolTable, public ast::WithGuards,
1181 public ast::WithVisitorRef<Resolver_new>, public ast::WithShortCircuiting,
1182 public ast::WithStmtsToAdd<> {
1183
1184 ast::ptr< ast::Type > functionReturn = nullptr;
1185 ast::CurrentObject currentObject;
1186 bool inEnumDecl = false;
1187
1188 public:
1189 Resolver_new() = default;
1190 Resolver_new( const ast::SymbolTable & syms ) { symtab = syms; }
1191
1192 void previsit( const ast::FunctionDecl * );
1193 const ast::FunctionDecl * postvisit( const ast::FunctionDecl * );
1194 void previsit( const ast::ObjectDecl * );
1195 void previsit( const ast::EnumDecl * );
1196 const ast::StaticAssertDecl * previsit( const ast::StaticAssertDecl * );
1197
1198 void previsit( const ast::ArrayType * );
1199 void previsit( const ast::PointerType * );
1200
1201 const ast::ExprStmt * previsit( const ast::ExprStmt * );
1202 const ast::AsmExpr * previsit( const ast::AsmExpr * );
1203 const ast::AsmStmt * previsit( const ast::AsmStmt * );
1204 const ast::IfStmt * previsit( const ast::IfStmt * );
1205 const ast::WhileStmt * previsit( const ast::WhileStmt * );
1206 const ast::ForStmt * previsit( const ast::ForStmt * );
1207 const ast::SwitchStmt * previsit( const ast::SwitchStmt * );
1208 const ast::CaseStmt * previsit( const ast::CaseStmt * );
1209 const ast::BranchStmt * previsit( const ast::BranchStmt * );
1210 const ast::ReturnStmt * previsit( const ast::ReturnStmt * );
1211 const ast::ThrowStmt * previsit( const ast::ThrowStmt * );
1212 const ast::CatchStmt * previsit( const ast::CatchStmt * );
1213 void previsit( const ast::WaitForStmt * );
1214
1215 void previsit( const ast::SingleInit * );
1216 void previsit( const ast::ListInit * );
1217 void previsit( const ast::ConstructorInit * );
1218 };
1219
1220 void resolve( std::list< ast::ptr<ast::Decl> >& translationUnit ) {
1221 ast::Pass<Resolver_new> resolver;
1222 accept_all( translationUnit, resolver );
1223 }
1224
1225 void Resolver_new::previsit( const ast::FunctionDecl * functionDecl ) {
1226 GuardValue( functionReturn );
1227 functionReturn = extractResultType( functionDecl->type );
1228 }
1229
1230 const ast::FunctionDecl * Resolver_new::postvisit( const ast::FunctionDecl * functionDecl ) {
1231 // default value expressions have an environment which shouldn't be there and trips up
1232 // later passes.
1233 ast::ptr< ast::FunctionDecl > ret = functionDecl;
1234 for ( unsigned i = 0; i < functionDecl->type->params.size(); ++i ) {
1235 const ast::ptr<ast::DeclWithType> & d = functionDecl->type->params[i];
1236
1237 if ( const ast::ObjectDecl * obj = d.as< ast::ObjectDecl >() ) {
1238 if ( const ast::SingleInit * init = obj->init.as< ast::SingleInit >() ) {
1239 if ( init->value->env == nullptr ) continue;
1240 // clone initializer minus the initializer environment
1241 ast::chain_mutate( ret )
1242 ( &ast::FunctionDecl::type )
1243 ( &ast::FunctionType::params )[i]
1244 ( &ast::ObjectDecl::init )
1245 ( &ast::SingleInit::value )->env = nullptr;
1246
1247 assert( functionDecl != ret.get() || functionDecl->unique() );
1248 assert( ! ret->type->params[i].strict_as< ast::ObjectDecl >()->init.strict_as< ast::SingleInit >()->value->env );
1249 }
1250 }
1251 }
1252 return ret.get();
1253 }
1254
1255 void Resolver_new::previsit( const ast::ObjectDecl * objectDecl ) {
1256 // To handle initialization of routine pointers [e.g. int (*fp)(int) = foo()],
1257 // class-variable `initContext` is changed multiple times because the LHS is analyzed
1258 // twice. The second analysis changes `initContext` because a function type can contain
1259 // object declarations in the return and parameter types. Therefore each value of
1260 // `initContext` is retained so the type on the first analysis is preserved and used for
1261 // selecting the RHS.
1262 GuardValue( currentObject );
1263 currentObject = ast::CurrentObject{ objectDecl->location, objectDecl->get_type() };
1264 if ( inEnumDecl && dynamic_cast< const ast::EnumInstType * >( objectDecl->get_type() ) ) {
1265 // enumerator initializers should not use the enum type to initialize, since the
1266 // enum type is still incomplete at this point. Use `int` instead.
1267 currentObject = ast::CurrentObject{
1268 objectDecl->location, new ast::BasicType{ ast::BasicType::SignedInt } };
1269 }
1270 }
1271
1272 void Resolver_new::previsit( const ast::EnumDecl * ) {
1273 // in case we decide to allow nested enums
1274 GuardValue( inEnumDecl );
1275 inEnumDecl = false;
1276 }
1277
1278 const ast::StaticAssertDecl * Resolver_new::previsit(
1279 const ast::StaticAssertDecl * assertDecl
1280 ) {
1281 return ast::mutate_field(
1282 assertDecl, &ast::StaticAssertDecl::cond,
1283 findIntegralExpression( assertDecl->cond, symtab ) );
1284 }
1285
1286 template< typename PtrType >
1287 void handlePtrType( const PtrType * type, const ast::SymbolTable & symtab ) {
1288 #warning unimplemented; needs support for new Validate::SizeType global
1289 (void)type; (void)symtab;
1290 assert( false );
1291 }
1292
1293 void Resolver_new::previsit( const ast::ArrayType * at ) {
1294 handlePtrType( at, symtab );
1295 }
1296
1297 void Resolver_new::previsit( const ast::PointerType * pt ) {
1298 handlePtrType( pt, symtab );
1299 }
1300
1301 const ast::ExprStmt * Resolver_new::previsit( const ast::ExprStmt * exprStmt ) {
1302 visit_children = false;
1303 assertf( exprStmt->expr, "ExprStmt has null expression in resolver" );
1304
1305 return ast::mutate_field(
1306 exprStmt, &ast::ExprStmt::expr, findVoidExpression( exprStmt->expr, symtab ) );
1307 }
1308
1309 const ast::AsmExpr * Resolver_new::previsit( const ast::AsmExpr * asmExpr ) {
1310 visit_children = false;
1311
1312 asmExpr = ast::mutate_field(
1313 asmExpr, &ast::AsmExpr::operand, findVoidExpression( asmExpr->operand, symtab ) );
1314
1315 if ( asmExpr->inout ) {
1316 asmExpr = ast::mutate_field(
1317 asmExpr, &ast::AsmExpr::inout, findVoidExpression( asmExpr->inout, symtab ) );
1318 }
1319
1320 return asmExpr;
1321 }
1322
1323 const ast::AsmStmt * Resolver_new::previsit( const ast::AsmStmt * asmStmt ) {
1324 visitor->maybe_accept( asmStmt, &ast::AsmStmt::input );
1325 visitor->maybe_accept( asmStmt, &ast::AsmStmt::output );
1326 visit_children = false;
1327 return asmStmt;
1328 }
1329
1330 const ast::IfStmt * Resolver_new::previsit( const ast::IfStmt * ifStmt ) {
1331 return ast::mutate_field(
1332 ifStmt, &ast::IfStmt::cond, findIntegralExpression( ifStmt->cond, symtab ) );
1333 }
1334
1335 const ast::WhileStmt * Resolver_new::previsit( const ast::WhileStmt * whileStmt ) {
1336 return ast::mutate_field(
1337 whileStmt, &ast::WhileStmt::cond, findIntegralExpression( whileStmt->cond, symtab ) );
1338 }
1339
1340 const ast::ForStmt * Resolver_new::previsit( const ast::ForStmt * forStmt ) {
1341 if ( forStmt->cond ) {
1342 forStmt = ast::mutate_field(
1343 forStmt, &ast::ForStmt::cond, findIntegralExpression( forStmt->cond, symtab ) );
1344 }
1345
1346 if ( forStmt->inc ) {
1347 forStmt = ast::mutate_field(
1348 forStmt, &ast::ForStmt::inc, findVoidExpression( forStmt->inc, symtab ) );
1349 }
1350
1351 return forStmt;
1352 }
1353
1354 const ast::SwitchStmt * Resolver_new::previsit( const ast::SwitchStmt * switchStmt ) {
1355 GuardValue( currentObject );
1356 switchStmt = ast::mutate_field(
1357 switchStmt, &ast::SwitchStmt::cond,
1358 findIntegralExpression( switchStmt->cond, symtab ) );
1359 currentObject = ast::CurrentObject{ switchStmt->location, switchStmt->cond->result };
1360 return switchStmt;
1361 }
1362
1363 const ast::CaseStmt * Resolver_new::previsit( const ast::CaseStmt * caseStmt ) {
1364 if ( caseStmt->cond ) {
1365 std::vector< ast::InitAlternative > initAlts = currentObject.getOptions();
1366 assertf( initAlts.size() == 1, "SwitchStmt did not correctly resolve an integral "
1367 "expression." );
1368
1369 const ast::Expr * untyped =
1370 new ast::CastExpr{ caseStmt->location, caseStmt->cond, initAlts.front().type };
1371 ast::ptr< ast::Expr > newExpr = findKindExpression( untyped, symtab );
1372
1373 // case condition cannot have a cast in C, so it must be removed here, regardless of
1374 // whether it would perform a conversion.
1375 if ( const ast::CastExpr * castExpr = newExpr.as< ast::CastExpr >() ) {
1376 ast::ptr< ast::TypeSubstitution > env = castExpr->env;
1377 newExpr.set_and_mutate( castExpr->arg )->env = env;
1378 }
1379
1380 caseStmt = ast::mutate_field( caseStmt, &ast::CaseStmt::cond, newExpr );
1381 }
1382 return caseStmt;
1383 }
1384
1385 const ast::BranchStmt * Resolver_new::previsit( const ast::BranchStmt * branchStmt ) {
1386 visit_children = false;
1387 // must resolve the argument of a computed goto
1388 if ( branchStmt->kind == ast::BranchStmt::Goto && branchStmt->computedTarget ) {
1389 // computed goto argument is void*
1390 branchStmt = ast::mutate_field(
1391 branchStmt, &ast::BranchStmt::computedTarget,
1392 findSingleExpression(
1393 branchStmt->computedTarget, new ast::PointerType{ new ast::VoidType{} },
1394 symtab ) );
1395 }
1396 return branchStmt;
1397 }
1398
1399 const ast::ReturnStmt * Resolver_new::previsit( const ast::ReturnStmt * returnStmt ) {
1400 visit_children = false;
1401 if ( returnStmt->expr ) {
1402 returnStmt = ast::mutate_field(
1403 returnStmt, &ast::ReturnStmt::expr,
1404 findSingleExpression( returnStmt->expr, functionReturn, symtab ) );
1405 }
1406 return returnStmt;
1407 }
1408
1409 const ast::ThrowStmt * Resolver_new::previsit( const ast::ThrowStmt * throwStmt ) {
1410 visit_children = false;
1411 if ( throwStmt->expr ) {
1412 const ast::StructDecl * exceptionDecl =
1413 symtab.lookupStruct( "__cfaabi_ehm__base_exception_t" );
1414 assert( exceptionDecl );
1415 ast::ptr< ast::Type > exceptType =
1416 new ast::PointerType{ new ast::StructInstType{ exceptionDecl } };
1417 throwStmt = ast::mutate_field(
1418 throwStmt, &ast::ThrowStmt::expr,
1419 findSingleExpression( throwStmt->expr, exceptType, symtab ) );
1420 }
1421 return throwStmt;
1422 }
1423
1424 const ast::CatchStmt * Resolver_new::previsit( const ast::CatchStmt * catchStmt ) {
1425 if ( catchStmt->cond ) {
1426 ast::ptr< ast::Type > boolType = new ast::BasicType{ ast::BasicType::Bool };
1427 catchStmt = ast::mutate_field(
1428 catchStmt, &ast::CatchStmt::cond,
1429 findSingleExpression( catchStmt->cond, boolType, symtab ) );
1430 }
1431 return catchStmt;
1432 }
1433
1434 void Resolver_new::previsit( const ast::WaitForStmt * stmt ) {
1435 #warning unimplemented; Resolver port in progress
1436 (void)stmt;
1437 assert(false);
1438 }
1439
1440 void Resolver_new::previsit( const ast::SingleInit * singleInit ) {
1441 #warning unimplemented; Resolver port in progress
1442 (void)singleInit;
1443 assert(false);
1444 }
1445
1446 void Resolver_new::previsit( const ast::ListInit * listInit ) {
1447 #warning unimplemented; Resolver port in progress
1448 (void)listInit;
1449 assert(false);
1450 }
1451
1452 void Resolver_new::previsit( const ast::ConstructorInit * ctorInit ) {
1453 #warning unimplemented; Resolver port in progress
1454 (void)ctorInit;
1455 assert(false);
1456 }
1457
1458} // namespace ResolvExpr
1459
1460// Local Variables: //
1461// tab-width: 4 //
1462// mode: c++ //
1463// compile-command: "make install" //
1464// End: //
Note: See TracBrowser for help on using the repository browser.