source: src/InitTweak/InitTweak.cc@ 40e636a

ADT aaron-thesis arm-eh ast-experimental cleanup-dtors ctor deferred_resn demangler enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox memory 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 40e636a was 40e636a, checked in by Rob Schluntz <rschlunt@…>, 9 years ago

only generate array dimension constant inside of functions, recursively mutate array types into pointer types in function parameter lists, fix bug where global compound literal object is lost
  • Property mode set to 100644
File size: 7.9 KB
Line 
1#include "InitTweak.h"
2#include "SynTree/Visitor.h"
3#include "SynTree/Statement.h"
4#include "SynTree/Initializer.h"
5#include "SynTree/Expression.h"
6#include "GenPoly/GenPoly.h"
7
8namespace InitTweak {
9 namespace {
10 class HasDesignations : public Visitor {
11 public:
12 bool hasDesignations = false;
13 template<typename Init>
14 void handleInit( Init * init ) {
15 if ( ! init->get_designators().empty() ) hasDesignations = true;
16 else Visitor::visit( init );
17 }
18 virtual void visit( SingleInit * singleInit ) { handleInit( singleInit); }
19 virtual void visit( ListInit * listInit ) { handleInit( listInit); }
20 };
21
22 class InitExpander : public Visitor {
23 public:
24 InitExpander() {}
25 virtual void visit( SingleInit * singleInit );
26 virtual void visit( ListInit * listInit );
27 std::list< Expression * > argList;
28 };
29
30 void InitExpander::visit( SingleInit * singleInit ) {
31 argList.push_back( singleInit->get_value()->clone() );
32 }
33
34 void InitExpander::visit( ListInit * listInit ) {
35 // xxx - for now, assume no nested list inits
36 std::list<Initializer*>::iterator it = listInit->begin_initializers();
37 for ( ; it != listInit->end_initializers(); ++it ) {
38 (*it)->accept( *this );
39 }
40 }
41 }
42
43 std::list< Expression * > makeInitList( Initializer * init ) {
44 InitExpander expander;
45 maybeAccept( init, expander );
46 return expander.argList;
47 }
48
49 bool isDesignated( Initializer * init ) {
50 HasDesignations finder;
51 maybeAccept( init, finder );
52 return finder.hasDesignations;
53 }
54
55 bool tryConstruct( ObjectDecl * objDecl ) {
56 return ! LinkageSpec::isBuiltin( objDecl->get_linkage() ) &&
57 (objDecl->get_init() == NULL ||
58 ( objDecl->get_init() != NULL && objDecl->get_init()->get_maybeConstructed() )) &&
59 ! isDesignated( objDecl->get_init() );
60 }
61
62 Expression * getCtorDtorCall( Statement * stmt ) {
63 if ( stmt == NULL ) return NULL;
64 if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( stmt ) ) {
65 return exprStmt->get_expr();
66 } else if ( CompoundStmt * compoundStmt = dynamic_cast< CompoundStmt * >( stmt ) ) {
67 // could also be a compound statement with a loop, in the case of an array
68 if( compoundStmt->get_kids().size() == 2 ) {
69 // loop variable and loop
70 ForStmt * forStmt = dynamic_cast< ForStmt * >( compoundStmt->get_kids().back() );
71 assert( forStmt && forStmt->get_body() );
72 return getCtorDtorCall( forStmt->get_body() );
73 } else if ( compoundStmt->get_kids().size() == 1 ) {
74 // should be the call statement, but in any case there's only one option
75 return getCtorDtorCall( compoundStmt->get_kids().front() );
76 } else {
77 assert( false && "too many statements in compoundStmt for getCtorDtorCall" );
78 }
79 } if ( ImplicitCtorDtorStmt * impCtorDtorStmt = dynamic_cast< ImplicitCtorDtorStmt * > ( stmt ) ) {
80 return getCtorDtorCall( impCtorDtorStmt->get_callStmt() );
81 } else {
82 // should never get here
83 assert( false && "encountered unknown call statement" );
84 }
85 }
86
87 bool isInstrinsicSingleArgCallStmt( Statement * stmt ) {
88 Expression * callExpr = getCtorDtorCall( stmt );
89 if ( ! callExpr ) return false;
90 ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( callExpr );
91 assert( appExpr );
92 VariableExpr * function = dynamic_cast< VariableExpr * >( appExpr->get_function() );
93 assert( function );
94 // check for Intrinsic only - don't want to remove all overridable ctor/dtors because autogenerated ctor/dtor
95 // will call all member dtors, and some members may have a user defined dtor.
96 FunctionType * funcType = GenPoly::getFunctionType( function->get_var()->get_type() );
97 assert( funcType );
98 return function->get_var()->get_linkage() == LinkageSpec::Intrinsic && funcType->get_parameters().size() == 1;
99 }
100
101 namespace {
102 template<typename CallExpr>
103 Expression *& callArg( CallExpr * callExpr, unsigned int pos ) {
104 if ( pos >= callExpr->get_args().size() ) assert( false && "asking for argument that doesn't exist. Return NULL/throw exception?" );
105 for ( Expression *& arg : callExpr->get_args() ) {
106 if ( pos == 0 ) return arg;
107 pos--;
108 }
109 assert( false );
110 }
111 }
112
113 Expression *& getCallArg( Expression * callExpr, unsigned int pos ) {
114 if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( callExpr ) ) {
115 return callArg( appExpr, pos );
116 } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * >( callExpr ) ) {
117 return callArg( untypedExpr, pos );
118 } else {
119 assert( false && "Unexpected expression type passed to getCallArg" );
120 }
121 }
122
123 namespace {
124 std::string funcName( Expression * func ) {
125 if ( NameExpr * nameExpr = dynamic_cast< NameExpr * >( func ) ) {
126 return nameExpr->get_name();
127 } else if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( func ) ) {
128 return varExpr->get_var()->get_name();
129 } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( func ) ) {
130 return funcName( castExpr->get_arg() );
131 } else {
132 assert( false && "Unexpected expression type being called as a function in call expression" );
133 }
134 }
135 }
136
137 std::string getFunctionName( Expression * expr ) {
138 if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr ) ) {
139 return funcName( appExpr->get_function() );
140 } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * > ( expr ) ) {
141 return funcName( untypedExpr->get_function() );
142 } else {
143 std::cerr << expr << std::endl;
144 assert( false && "Unexpected expression type passed to getFunctionName" );
145 }
146 }
147
148 Type * getPointerBase( Type * type ) {
149 if ( PointerType * ptrType = dynamic_cast< PointerType * >( type ) ) {
150 return ptrType->get_base();
151 } else if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
152 return arrayType->get_base();
153 } else {
154 return NULL;
155 }
156 }
157
158 Type * isPointerType( Type * type ) {
159 if ( getPointerBase( type ) ) return type;
160 else return NULL;
161 }
162
163 class ConstExprChecker : public Visitor {
164 public:
165 ConstExprChecker() : isConstExpr( true ) {}
166
167 virtual void visit( ApplicationExpr *applicationExpr ) { isConstExpr = false; }
168 virtual void visit( UntypedExpr *untypedExpr ) { isConstExpr = false; }
169 virtual void visit( NameExpr *nameExpr ) { isConstExpr = false; }
170 virtual void visit( CastExpr *castExpr ) { isConstExpr = false; }
171 virtual void visit( LabelAddressExpr *labAddressExpr ) { isConstExpr = false; }
172 virtual void visit( UntypedMemberExpr *memberExpr ) { isConstExpr = false; }
173 virtual void visit( MemberExpr *memberExpr ) { isConstExpr = false; }
174 virtual void visit( VariableExpr *variableExpr ) { isConstExpr = false; }
175 virtual void visit( ConstantExpr *constantExpr ) { /* bottom out */ }
176 // these might be okay?
177 // virtual void visit( SizeofExpr *sizeofExpr );
178 // virtual void visit( AlignofExpr *alignofExpr );
179 // virtual void visit( UntypedOffsetofExpr *offsetofExpr );
180 // virtual void visit( OffsetofExpr *offsetofExpr );
181 // virtual void visit( OffsetPackExpr *offsetPackExpr );
182 // virtual void visit( AttrExpr *attrExpr );
183 // virtual void visit( CommaExpr *commaExpr );
184 // virtual void visit( LogicalExpr *logicalExpr );
185 // virtual void visit( ConditionalExpr *conditionalExpr );
186 virtual void visit( TupleExpr *tupleExpr ) { isConstExpr = false; }
187 virtual void visit( SolvedTupleExpr *tupleExpr ) { isConstExpr = false; }
188 virtual void visit( TypeExpr *typeExpr ) { isConstExpr = false; }
189 virtual void visit( AsmExpr *asmExpr ) { isConstExpr = false; }
190 virtual void visit( UntypedValofExpr *valofExpr ) { isConstExpr = false; }
191 virtual void visit( CompoundLiteralExpr *compLitExpr ) { isConstExpr = false; }
192
193 bool isConstExpr;
194 };
195
196 bool isConstExpr( Expression * expr ) {
197 if ( expr ) {
198 ConstExprChecker checker;
199 expr->accept( checker );
200 return checker.isConstExpr;
201 }
202 return true;
203 }
204
205 bool isConstExpr( Initializer * init ) {
206 if ( init ) {
207 ConstExprChecker checker;
208 init->accept( checker );
209 return checker.isConstExpr;
210 } // if
211 // for all intents and purposes, no initializer means const expr
212 return true;
213 }
214
215}
Note: See TracBrowser for help on using the repository browser.