source: src/ResolvExpr/AlternativeFinder.h@ 78a0b88

ADT aaron-thesis arm-eh ast-experimental cleanup-dtors deferred_resn demangler enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox new-ast new-ast-unique-expr new-env no_list persistent-indexer pthread-emulation qualifiedEnum resolv-new with_gc
Last change on this file since 78a0b88 was ea6332d, checked in by Thierry Delisle <tdelisle@…>, 8 years ago

Big header cleaning pass - commit 3
  • Property mode set to 100644
File size: 6.4 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// AlternativeFinder.h --
8//
9// Author : Richard C. Bilson
10// Created On : Sat May 16 23:56:12 2015
11// Last Modified By : Andrew Beach
12// Last Modified On : Wed Jul 26 11:24:00 2017
13// Update Count : 4
14//
15
16#pragma once
17
18#include <algorithm> // for copy
19#include <list> // for list
20#include <string> // for string
21
22#include "Alternative.h" // for AltList, Alternative
23#include "ResolvExpr/Cost.h" // for Cost, Cost::infinity
24#include "ResolvExpr/TypeEnvironment.h" // for AssertionSet, OpenVarSet
25#include "SynTree/Visitor.h" // for Visitor
26#include "SynTree/SynTree.h" // for Visitor Nodes
27
28namespace SymTab {
29class Indexer;
30} // namespace SymTab
31
32namespace ResolvExpr {
33 class AlternativeFinder : public Visitor {
34 public:
35 AlternativeFinder( const SymTab::Indexer &indexer, const TypeEnvironment &env );
36 void find( Expression *expr, bool adjust = false, bool prune = true );
37 /// Calls find with the adjust flag set; adjustment turns array and function types into equivalent pointer types
38 void findWithAdjustment( Expression *expr, bool prune = true );
39 AltList &get_alternatives() { return alternatives; }
40
41 // make this look like an STL container so that we can apply generic algorithms
42 typedef Alternative value_type;
43 typedef AltList::iterator iterator;
44 typedef AltList::const_iterator const_iterator;
45 AltList::iterator begin() { return alternatives.begin(); }
46 AltList::iterator end() { return alternatives.end(); }
47 AltList::const_iterator begin() const { return alternatives.begin(); }
48 AltList::const_iterator end() const { return alternatives.end(); }
49
50 const SymTab::Indexer &get_indexer() const { return indexer; }
51 const TypeEnvironment &get_environ() const { return env; }
52 private:
53 virtual void visit( ApplicationExpr *applicationExpr );
54 virtual void visit( UntypedExpr *untypedExpr );
55 virtual void visit( AddressExpr *addressExpr );
56 virtual void visit( CastExpr *castExpr );
57 virtual void visit( VirtualCastExpr *castExpr );
58 virtual void visit( UntypedMemberExpr *memberExpr );
59 virtual void visit( MemberExpr *memberExpr );
60 virtual void visit( NameExpr *variableExpr );
61 virtual void visit( VariableExpr *variableExpr );
62 virtual void visit( ConstantExpr *constantExpr );
63 virtual void visit( SizeofExpr *sizeofExpr );
64 virtual void visit( AlignofExpr *alignofExpr );
65 virtual void visit( UntypedOffsetofExpr *offsetofExpr );
66 virtual void visit( OffsetofExpr *offsetofExpr );
67 virtual void visit( OffsetPackExpr *offsetPackExpr );
68 virtual void visit( AttrExpr *attrExpr );
69 virtual void visit( LogicalExpr *logicalExpr );
70 virtual void visit( ConditionalExpr *conditionalExpr );
71 virtual void visit( CommaExpr *commaExpr );
72 virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr );
73 virtual void visit( ConstructorExpr * ctorExpr );
74 virtual void visit( RangeExpr * rangeExpr );
75 virtual void visit( UntypedTupleExpr *tupleExpr );
76 virtual void visit( TupleExpr *tupleExpr );
77 virtual void visit( TupleIndexExpr *tupleExpr );
78 virtual void visit( TupleAssignExpr *tupleExpr );
79 virtual void visit( UniqueExpr *unqExpr );
80 virtual void visit( StmtExpr *stmtExpr );
81 virtual void visit( UntypedInitExpr *initExpr );
82 /// Runs a new alternative finder on each element in [begin, end)
83 /// and writes each alternative finder to out.
84 template< typename InputIterator, typename OutputIterator >
85 void findSubExprs( InputIterator begin, InputIterator end, OutputIterator out );
86
87 /// Adds alternatives for anonymous members
88 void addAnonConversions( const Alternative & alt );
89 /// Adds alternatives for member expressions, given the aggregate, conversion cost for that aggregate, and name of the member
90 template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member );
91 /// Adds alternatives for member expressions where the left side has tuple type
92 void addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member );
93 /// Adds alternatives for offsetof expressions, given the base type and name of the member
94 template< typename StructOrUnionType > void addOffsetof( StructOrUnionType *aggInst, const std::string &name );
95 bool instantiateFunction( std::list< DeclarationWithType* >& formals, const AltList &actuals, bool isVarArgs, OpenVarSet& openVars, TypeEnvironment &resultEnv, AssertionSet &resultNeed, AssertionSet &resultHave, AltList & out );
96 template< typename OutputIterator >
97 void makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, const AltList &actualAlt, OutputIterator out );
98 template< typename OutputIterator >
99 void inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out );
100 void resolveAttr( DeclarationWithType *funcDecl, FunctionType *function, Type *argType, const TypeEnvironment &env );
101
102 const SymTab::Indexer &indexer;
103 AltList alternatives;
104 const TypeEnvironment &env;
105 Type * targetType = nullptr;
106 }; // AlternativeFinder
107
108 Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer, TypeEnvironment &env );
109
110 template< typename InputIterator, typename OutputIterator >
111 void findMinCost( InputIterator begin, InputIterator end, OutputIterator out ) {
112 AltList alternatives;
113
114 // select the alternatives that have the minimum parameter cost
115 Cost minCost = Cost::infinity;
116 for ( InputIterator i = begin; i != end; ++i ) {
117 if ( i->cost < minCost ) {
118 minCost = i->cost;
119 i->cost = i->cvtCost;
120 alternatives.clear();
121 alternatives.push_back( *i );
122 } else if ( i->cost == minCost ) {
123 i->cost = i->cvtCost;
124 alternatives.push_back( *i );
125 }
126 }
127 std::copy( alternatives.begin(), alternatives.end(), out );
128 }
129
130 Cost sumCost( const AltList &in );
131
132 template< typename InputIterator >
133 void simpleCombineEnvironments( InputIterator begin, InputIterator end, TypeEnvironment &result ) {
134 while ( begin != end ) {
135 result.simpleCombine( (*begin++).env );
136 }
137 }
138} // namespace ResolvExpr
139
140// Local Variables: //
141// tab-width: 4 //
142// mode: c++ //
143// compile-command: "make install" //
144// End: //
Note: See TracBrowser for help on using the repository browser.