source: src/CodeGen/GenType.cc@ c649d2c

Last change on this file since c649d2c was 8941b6b, checked in by Andrew Beach <ajbeach@…>, 2 years ago

Direct translation of code generation.
  • Property mode set to 100644
File size: 20.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 : Andrew Beach
12// Last Modified On : Fri May 20 11:18:00 2022
13// Update Count : 24
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 "AST/Print.hpp" // for print
22#include "AST/Vector.hpp" // for vector
23#include "CodeGenerator.h" // for CodeGenerator
24#include "CodeGeneratorNew.hpp" // for CodeGenerator_new
25#include "SynTree/Declaration.h" // for DeclarationWithType
26#include "SynTree/Expression.h" // for Expression
27#include "SynTree/Type.h" // for PointerType, Type, FunctionType
28#include "SynTree/Visitor.h" // for Visitor
29
30namespace CodeGen {
31 struct GenType : public WithVisitorRef<GenType>, public WithShortCircuiting {
32 std::string typeString;
33 GenType( const std::string &typeString, const Options &options );
34
35 void previsit( BaseSyntaxNode * );
36 void postvisit( BaseSyntaxNode * );
37
38 void postvisit( FunctionType * funcType );
39 void postvisit( VoidType * voidType );
40 void postvisit( BasicType * basicType );
41 void postvisit( PointerType * pointerType );
42 void postvisit( ArrayType * arrayType );
43 void postvisit( ReferenceType * refType );
44 void postvisit( StructInstType * structInst );
45 void postvisit( UnionInstType * unionInst );
46 void postvisit( EnumInstType * enumInst );
47 void postvisit( TypeInstType * typeInst );
48 void postvisit( TupleType * tupleType );
49 void postvisit( VarArgsType * varArgsType );
50 void postvisit( ZeroType * zeroType );
51 void postvisit( OneType * oneType );
52 void postvisit( GlobalScopeType * globalType );
53 void postvisit( TraitInstType * inst );
54 void postvisit( TypeofType * typeof );
55 void postvisit( VTableType * vtable );
56 void postvisit( QualifiedType * qualType );
57
58 private:
59 void handleQualifiers( Type *type );
60 std::string handleGeneric( ReferenceToType * refType );
61 void genArray( const Type::Qualifiers &qualifiers, Type *base, Expression *dimension, bool isVarLen, bool isStatic );
62
63 Options options;
64 };
65
66 std::string genType( Type *type, const std::string &baseString, const Options &options ) {
67 PassVisitor<GenType> gt( baseString, options );
68 std::ostringstream os;
69
70 if ( ! type->get_attributes().empty() ) {
71 PassVisitor<CodeGenerator> cg( os, options );
72 cg.pass.genAttributes( type->get_attributes() );
73 } // if
74
75 type->accept( gt );
76 return os.str() + gt.pass.typeString;
77 }
78
79 std::string genType( Type *type, const std::string &baseString, bool pretty, bool genC , bool lineMarks ) {
80 return genType( type, baseString, Options(pretty, genC, lineMarks, false ) );
81 }
82
83 std::string genPrettyType( Type * type, const std::string & baseString ) {
84 return genType( type, baseString, true, false );
85 }
86
87 GenType::GenType( const std::string &typeString, const Options &options ) : typeString( typeString ), options( options ) {}
88
89 // *** BaseSyntaxNode
90 void GenType::previsit( BaseSyntaxNode * ) {
91 // turn off automatic recursion for all nodes, to allow each visitor to
92 // precisely control the order in which its children are visited.
93 visit_children = false;
94 }
95
96 void GenType::postvisit( BaseSyntaxNode * node ) {
97 std::stringstream ss;
98 node->print( ss );
99 assertf( false, "Unhandled node reached in GenType: %s", ss.str().c_str() );
100 }
101
102 void GenType::postvisit( VoidType * voidType ) {
103 typeString = "void " + typeString;
104 handleQualifiers( voidType );
105 }
106
107 void GenType::postvisit( BasicType * basicType ) {
108 BasicType::Kind kind = basicType->kind;
109 assert( 0 <= kind && kind < BasicType::NUMBER_OF_BASIC_TYPES );
110 typeString = std::string( BasicType::typeNames[kind] ) + " " + typeString;
111 handleQualifiers( basicType );
112 }
113
114 void GenType::genArray( const Type::Qualifiers & qualifiers, Type * base, Expression *dimension, bool isVarLen, bool isStatic ) {
115 std::ostringstream os;
116 if ( typeString != "" ) {
117 if ( typeString[ 0 ] == '*' ) {
118 os << "(" << typeString << ")";
119 } else {
120 os << typeString;
121 } // if
122 } // if
123 os << "[";
124
125 if ( isStatic ) {
126 os << "static ";
127 } // if
128 if ( qualifiers.is_const ) {
129 os << "const ";
130 } // if
131 if ( qualifiers.is_volatile ) {
132 os << "volatile ";
133 } // if
134 if ( qualifiers.is_restrict ) {
135 os << "__restrict ";
136 } // if
137 if ( qualifiers.is_atomic ) {
138 os << "_Atomic ";
139 } // if
140 if ( dimension != 0 ) {
141 PassVisitor<CodeGenerator> cg( os, options );
142 dimension->accept( cg );
143 } else if ( isVarLen ) {
144 // no dimension expression on a VLA means it came in with the * token
145 os << "*";
146 } // if
147 os << "]";
148
149 typeString = os.str();
150
151 base->accept( *visitor );
152 }
153
154 void GenType::postvisit( PointerType * pointerType ) {
155 assert( pointerType->base != 0);
156 if ( pointerType->get_isStatic() || pointerType->get_isVarLen() || pointerType->dimension ) {
157 genArray( pointerType->get_qualifiers(), pointerType->base, pointerType->dimension, pointerType->get_isVarLen(), pointerType->get_isStatic() );
158 } else {
159 handleQualifiers( pointerType );
160 if ( typeString[ 0 ] == '?' ) {
161 typeString = "* " + typeString;
162 } else {
163 typeString = "*" + typeString;
164 } // if
165 pointerType->base->accept( *visitor );
166 } // if
167 }
168
169 void GenType::postvisit( ArrayType * arrayType ) {
170 genArray( arrayType->get_qualifiers(), arrayType->base, arrayType->dimension, arrayType->get_isVarLen(), arrayType->get_isStatic() );
171 }
172
173 void GenType::postvisit( ReferenceType * refType ) {
174 assert( 0 != refType->base );
175 assertf( ! options.genC, "Reference types should not reach code generation." );
176 handleQualifiers( refType );
177 typeString = "&" + typeString;
178 refType->base->accept( *visitor );
179 }
180
181 void GenType::postvisit( FunctionType * funcType ) {
182 std::ostringstream os;
183
184 if ( typeString != "" ) {
185 if ( typeString[ 0 ] == '*' ) {
186 os << "(" << typeString << ")";
187 } else {
188 os << typeString;
189 } // if
190 } // if
191
192 /************* parameters ***************/
193
194 const std::list<DeclarationWithType *> &pars = funcType->parameters;
195
196 if ( pars.empty() ) {
197 if ( funcType->get_isVarArgs() ) {
198 os << "()";
199 } else {
200 os << "(void)";
201 } // if
202 } else {
203 PassVisitor<CodeGenerator> cg( os, options );
204 os << "(" ;
205
206 cg.pass.genCommaList( pars.begin(), pars.end() );
207
208 if ( funcType->get_isVarArgs() ) {
209 os << ", ...";
210 } // if
211 os << ")";
212 } // if
213
214 typeString = os.str();
215
216 if ( funcType->returnVals.size() == 0 ) {
217 typeString = "void " + typeString;
218 } else {
219 funcType->returnVals.front()->get_type()->accept( *visitor );
220 } // if
221
222 // add forall
223 if( ! funcType->forall.empty() && ! options.genC ) {
224 // assertf( ! genC, "Aggregate type parameters should not reach code generation." );
225 std::ostringstream os;
226 PassVisitor<CodeGenerator> cg( os, options );
227 os << "forall(";
228 cg.pass.genCommaList( funcType->forall.begin(), funcType->forall.end() );
229 os << ")" << std::endl;
230 typeString = os.str() + typeString;
231 }
232 }
233
234 std::string GenType::handleGeneric( ReferenceToType * refType ) {
235 if ( ! refType->parameters.empty() ) {
236 std::ostringstream os;
237 PassVisitor<CodeGenerator> cg( os, options );
238 os << "(";
239 cg.pass.genCommaList( refType->parameters.begin(), refType->parameters.end() );
240 os << ") ";
241 return os.str();
242 }
243 return "";
244 }
245
246 void GenType::postvisit( StructInstType * structInst ) {
247 typeString = structInst->name + handleGeneric( structInst ) + " " + typeString;
248 if ( options.genC ) typeString = "struct " + typeString;
249 handleQualifiers( structInst );
250 }
251
252 void GenType::postvisit( UnionInstType * unionInst ) {
253 typeString = unionInst->name + handleGeneric( unionInst ) + " " + typeString;
254 if ( options.genC ) typeString = "union " + typeString;
255 handleQualifiers( unionInst );
256 }
257
258 void GenType::postvisit( EnumInstType * enumInst ) {
259 if ( enumInst->baseEnum && enumInst->baseEnum->base ) {
260 typeString = genType(enumInst->baseEnum->base, typeString, options);
261 } else {
262 typeString = enumInst->name + " " + typeString;
263 if ( options.genC ) {
264 typeString = "enum " + typeString;
265 }
266 }
267 handleQualifiers( enumInst );
268 }
269
270 void GenType::postvisit( TypeInstType * typeInst ) {
271 assertf( ! options.genC, "Type instance types should not reach code generation." );
272 typeString = typeInst->name + " " + typeString;
273 handleQualifiers( typeInst );
274 }
275
276 void GenType::postvisit( TupleType * tupleType ) {
277 assertf( ! options.genC, "Tuple types should not reach code generation." );
278 unsigned int i = 0;
279 std::ostringstream os;
280 os << "[";
281 for ( Type * t : *tupleType ) {
282 i++;
283 os << genType( t, "", options ) << (i == tupleType->size() ? "" : ", ");
284 }
285 os << "] ";
286 typeString = os.str() + typeString;
287 }
288
289 void GenType::postvisit( VarArgsType * varArgsType ) {
290 typeString = "__builtin_va_list " + typeString;
291 handleQualifiers( varArgsType );
292 }
293
294 void GenType::postvisit( ZeroType * zeroType ) {
295 // ideally these wouldn't hit codegen at all, but should be safe to make them ints
296 typeString = (options.pretty ? "zero_t " : "long int ") + typeString;
297 handleQualifiers( zeroType );
298 }
299
300 void GenType::postvisit( OneType * oneType ) {
301 // ideally these wouldn't hit codegen at all, but should be safe to make them ints
302 typeString = (options.pretty ? "one_t " : "long int ") + typeString;
303 handleQualifiers( oneType );
304 }
305
306 void GenType::postvisit( GlobalScopeType * globalType ) {
307 assertf( ! options.genC, "Global scope type should not reach code generation." );
308 handleQualifiers( globalType );
309 }
310
311 void GenType::postvisit( TraitInstType * inst ) {
312 assertf( ! options.genC, "Trait types should not reach code generation." );
313 typeString = inst->name + " " + typeString;
314 handleQualifiers( inst );
315 }
316
317 void GenType::postvisit( TypeofType * typeof ) {
318 std::ostringstream os;
319 PassVisitor<CodeGenerator> cg( os, options );
320 os << "typeof(";
321 typeof->expr->accept( cg );
322 os << ") " << typeString;
323 typeString = os.str();
324 handleQualifiers( typeof );
325 }
326
327 void GenType::postvisit( VTableType * vtable ) {
328 assertf( ! options.genC, "Virtual table types should not reach code generation." );
329 std::ostringstream os;
330 os << "vtable(" << genType( vtable->base, "", options ) << ") " << typeString;
331 typeString = os.str();
332 handleQualifiers( vtable );
333 }
334
335 void GenType::postvisit( QualifiedType * qualType ) {
336 assertf( ! options.genC, "Qualified types should not reach code generation." );
337 std::ostringstream os;
338 os << genType( qualType->parent, "", options ) << "." << genType( qualType->child, "", options ) << typeString;
339 typeString = os.str();
340 handleQualifiers( qualType );
341 }
342
343 void GenType::handleQualifiers( Type * type ) {
344 if ( type->get_const() ) {
345 typeString = "const " + typeString;
346 } // if
347 if ( type->get_volatile() ) {
348 typeString = "volatile " + typeString;
349 } // if
350 if ( type->get_restrict() ) {
351 typeString = "__restrict " + typeString;
352 } // if
353 if ( type->get_atomic() ) {
354 typeString = "_Atomic " + typeString;
355 } // if
356 }
357
358namespace {
359
360#warning Remove the _new when old version is removed.
361struct GenType_new :
362 public ast::WithShortCircuiting,
363 public ast::WithVisitorRef<GenType_new> {
364 std::string result;
365 GenType_new( const std::string &typeString, const Options &options );
366
367 void previsit( ast::Node const * );
368 void postvisit( ast::Node const * );
369
370 void postvisit( ast::FunctionType const * type );
371 void postvisit( ast::VoidType const * type );
372 void postvisit( ast::BasicType const * type );
373 void postvisit( ast::PointerType const * type );
374 void postvisit( ast::ArrayType const * type );
375 void postvisit( ast::ReferenceType const * type );
376 void postvisit( ast::StructInstType const * type );
377 void postvisit( ast::UnionInstType const * type );
378 void postvisit( ast::EnumInstType const * type );
379 void postvisit( ast::TypeInstType const * type );
380 void postvisit( ast::TupleType const * type );
381 void postvisit( ast::VarArgsType const * type );
382 void postvisit( ast::ZeroType const * type );
383 void postvisit( ast::OneType const * type );
384 void postvisit( ast::GlobalScopeType const * type );
385 void postvisit( ast::TraitInstType const * type );
386 void postvisit( ast::TypeofType const * type );
387 void postvisit( ast::VTableType const * type );
388 void postvisit( ast::QualifiedType const * type );
389
390private:
391 void handleQualifiers( ast::Type const *type );
392 std::string handleGeneric( ast::BaseInstType const * type );
393 void genArray( const ast::CV::Qualifiers &qualifiers, ast::Type const *base, ast::Expr const *dimension, bool isVarLen, bool isStatic );
394 std::string genParamList( const ast::vector<ast::Type> & );
395
396 Options options;
397};
398
399GenType_new::GenType_new( const std::string &typeString, const Options &options ) : result( typeString ), options( options ) {}
400
401void GenType_new::previsit( ast::Node const * ) {
402 // Turn off automatic recursion for all nodes, to allow each visitor to
403 // precisely control the order in which its children are visited.
404 visit_children = false;
405}
406
407void GenType_new::postvisit( ast::Node const * node ) {
408 std::stringstream ss;
409 ast::print( ss, node );
410 assertf( false, "Unhandled node reached in GenType: %s", ss.str().c_str() );
411}
412
413void GenType_new::postvisit( ast::VoidType const * type ) {
414 result = "void " + result;
415 handleQualifiers( type );
416}
417
418void GenType_new::postvisit( ast::BasicType const * type ) {
419 ast::BasicType::Kind kind = type->kind;
420 assert( 0 <= kind && kind < ast::BasicType::NUMBER_OF_BASIC_TYPES );
421 result = std::string( ast::BasicType::typeNames[kind] ) + " " + result;
422 handleQualifiers( type );
423}
424
425void GenType_new::genArray( const ast::CV::Qualifiers & qualifiers, ast::Type const * base, ast::Expr const *dimension, bool isVarLen, bool isStatic ) {
426 std::ostringstream os;
427 if ( result != "" ) {
428 if ( result[ 0 ] == '*' ) {
429 os << "(" << result << ")";
430 } else {
431 os << result;
432 }
433 }
434 os << "[";
435 if ( isStatic ) {
436 os << "static ";
437 }
438 if ( qualifiers.is_const ) {
439 os << "const ";
440 }
441 if ( qualifiers.is_volatile ) {
442 os << "volatile ";
443 }
444 if ( qualifiers.is_restrict ) {
445 os << "__restrict ";
446 }
447 if ( qualifiers.is_atomic ) {
448 os << "_Atomic ";
449 }
450 if ( dimension != 0 ) {
451 ast::Pass<CodeGenerator_new>::read( dimension, os, options );
452 } else if ( isVarLen ) {
453 // no dimension expression on a VLA means it came in with the * token
454 os << "*";
455 }
456 os << "]";
457
458 result = os.str();
459
460 base->accept( *visitor );
461}
462
463void GenType_new::postvisit( ast::PointerType const * type ) {
464 if ( type->isStatic || type->isVarLen || type->dimension ) {
465 genArray( type->qualifiers, type->base, type->dimension, type->isVarLen, type->isStatic );
466 } else {
467 handleQualifiers( type );
468 if ( result[ 0 ] == '?' ) {
469 result = "* " + result;
470 } else {
471 result = "*" + result;
472 }
473 type->base->accept( *visitor );
474 }
475}
476
477void GenType_new::postvisit( ast::ArrayType const * type ) {
478 genArray( type->qualifiers, type->base, type->dimension, type->isVarLen, type->isStatic );
479}
480
481void GenType_new::postvisit( ast::ReferenceType const * type ) {
482 assertf( !options.genC, "Reference types should not reach code generation." );
483 handleQualifiers( type );
484 result = "&" + result;
485 type->base->accept( *visitor );
486}
487
488void GenType_new::postvisit( ast::FunctionType const * type ) {
489 std::ostringstream os;
490
491 if ( result != "" ) {
492 if ( result[ 0 ] == '*' ) {
493 os << "(" << result << ")";
494 } else {
495 os << result;
496 }
497 }
498
499 if ( type->params.empty() ) {
500 if ( type->isVarArgs ) {
501 os << "()";
502 } else {
503 os << "(void)";
504 }
505 } else {
506 os << "(" ;
507
508 os << genParamList( type->params );
509
510 if ( type->isVarArgs ) {
511 os << ", ...";
512 }
513 os << ")";
514 }
515
516 result = os.str();
517
518 if ( type->returns.size() == 0 ) {
519 result = "void " + result;
520 } else {
521 type->returns.front()->accept( *visitor );
522 }
523
524 // Add forall clause.
525 if( !type->forall.empty() && !options.genC ) {
526 //assertf( !options.genC, "FunctionDecl type parameters should not reach code generation." );
527 std::ostringstream os;
528 ast::Pass<CodeGenerator_new> cg( os, options );
529 os << "forall(";
530 cg.core.genCommaList( type->forall );
531 os << ")" << std::endl;
532 result = os.str() + result;
533 }
534}
535
536std::string GenType_new::handleGeneric( ast::BaseInstType const * type ) {
537 if ( !type->params.empty() ) {
538 std::ostringstream os;
539 ast::Pass<CodeGenerator_new> cg( os, options );
540 os << "(";
541 cg.core.genCommaList( type->params );
542 os << ") ";
543 return os.str();
544 }
545 return "";
546}
547
548void GenType_new::postvisit( ast::StructInstType const * type ) {
549 result = type->name + handleGeneric( type ) + " " + result;
550 if ( options.genC ) result = "struct " + result;
551 handleQualifiers( type );
552}
553
554void GenType_new::postvisit( ast::UnionInstType const * type ) {
555 result = type->name + handleGeneric( type ) + " " + result;
556 if ( options.genC ) result = "union " + result;
557 handleQualifiers( type );
558}
559
560void GenType_new::postvisit( ast::EnumInstType const * type ) {
561 if ( type->base && type->base->base ) {
562 result = genType( type->base->base, result, options );
563 } else {
564 result = type->name + " " + result;
565 if ( options.genC ) {
566 result = "enum " + result;
567 }
568 }
569 handleQualifiers( type );
570}
571
572void GenType_new::postvisit( ast::TypeInstType const * type ) {
573 assertf( !options.genC, "TypeInstType should not reach code generation." );
574 result = type->name + " " + result;
575 handleQualifiers( type );
576}
577
578void GenType_new::postvisit( ast::TupleType const * type ) {
579 assertf( !options.genC, "TupleType should not reach code generation." );
580 unsigned int i = 0;
581 std::ostringstream os;
582 os << "[";
583 for ( ast::ptr<ast::Type> const & t : type->types ) {
584 i++;
585 os << genType( t, "", options ) << (i == type->size() ? "" : ", ");
586 }
587 os << "] ";
588 result = os.str() + result;
589}
590
591void GenType_new::postvisit( ast::VarArgsType const * type ) {
592 result = "__builtin_va_list " + result;
593 handleQualifiers( type );
594}
595
596void GenType_new::postvisit( ast::ZeroType const * type ) {
597 // Ideally these wouldn't hit codegen at all, but should be safe to make them ints.
598 result = (options.pretty ? "zero_t " : "long int ") + result;
599 handleQualifiers( type );
600}
601
602void GenType_new::postvisit( ast::OneType const * type ) {
603 // Ideally these wouldn't hit codegen at all, but should be safe to make them ints.
604 result = (options.pretty ? "one_t " : "long int ") + result;
605 handleQualifiers( type );
606}
607
608void GenType_new::postvisit( ast::GlobalScopeType const * type ) {
609 assertf( !options.genC, "GlobalScopeType should not reach code generation." );
610 handleQualifiers( type );
611}
612
613void GenType_new::postvisit( ast::TraitInstType const * type ) {
614 assertf( !options.genC, "TraitInstType should not reach code generation." );
615 result = type->name + " " + result;
616 handleQualifiers( type );
617}
618
619void GenType_new::postvisit( ast::TypeofType const * type ) {
620 std::ostringstream os;
621 os << "typeof(";
622 ast::Pass<CodeGenerator_new>::read( type, os, options );
623 os << ") " << result;
624 result = os.str();
625 handleQualifiers( type );
626}
627
628void GenType_new::postvisit( ast::VTableType const * type ) {
629 assertf( !options.genC, "Virtual table types should not reach code generation." );
630 std::ostringstream os;
631 os << "vtable(" << genType( type->base, "", options ) << ") " << result;
632 result = os.str();
633 handleQualifiers( type );
634}
635
636void GenType_new::postvisit( ast::QualifiedType const * type ) {
637 assertf( !options.genC, "QualifiedType should not reach code generation." );
638 std::ostringstream os;
639 os << genType( type->parent, "", options ) << "." << genType( type->child, "", options ) << result;
640 result = os.str();
641 handleQualifiers( type );
642}
643
644void GenType_new::handleQualifiers( ast::Type const * type ) {
645 if ( type->is_const() ) {
646 result = "const " + result;
647 }
648 if ( type->is_volatile() ) {
649 result = "volatile " + result;
650 }
651 if ( type->is_restrict() ) {
652 result = "__restrict " + result;
653 }
654 if ( type->is_atomic() ) {
655 result = "_Atomic " + result;
656 }
657}
658
659std::string GenType_new::genParamList( const ast::vector<ast::Type> & range ) {
660 auto cur = range.begin();
661 auto end = range.end();
662 if ( cur == end ) return "";
663 std::ostringstream oss;
664 for ( unsigned int i = 0 ; ; ++i ) {
665 oss << genType( *cur++, "__param_" + std::to_string(i), options );
666 if ( cur == end ) break;
667 oss << ", ";
668 }
669 return oss.str();
670}
671
672} // namespace
673
674std::string genType( ast::Type const * type, const std::string & base, const Options & options ) {
675 std::ostringstream os;
676 if ( !type->attributes.empty() ) {
677 ast::Pass<CodeGenerator_new> cg( os, options );
678 cg.core.genAttributes( type->attributes );
679 }
680
681 return os.str() + ast::Pass<GenType_new>::read( type, base, options );
682}
683
684std::string genTypeNoAttr( ast::Type const * type, const std::string & base, const Options & options ) {
685 return ast::Pass<GenType_new>::read( type, base, options );
686}
687
688} // namespace CodeGen
689
690// Local Variables: //
691// tab-width: 4 //
692// mode: c++ //
693// compile-command: "make install" //
694// End: //
Note: See TracBrowser for help on using the repository browser.