source: src/CodeGen/GenType.cc@ ec28948

ADT arm-eh ast-experimental cleanup-dtors enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox new-ast new-ast-unique-expr pthread-emulation qualifiedEnum
Last change on this file since ec28948 was c198b69, checked in by Rob Schluntz <rschlunt@…>, 7 years ago

Minor cleanup in GenType
  • Property mode set to 100644
File size: 10.8 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// GenType.cc --
8//
9// Author : Richard C. Bilson
10// Created On : Mon May 18 07:44:20 2015
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Fri Mar 17 09:02:28 2017
13// Update Count : 22
14//
15#include "GenType.h"
16
17#include <cassert> // for assert, assertf
18#include <list> // for _List_iterator, _List_const_iterator
19#include <sstream> // for operator<<, ostringstream, basic_os...
20
21#include "CodeGenerator.h" // for CodeGenerator
22#include "SynTree/Declaration.h" // for DeclarationWithType
23#include "SynTree/Expression.h" // for Expression
24#include "SynTree/Type.h" // for PointerType, Type, FunctionType
25#include "SynTree/Visitor.h" // for Visitor
26
27namespace CodeGen {
28 struct GenType : public WithVisitorRef<GenType>, public WithShortCircuiting {
29 std::string typeString;
30 GenType( const std::string &typeString, bool pretty, bool genC, bool lineMarks );
31
32 void previsit( BaseSyntaxNode * );
33 void postvisit( BaseSyntaxNode * );
34
35 void postvisit( FunctionType * funcType );
36 void postvisit( VoidType * voidType );
37 void postvisit( BasicType * basicType );
38 void postvisit( PointerType * pointerType );
39 void postvisit( ArrayType * arrayType );
40 void postvisit( ReferenceType * refType );
41 void postvisit( StructInstType * structInst );
42 void postvisit( UnionInstType * unionInst );
43 void postvisit( EnumInstType * enumInst );
44 void postvisit( TypeInstType * typeInst );
45 void postvisit( TupleType * tupleType );
46 void postvisit( VarArgsType * varArgsType );
47 void postvisit( ZeroType * zeroType );
48 void postvisit( OneType * oneType );
49 void postvisit( GlobalScopeType * globalType );
50 void postvisit( TraitInstType * inst );
51 void postvisit( TypeofType * typeof );
52 void postvisit( QualifiedType * qualType );
53
54 private:
55 void handleQualifiers( Type *type );
56 std::string handleGeneric( ReferenceToType * refType );
57 void genArray( const Type::Qualifiers &qualifiers, Type *base, Expression *dimension, bool isVarLen, bool isStatic );
58
59 bool pretty = false; // pretty print
60 bool genC = false; // generating C code?
61 bool lineMarks = false; // lineMarks on for CodeGenerator?
62 };
63
64 std::string genType( Type *type, const std::string &baseString, bool pretty, bool genC , bool lineMarks ) {
65 PassVisitor<GenType> gt( baseString, pretty, genC, lineMarks );
66 std::ostringstream os;
67
68 if ( ! type->get_attributes().empty() ) {
69 PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
70 cg.pass.genAttributes( type->get_attributes() );
71 } // if
72
73 type->accept( gt );
74 return os.str() + gt.pass.typeString;
75 }
76
77 std::string genPrettyType( Type * type, const std::string & baseString ) {
78 return genType( type, baseString, true, false );
79 }
80
81 GenType::GenType( const std::string &typeString, bool pretty, bool genC, bool lineMarks ) : typeString( typeString ), pretty( pretty ), genC( genC ), lineMarks( lineMarks ) {}
82
83 // *** BaseSyntaxNode
84 void GenType::previsit( BaseSyntaxNode * ) {
85 // turn off automatic recursion for all nodes, to allow each visitor to
86 // precisely control the order in which its children are visited.
87 visit_children = false;
88 }
89
90 void GenType::postvisit( BaseSyntaxNode * node ) {
91 std::stringstream ss;
92 node->print( ss );
93 assertf( false, "Unhandled node reached in GenType: %s", ss.str().c_str() );
94 }
95
96 void GenType::postvisit( VoidType * voidType ) {
97 typeString = "void " + typeString;
98 handleQualifiers( voidType );
99 }
100
101 void GenType::postvisit( BasicType * basicType ) {
102 BasicType::Kind kind = basicType->kind;
103 assert( 0 <= kind && kind < BasicType::NUMBER_OF_BASIC_TYPES );
104 typeString = std::string( BasicType::typeNames[kind] ) + " " + typeString;
105 handleQualifiers( basicType );
106 }
107
108 void GenType::genArray( const Type::Qualifiers & qualifiers, Type * base, Expression *dimension, bool isVarLen, bool isStatic ) {
109 std::ostringstream os;
110 if ( typeString != "" ) {
111 if ( typeString[ 0 ] == '*' ) {
112 os << "(" << typeString << ")";
113 } else {
114 os << typeString;
115 } // if
116 } // if
117 os << "[";
118
119 if ( isStatic ) {
120 os << "static ";
121 } // if
122 if ( qualifiers.is_const ) {
123 os << "const ";
124 } // if
125 if ( qualifiers.is_volatile ) {
126 os << "volatile ";
127 } // if
128 if ( qualifiers.is_restrict ) {
129 os << "__restrict ";
130 } // if
131 if ( qualifiers.is_atomic ) {
132 os << "_Atomic ";
133 } // if
134 if ( dimension != 0 ) {
135 PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
136 dimension->accept( cg );
137 } else if ( isVarLen ) {
138 // no dimension expression on a VLA means it came in with the * token
139 os << "*";
140 } // if
141 os << "]";
142
143 typeString = os.str();
144
145 base->accept( *visitor );
146 }
147
148 void GenType::postvisit( PointerType * pointerType ) {
149 assert( pointerType->base != 0);
150 if ( pointerType->get_isStatic() || pointerType->get_isVarLen() || pointerType->dimension ) {
151 genArray( pointerType->get_qualifiers(), pointerType->base, pointerType->dimension, pointerType->get_isVarLen(), pointerType->get_isStatic() );
152 } else {
153 handleQualifiers( pointerType );
154 if ( typeString[ 0 ] == '?' ) {
155 typeString = "* " + typeString;
156 } else {
157 typeString = "*" + typeString;
158 } // if
159 pointerType->base->accept( *visitor );
160 } // if
161 }
162
163 void GenType::postvisit( ArrayType * arrayType ) {
164 genArray( arrayType->get_qualifiers(), arrayType->base, arrayType->dimension, arrayType->get_isVarLen(), arrayType->get_isStatic() );
165 }
166
167 void GenType::postvisit( ReferenceType * refType ) {
168 assert( refType->base != 0);
169 assertf( ! genC, "Reference types should not reach code generation." );
170 handleQualifiers( refType );
171 typeString = "&" + typeString;
172 refType->base->accept( *visitor );
173 }
174
175 void GenType::postvisit( FunctionType * funcType ) {
176 std::ostringstream os;
177
178 if ( typeString != "" ) {
179 if ( typeString[ 0 ] == '*' ) {
180 os << "(" << typeString << ")";
181 } else {
182 os << typeString;
183 } // if
184 } // if
185
186 /************* parameters ***************/
187
188 const std::list<DeclarationWithType *> &pars = funcType->parameters;
189
190 if ( pars.empty() ) {
191 if ( funcType->get_isVarArgs() ) {
192 os << "()";
193 } else {
194 os << "(void)";
195 } // if
196 } else {
197 PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
198 os << "(" ;
199
200 cg.pass.genCommaList( pars.begin(), pars.end() );
201
202 if ( funcType->get_isVarArgs() ) {
203 os << ", ...";
204 } // if
205 os << ")";
206 } // if
207
208 typeString = os.str();
209
210 if ( funcType->returnVals.size() == 0 ) {
211 typeString = "void " + typeString;
212 } else {
213 funcType->returnVals.front()->get_type()->accept( *visitor );
214 } // if
215
216 // add forall
217 if( ! funcType->forall.empty() && ! genC ) {
218 // assertf( ! genC, "Aggregate type parameters should not reach code generation." );
219 std::ostringstream os;
220 PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
221 os << "forall(";
222 cg.pass.genCommaList( funcType->forall.begin(), funcType->forall.end() );
223 os << ")" << std::endl;
224 typeString = os.str() + typeString;
225 }
226 }
227
228 std::string GenType::handleGeneric( ReferenceToType * refType ) {
229 if ( ! refType->parameters.empty() ) {
230 std::ostringstream os;
231 PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
232 os << "(";
233 cg.pass.genCommaList( refType->parameters.begin(), refType->parameters.end() );
234 os << ") ";
235 return os.str();
236 }
237 return "";
238 }
239
240 void GenType::postvisit( StructInstType * structInst ) {
241 typeString = structInst->name + handleGeneric( structInst ) + " " + typeString;
242 if ( genC ) typeString = "struct " + typeString;
243 handleQualifiers( structInst );
244 }
245
246 void GenType::postvisit( UnionInstType * unionInst ) {
247 typeString = unionInst->name + handleGeneric( unionInst ) + " " + typeString;
248 if ( genC ) typeString = "union " + typeString;
249 handleQualifiers( unionInst );
250 }
251
252 void GenType::postvisit( EnumInstType * enumInst ) {
253 typeString = enumInst->name + " " + typeString;
254 if ( genC ) typeString = "enum " + typeString;
255 handleQualifiers( enumInst );
256 }
257
258 void GenType::postvisit( TypeInstType * typeInst ) {
259 typeString = typeInst->name + " " + typeString;
260 handleQualifiers( typeInst );
261 }
262
263 void GenType::postvisit( TupleType * tupleType ) {
264 assertf( ! genC, "Tuple types should not reach code generation." );
265 unsigned int i = 0;
266 std::ostringstream os;
267 os << "[";
268 for ( Type * t : *tupleType ) {
269 i++;
270 os << genType( t, "", pretty, genC, lineMarks ) << (i == tupleType->size() ? "" : ", ");
271 }
272 os << "] ";
273 typeString = os.str() + typeString;
274 }
275
276 void GenType::postvisit( VarArgsType * varArgsType ) {
277 typeString = "__builtin_va_list " + typeString;
278 handleQualifiers( varArgsType );
279 }
280
281 void GenType::postvisit( ZeroType * zeroType ) {
282 // ideally these wouldn't hit codegen at all, but should be safe to make them ints
283 typeString = (pretty ? "zero_t " : "long int ") + typeString;
284 handleQualifiers( zeroType );
285 }
286
287 void GenType::postvisit( OneType * oneType ) {
288 // ideally these wouldn't hit codegen at all, but should be safe to make them ints
289 typeString = (pretty ? "one_t " : "long int ") + typeString;
290 handleQualifiers( oneType );
291 }
292
293 void GenType::postvisit( GlobalScopeType * globalType ) {
294 assertf( ! genC, "Global scope type should not reach code generation." );
295 handleQualifiers( globalType );
296 }
297
298 void GenType::postvisit( TraitInstType * inst ) {
299 assertf( ! genC, "Trait types should not reach code generation." );
300 typeString = inst->name + " " + typeString;
301 handleQualifiers( inst );
302 }
303
304 void GenType::postvisit( TypeofType * typeof ) {
305 std::ostringstream os;
306 PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
307 os << "typeof(";
308 typeof->expr->accept( cg );
309 os << ") " << typeString;
310 typeString = os.str();
311 handleQualifiers( typeof );
312 }
313
314 void GenType::postvisit( QualifiedType * qualType ) {
315 assertf( ! genC, "Qualified types should not reach code generation." );
316 std::ostringstream os;
317 os << genType( qualType->parent, "", pretty, genC, lineMarks ) << "." << genType( qualType->child, "", pretty, genC, lineMarks ) << typeString;
318 typeString = os.str();
319 handleQualifiers( qualType );
320 }
321
322 void GenType::handleQualifiers( Type * type ) {
323 if ( type->get_const() ) {
324 typeString = "const " + typeString;
325 } // if
326 if ( type->get_volatile() ) {
327 typeString = "volatile " + typeString;
328 } // if
329 if ( type->get_restrict() ) {
330 typeString = "__restrict " + typeString;
331 } // if
332 if ( type->get_atomic() ) {
333 typeString = "_Atomic " + typeString;
334 } // if
335 if ( type->get_lvalue() && ! genC ) {
336 // when not generating C code, print lvalue for debugging.
337 typeString = "lvalue " + typeString;
338 }
339 }
340} // namespace CodeGen
341
342// Local Variables: //
343// tab-width: 4 //
344// mode: c++ //
345// compile-command: "make install" //
346// End: //
Note: See TracBrowser for help on using the repository browser.