Context Navigation

source: src/CodeGen/CodeGenerator.cc @ ac911f4

ADTaaron-thesisarm-ehast-experimentalcleanup-dtorsctordeferred_resndemanglerenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxmemorynew-astnew-ast-unique-exprnew-envno_listpersistent-indexerpthread-emulationqualifiedEnumresolv-newwith_gc

Last change on this file since ac911f4 was ac911f4, checked in by Peter A. Buhr <pabuhr@…>, 8 years ago
case range, second attempt
Property mode set to `100644`
File size: 25.0 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	// CodeGenerator.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 : Sat Jul 30 11:27:07 2016
13	// Update Count : 340
14	//
15
16	#include <algorithm>
17	#include <iostream>
18	#include <cassert>
19	#include <list>
20
21	#include "Parser/ParseNode.h"
22
23	#include "SynTree/Declaration.h"
24	#include "SynTree/Expression.h"
25	#include "SynTree/Initializer.h"
26	#include "SynTree/Statement.h"
27	#include "SynTree/Type.h"
28	#include "SynTree/Attribute.h"
29
30	#include "Common/utility.h"
31	#include "Common/UnimplementedError.h"
32
33	#include "CodeGenerator.h"
34	#include "OperatorTable.h"
35	#include "GenType.h"
36
37	#include "InitTweak/InitTweak.h"
38
39	using namespace std;
40
41	namespace CodeGen {
42	int CodeGenerator::tabsize = 4;
43
44	// the kinds of statements that would ideally be followed by whitespace
45	bool wantSpacing( Statement * stmt) {
46	return dynamic_cast< IfStmt * >( stmt ) \|\| dynamic_cast< CompoundStmt * >( stmt ) \|\|
47	dynamic_cast< WhileStmt * >( stmt ) \|\| dynamic_cast< ForStmt * > ( stmt ) \|\| dynamic_cast< SwitchStmt *>( stmt );
48	}
49
50	void CodeGenerator::extension( Expression *expr ) {
51	if ( expr->get_extension() ) {
52	output << "__extension__ ";
53	} // if
54	} // extension
55
56	void CodeGenerator::extension( Declaration *decl ) {
57	if ( decl->get_extension() ) {
58	output << "__extension__ ";
59	} // if
60	} // extension
61
62	ostream & CodeGenerator::Indenter::operator()( ostream & output ) const {
63	return output << string( cg.cur_indent, ' ' );
64	}
65
66	ostream & operator<<( ostream & output, const CodeGenerator::Indenter &indent ) {
67	return indent( output );
68	}
69
70	CodeGenerator::LabelPrinter & CodeGenerator::LabelPrinter::operator()( std::list< Label > & l ) {
71	labels = &l;
72	return *this;
73	}
74
75	ostream & operator<<( ostream & output, CodeGenerator::LabelPrinter &printLabels ) {
76	std::list< Label > & labs = *printLabels.labels;
77	// l.unique(); // assumes a sorted list. Why not use set? Does order matter?
78	for ( Label & l : labs ) {
79	output << l.get_name() + ": ";
80	printLabels.cg.genAttributes( l.get_attributes() );
81	}
82	return output;
83	}
84
85	CodeGenerator::CodeGenerator( std::ostream &os ) : indent( this), cur_indent( 0 ), insideFunction( false ), output( os ), printLabels( this ) { }
86
87	CodeGenerator::CodeGenerator( std::ostream &os, std::string init, int indentation, bool infunp )
88	: indent( this), cur_indent( indentation ), insideFunction( infunp ), output( os ), printLabels( this ) {
89	//output << std::string( init );
90	}
91
92	CodeGenerator::CodeGenerator( std::ostream &os, char *init, int indentation, bool infunp )
93	: indent( this ), cur_indent( indentation ), insideFunction( infunp ), output( os ), printLabels( this ) {
94	//output << std::string( init );
95	}
96
97	string mangleName( DeclarationWithType *decl ) {
98	if ( decl->get_mangleName() != "" ) {
99	// need to incorporate scope level in order to differentiate names for destructors
100	return decl->get_scopedMangleName();
101	} else {
102	return decl->get_name();
103	} // if
104	}
105
106	void CodeGenerator::genAttributes( std::list< Attribute * > & attributes ) {
107	if ( ! attributes.empty() ) {
108	output << "__attribute__ ((";
109	for ( Attribute *& attr : attributes ) {
110	if ( ! attr->empty() ) {
111	output << attr->get_name() << "(";
112	genCommaList( attr->get_parameters().begin(), attr->get_parameters().end() );
113	output << ")";
114	}
115	output << ",";
116	}
117	output << ")) ";
118	}
119	}
120
121
122	//*** Declarations
123	void CodeGenerator::visit( FunctionDecl *functionDecl ) {
124	extension( functionDecl );
125	genAttributes( functionDecl->get_attributes() );
126
127	handleStorageClass( functionDecl );
128	if ( functionDecl->get_isInline() ) {
129	output << "inline ";
130	} // if
131	if ( functionDecl->get_isNoreturn() ) {
132	output << "_Noreturn ";
133	} // if
134	output << genType( functionDecl->get_functionType(), mangleName( functionDecl ) );
135
136	// how to get this to the Functype?
137	std::list< Declaration * > olds = functionDecl->get_oldDecls();
138	if ( ! olds.empty() ) {
139	output << " /* function has old declaration */";
140	} // if
141
142	// acceptAll( functionDecl->get_oldDecls(), *this );
143	if ( functionDecl->get_statements() ) {
144	functionDecl->get_statements()->accept( *this );
145	} // if
146	}
147
148	void CodeGenerator::visit( ObjectDecl *objectDecl ) {
149	extension( objectDecl );
150	handleStorageClass( objectDecl );
151	output << genType( objectDecl->get_type(), mangleName( objectDecl ) );
152
153	if ( objectDecl->get_init() ) {
154	output << " = ";
155	objectDecl->get_init()->accept( *this );
156	} // if
157	if ( objectDecl->get_bitfieldWidth() ) {
158	output << ":";
159	objectDecl->get_bitfieldWidth()->accept( *this );
160	} // if
161	}
162
163	void CodeGenerator::handleAggregate( AggregateDecl *aggDecl ) {
164	if ( aggDecl->get_name() != "" )
165	output << aggDecl->get_name();
166
167	std::list< Declaration * > &memb = aggDecl->get_members();
168	if ( ! memb.empty() ) {
169	// if ( aggDecl->has_body() ) {
170	// std::list< Declaration * > &memb = aggDecl->get_members();
171	output << " {" << endl;
172
173	cur_indent += CodeGenerator::tabsize;
174	for ( std::list< Declaration* >::iterator i = memb.begin(); i != memb.end(); i++) {
175	output << indent;
176	(i)->accept( this );
177	output << ";" << endl;
178	}
179
180	cur_indent -= CodeGenerator::tabsize;
181
182	output << indent << "}";
183	} // if
184	}
185
186	void CodeGenerator::visit( StructDecl *structDecl ) {
187	extension( structDecl );
188	output << "struct ";
189	handleAggregate( structDecl );
190	}
191
192	void CodeGenerator::visit( UnionDecl *unionDecl ) {
193	extension( unionDecl );
194	output << "union ";
195	handleAggregate( unionDecl );
196	}
197
198	void CodeGenerator::visit( EnumDecl *enumDecl ) {
199	extension( enumDecl );
200	output << "enum ";
201
202	if ( enumDecl->get_name() != "" )
203	output << enumDecl->get_name();
204
205	std::list< Declaration* > &memb = enumDecl->get_members();
206
207	if ( ! memb.empty() ) {
208	output << " {" << endl;
209
210	cur_indent += CodeGenerator::tabsize;
211	for ( std::list< Declaration* >::iterator i = memb.begin(); i != memb.end(); i++) {
212	ObjectDecl obj = dynamic_cast< ObjectDecl >( *i );
213	assert( obj );
214	output << indent << mangleName( obj );
215	if ( obj->get_init() ) {
216	output << " = ";
217	obj->get_init()->accept( *this );
218	} // if
219	output << "," << endl;
220	} // for
221
222	cur_indent -= CodeGenerator::tabsize;
223
224	output << indent << "}";
225	} // if
226	}
227
228	void CodeGenerator::visit( TraitDecl *traitDecl ) {}
229
230	void CodeGenerator::visit( TypedefDecl *typeDecl ) {
231	assert( false && "Typedefs are removed and substituted in earlier passes." );
232	//output << "typedef ";
233	//output << genType( typeDecl->get_base(), typeDecl->get_name() );
234	}
235
236	void CodeGenerator::visit( TypeDecl *typeDecl ) {
237	// really, we should mutate this into something that isn't a TypeDecl but that requires large-scale changes,
238	// still to be done
239	extension( typeDecl );
240	output << "extern unsigned long " << typeDecl->get_name();
241	if ( typeDecl->get_base() ) {
242	output << " = sizeof( " << genType( typeDecl->get_base(), "" ) << " )";
243	} // if
244	}
245
246	void CodeGenerator::printDesignators( std::list< Expression * > & designators ) {
247	typedef std::list< Expression * > DesignatorList;
248	if ( designators.size() == 0 ) return;
249	for ( DesignatorList::iterator iter = designators.begin(); iter != designators.end(); ++iter ) {
250	if ( dynamic_cast< NameExpr * >( *iter ) ) {
251	// if expression is a name, then initializing aggregate member
252	output << ".";
253	(iter)->accept( this );
254	} else {
255	// if not a simple name, it has to be a constant expression, i.e. an array designator
256	output << "[";
257	(iter)->accept( this );
258	output << "]";
259	}
260	}
261	output << " = ";
262	}
263
264	void CodeGenerator::visit( SingleInit *init ) {
265	printDesignators( init->get_designators() );
266	init->get_value()->accept( *this );
267	}
268
269	void CodeGenerator::visit( ListInit *init ) {
270	printDesignators( init->get_designators() );
271	output << "{ ";
272	if ( init->begin_initializers() == init->end_initializers() ) {
273	// illegal to leave initializer list empty for scalar initializers, but always legal to have 0
274	output << "0";
275	} else {
276	genCommaList( init->begin_initializers(), init->end_initializers() );
277	}
278	output << " }";
279	}
280
281	void CodeGenerator::visit( Constant *constant ) {
282	output << constant->get_value() ;
283	}
284
285	//*** Expressions
286	void CodeGenerator::visit( ApplicationExpr *applicationExpr ) {
287	extension( applicationExpr );
288	if ( VariableExpr varExpr = dynamic_cast< VariableExpr >( applicationExpr->get_function() ) ) {
289	OperatorInfo opInfo;
290	if ( varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic && operatorLookup( varExpr->get_var()->get_name(), opInfo ) ) {
291	std::list< Expression* >::iterator arg = applicationExpr->get_args().begin();
292	switch ( opInfo.type ) {
293	case OT_PREFIXASSIGN:
294	case OT_POSTFIXASSIGN:
295	case OT_INFIXASSIGN:
296	case OT_CTOR:
297	case OT_DTOR:
298	{
299	assert( arg != applicationExpr->get_args().end() );
300	if ( AddressExpr addrExpr = dynamic_cast< AddressExpr >( *arg ) ) {
301	// remove & from first assignment/ctor argument
302	*arg = addrExpr->get_arg();
303	} else {
304	// no address-of operator, so must be a pointer - add dereference
305	UntypedExpr newExpr = new UntypedExpr( new NameExpr( "?" ) );
306	newExpr->get_args().push_back( *arg );
307	assert( (*arg)->get_results().size() == 1 );
308	Type * type = InitTweak::getPointerBase( (*arg)->get_results().front() );
309	assert( type );
310	newExpr->get_results().push_back( type );
311	*arg = newExpr;
312	} // if
313	break;
314	}
315
316	default:
317	// do nothing
318	;
319	}
320
321	switch ( opInfo.type ) {
322	case OT_INDEX:
323	assert( applicationExpr->get_args().size() == 2 );
324	(arg++)->accept( this );
325	output << "[";
326	(arg)->accept( this );
327	output << "]";
328	break;
329
330	case OT_CALL:
331	// there are no intrinsic definitions of the function call operator
332	assert( false );
333	break;
334
335	case OT_CTOR:
336	case OT_DTOR:
337	if ( applicationExpr->get_args().size() == 1 ) {
338	// the expression fed into a single parameter constructor or destructor may contain side
339	// effects, so must still output this expression
340	output << "(";
341	(arg++)->accept( this );
342	output << ") /* " << opInfo.inputName << " */";
343	} else if ( applicationExpr->get_args().size() == 2 ) {
344	// intrinsic two parameter constructors are essentially bitwise assignment
345	output << "(";
346	(arg++)->accept( this );
347	output << opInfo.symbol;
348	(arg)->accept( this );
349	output << ") /* " << opInfo.inputName << " */";
350	} else {
351	// no constructors with 0 or more than 2 parameters
352	assert( false );
353	}
354	break;
355
356	case OT_PREFIX:
357	case OT_PREFIXASSIGN:
358	assert( applicationExpr->get_args().size() == 1 );
359	output << "(";
360	output << opInfo.symbol;
361	(arg)->accept( this );
362	output << ")";
363	break;
364
365	case OT_POSTFIX:
366	case OT_POSTFIXASSIGN:
367	assert( applicationExpr->get_args().size() == 1 );
368	(arg)->accept( this );
369	output << opInfo.symbol;
370	break;
371
372
373	case OT_INFIX:
374	case OT_INFIXASSIGN:
375	assert( applicationExpr->get_args().size() == 2 );
376	output << "(";
377	(arg++)->accept( this );
378	output << opInfo.symbol;
379	(arg)->accept( this );
380	output << ")";
381	break;
382
383	case OT_CONSTANT:
384	case OT_LABELADDRESS:
385	// there are no intrinsic definitions of 0/1 or label addresses as functions
386	assert( false );
387	}
388	} else {
389	varExpr->accept( *this );
390	output << "(";
391	genCommaList( applicationExpr->get_args().begin(), applicationExpr->get_args().end() );
392	output << ")";
393	} // if
394	} else {
395	applicationExpr->get_function()->accept( *this );
396	output << "(";
397	genCommaList( applicationExpr->get_args().begin(), applicationExpr->get_args().end() );
398	output << ")";
399	} // if
400	}
401
402	void CodeGenerator::visit( UntypedExpr *untypedExpr ) {
403	extension( untypedExpr );
404	if ( NameExpr nameExpr = dynamic_cast< NameExpr >( untypedExpr->get_function() ) ) {
405	OperatorInfo opInfo;
406	if ( operatorLookup( nameExpr->get_name(), opInfo ) ) {
407	std::list< Expression* >::iterator arg = untypedExpr->get_args().begin();
408	switch ( opInfo.type ) {
409	case OT_INDEX:
410	assert( untypedExpr->get_args().size() == 2 );
411	(arg++)->accept( this );
412	output << "[";
413	(arg)->accept( this );
414	output << "]";
415	break;
416
417	case OT_CALL:
418	assert( false );
419
420
421	case OT_CTOR:
422	case OT_DTOR:
423	if ( untypedExpr->get_args().size() == 1 ) {
424	// the expression fed into a single parameter constructor or destructor may contain side
425	// effects, so must still output this expression
426	output << "(";
427	(arg++)->accept( this );
428	output << ") /* " << opInfo.inputName << " */";
429	} else if ( untypedExpr->get_args().size() == 2 ) {
430	// intrinsic two parameter constructors are essentially bitwise assignment
431	output << "(";
432	(arg++)->accept( this );
433	output << opInfo.symbol;
434	(arg)->accept( this );
435	output << ") /* " << opInfo.inputName << " */";
436	} else {
437	// no constructors with 0 or more than 2 parameters
438	assert( false );
439	}
440	break;
441
442	case OT_PREFIX:
443	case OT_PREFIXASSIGN:
444	case OT_LABELADDRESS:
445	assert( untypedExpr->get_args().size() == 1 );
446	output << "(";
447	output << opInfo.symbol;
448	(arg)->accept( this );
449	output << ")";
450	break;
451
452	case OT_POSTFIX:
453	case OT_POSTFIXASSIGN:
454	assert( untypedExpr->get_args().size() == 1 );
455	(arg)->accept( this );
456	output << opInfo.symbol;
457	break;
458
459	case OT_INFIX:
460	case OT_INFIXASSIGN:
461	assert( untypedExpr->get_args().size() == 2 );
462	output << "(";
463	(arg++)->accept( this );
464	output << opInfo.symbol;
465	(arg)->accept( this );
466	output << ")";
467	break;
468
469	case OT_CONSTANT:
470	// there are no intrinsic definitions of 0 or 1 as functions
471	assert( false );
472	}
473	} else {
474	if ( nameExpr->get_name() != "Range" ) {
475	// builtin routines
476	nameExpr->accept( *this );
477	output << "(";
478	genCommaList( untypedExpr->get_args().begin(), untypedExpr->get_args().end() );
479	output << ")";
480	} else {
481	// case V1 ... V2 or case V1~V2
482	assert( untypedExpr->get_args().size() == 2 );
483	(untypedExpr->get_args().begin())->accept( this );
484	output << " ... ";
485	(--untypedExpr->get_args().end())->accept( this );
486	} // if
487	} // if
488	} else {
489	untypedExpr->get_function()->accept( *this );
490	output << "(";
491	genCommaList( untypedExpr->get_args().begin(), untypedExpr->get_args().end() );
492	output << ")";
493	} // if
494	}
495
496	void CodeGenerator::visit( NameExpr *nameExpr ) {
497	extension( nameExpr );
498	OperatorInfo opInfo;
499	if ( operatorLookup( nameExpr->get_name(), opInfo ) ) {
500	assert( opInfo.type == OT_CONSTANT );
501	output << opInfo.symbol;
502	} else {
503	output << nameExpr->get_name();
504	} // if
505	}
506
507	void CodeGenerator::visit( AddressExpr *addressExpr ) {
508	extension( addressExpr );
509	output << "(&";
510	// this hack makes sure that we don't convert "constant_zero" to "0" if we're taking its address
511	if ( VariableExpr variableExpr = dynamic_cast< VariableExpr >( addressExpr->get_arg() ) ) {
512	output << mangleName( variableExpr->get_var() );
513	} else {
514	addressExpr->get_arg()->accept( *this );
515	} // if
516	output << ")";
517	}
518
519	void CodeGenerator::visit( CastExpr *castExpr ) {
520	extension( castExpr );
521	output << "(";
522	if ( castExpr->get_results().empty() ) {
523	output << "(void)" ;
524	} else if ( ! castExpr->get_results().front()->get_isLvalue() ) {
525	// at least one result type of cast, but not an lvalue
526	output << "(";
527	output << genType( castExpr->get_results().front(), "" );
528	output << ")";
529	} else {
530	// otherwise, the cast is to an lvalue type, so the cast should be dropped, since the result of a cast is
531	// never an lvalue in C
532	}
533	castExpr->get_arg()->accept( *this );
534	output << ")";
535	}
536
537	void CodeGenerator::visit( UntypedMemberExpr *memberExpr ) {
538	assert( false );
539	}
540
541	void CodeGenerator::visit( MemberExpr *memberExpr ) {
542	extension( memberExpr );
543	memberExpr->get_aggregate()->accept( *this );
544	output << "." << mangleName( memberExpr->get_member() );
545	}
546
547	void CodeGenerator::visit( VariableExpr *variableExpr ) {
548	extension( variableExpr );
549	OperatorInfo opInfo;
550	if ( variableExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic && operatorLookup( variableExpr->get_var()->get_name(), opInfo ) && opInfo.type == OT_CONSTANT ) {
551	output << opInfo.symbol;
552	} else {
553	output << mangleName( variableExpr->get_var() );
554	} // if
555	}
556
557	void CodeGenerator::visit( ConstantExpr *constantExpr ) {
558	assert( constantExpr->get_constant() );
559	extension( constantExpr );
560	constantExpr->get_constant()->accept( *this );
561	}
562
563	void CodeGenerator::visit( SizeofExpr *sizeofExpr ) {
564	extension( sizeofExpr );
565	output << "sizeof(";
566	if ( sizeofExpr->get_isType() ) {
567	output << genType( sizeofExpr->get_type(), "" );
568	} else {
569	sizeofExpr->get_expr()->accept( *this );
570	} // if
571	output << ")";
572	}
573
574	void CodeGenerator::visit( AlignofExpr *alignofExpr ) {
575	// use GCC extension to avoid bumping std to C11
576	extension( alignofExpr );
577	output << "__alignof__(";
578	if ( alignofExpr->get_isType() ) {
579	output << genType( alignofExpr->get_type(), "" );
580	} else {
581	alignofExpr->get_expr()->accept( *this );
582	} // if
583	output << ")";
584	}
585
586	void CodeGenerator::visit( UntypedOffsetofExpr *offsetofExpr ) {
587	assert( false && "UntypedOffsetofExpr should not reach code generation." );
588	}
589
590	void CodeGenerator::visit( OffsetofExpr *offsetofExpr ) {
591	// use GCC builtin
592	output << "__builtin_offsetof(";
593	output << genType( offsetofExpr->get_type(), "" );
594	output << ", " << mangleName( offsetofExpr->get_member() );
595	output << ")";
596	}
597
598	void CodeGenerator::visit( OffsetPackExpr *offsetPackExpr ) {
599	assert( false && "OffsetPackExpr should not reach code generation." );
600	}
601
602	void CodeGenerator::visit( LogicalExpr *logicalExpr ) {
603	extension( logicalExpr );
604	output << "(";
605	logicalExpr->get_arg1()->accept( *this );
606	if ( logicalExpr->get_isAnd() ) {
607	output << " && ";
608	} else {
609	output << " \|\| ";
610	} // if
611	logicalExpr->get_arg2()->accept( *this );
612	output << ")";
613	}
614
615	void CodeGenerator::visit( ConditionalExpr *conditionalExpr ) {
616	extension( conditionalExpr );
617	output << "(";
618	conditionalExpr->get_arg1()->accept( *this );
619	output << " ? ";
620	conditionalExpr->get_arg2()->accept( *this );
621	output << " : ";
622	conditionalExpr->get_arg3()->accept( *this );
623	output << ")";
624	}
625
626	void CodeGenerator::visit( CommaExpr *commaExpr ) {
627	extension( commaExpr );
628	output << "(";
629	commaExpr->get_arg1()->accept( *this );
630	output << " , ";
631	commaExpr->get_arg2()->accept( *this );
632	output << ")";
633	}
634
635	void CodeGenerator::visit( TupleExpr *tupleExpr ) {}
636
637	void CodeGenerator::visit( TypeExpr *typeExpr ) {}
638
639	void CodeGenerator::visit( AsmExpr *asmExpr ) {
640	if ( asmExpr->get_inout() ) {
641	output << "[ ";
642	asmExpr->get_inout()->accept( *this );
643	output << " ] ";
644	} // if
645	asmExpr->get_constraint()->accept( *this );
646	output << " ( ";
647	asmExpr->get_operand()->accept( *this );
648	output << " )";
649	}
650
651	//*** Statements
652	void CodeGenerator::visit( CompoundStmt *compoundStmt ) {
653	std::list<Statement*> ks = compoundStmt->get_kids();
654	output << "{" << endl;
655
656	cur_indent += CodeGenerator::tabsize;
657
658	for ( std::list<Statement *>::iterator i = ks.begin(); i != ks.end(); i++ ) {
659	output << indent << printLabels( (*i)->get_labels() );
660	(i)->accept( this );
661
662	output << endl;
663	if ( wantSpacing( *i ) ) {
664	output << endl;
665	}
666	}
667	cur_indent -= CodeGenerator::tabsize;
668
669	output << indent << "}";
670	}
671
672	void CodeGenerator::visit( ExprStmt *exprStmt ) {
673	assert( exprStmt );
674	// cast the top-level expression to void to reduce gcc warnings.
675	Expression * expr = new CastExpr( exprStmt->get_expr() );
676	expr->accept( *this );
677	output << ";";
678	}
679
680	void CodeGenerator::visit( AsmStmt *asmStmt ) {
681	output << "asm ";
682	if ( asmStmt->get_voltile() ) output << "volatile ";
683	if ( ! asmStmt->get_gotolabels().empty() ) output << "goto ";
684	output << "( ";
685	if ( asmStmt->get_instruction() ) asmStmt->get_instruction()->accept( *this );
686	output << " : ";
687	genCommaList( asmStmt->get_output().begin(), asmStmt->get_output().end() );
688	output << " : ";
689	genCommaList( asmStmt->get_input().begin(), asmStmt->get_input().end() );
690	output << " : ";
691	genCommaList( asmStmt->get_clobber().begin(), asmStmt->get_clobber().end() );
692	if ( ! asmStmt->get_gotolabels().empty() ) {
693	output << " : ";
694	for ( std::list<Label>::iterator begin = asmStmt->get_gotolabels().begin();; ) {
695	output << *begin++;
696	if ( begin == asmStmt->get_gotolabels().end() ) break;
697	output << ", ";
698	} // for
699	} // if
700	output << " );" ;
701	}
702
703	void CodeGenerator::visit( IfStmt *ifStmt ) {
704	output << "if ( ";
705	ifStmt->get_condition()->accept( *this );
706	output << " ) ";
707
708	ifStmt->get_thenPart()->accept( *this );
709
710	if ( ifStmt->get_elsePart() != 0) {
711	output << " else ";
712	ifStmt->get_elsePart()->accept( *this );
713	} // if
714	}
715
716	void CodeGenerator::visit( SwitchStmt *switchStmt ) {
717	output << "switch ( " ;
718	switchStmt->get_condition()->accept( *this );
719	output << " ) ";
720
721	output << "{" << std::endl;
722	cur_indent += CodeGenerator::tabsize;
723
724	acceptAll( switchStmt->get_branches(), *this );
725
726	cur_indent -= CodeGenerator::tabsize;
727
728	output << indent << "}";
729	}
730
731	void CodeGenerator::visit( CaseStmt *caseStmt ) {
732	output << indent;
733	if ( caseStmt->isDefault()) {
734	output << "default";
735	} else {
736	output << "case ";
737	caseStmt->get_condition()->accept( *this );
738	} // if
739	output << ":\n";
740
741	std::list<Statement *> sts = caseStmt->get_statements();
742
743	cur_indent += CodeGenerator::tabsize;
744	for ( std::list<Statement *>::iterator i = sts.begin(); i != sts.end(); i++) {
745	output << indent << printLabels( (*i)->get_labels() ) ;
746	(i)->accept( this );
747	output << endl;
748	}
749	cur_indent -= CodeGenerator::tabsize;
750	}
751
752	void CodeGenerator::visit( BranchStmt *branchStmt ) {
753	switch ( branchStmt->get_type()) {
754	case BranchStmt::Goto:
755	if ( ! branchStmt->get_target().empty() )
756	output << "goto " << branchStmt->get_target();
757	else {
758	if ( branchStmt->get_computedTarget() != 0 ) {
759	output << "goto *";
760	branchStmt->get_computedTarget()->accept( *this );
761	} // if
762	} // if
763	break;
764	case BranchStmt::Break:
765	output << "break";
766	break;
767	case BranchStmt::Continue:
768	output << "continue";
769	break;
770	}
771	output << ";";
772	}
773
774
775	void CodeGenerator::visit( ReturnStmt *returnStmt ) {
776	output << "return ";
777	maybeAccept( returnStmt->get_expr(), *this );
778	output << ";";
779	}
780
781	void CodeGenerator::visit( WhileStmt *whileStmt ) {
782	if ( whileStmt->get_isDoWhile() ) {
783	output << "do" ;
784	} else {
785	output << "while (" ;
786	whileStmt->get_condition()->accept( *this );
787	output << ")";
788	} // if
789	output << " ";
790
791	output << CodeGenerator::printLabels( whileStmt->get_body()->get_labels() );
792	whileStmt->get_body()->accept( *this );
793
794	output << indent;
795
796	if ( whileStmt->get_isDoWhile() ) {
797	output << " while (" ;
798	whileStmt->get_condition()->accept( *this );
799	output << ");";
800	} // if
801	}
802
803	void CodeGenerator::visit( ForStmt *forStmt ) {
804	// initialization is always hoisted, so don't bother doing anything with that
805	output << "for (;";
806
807	if ( forStmt->get_condition() != 0 ) {
808	forStmt->get_condition()->accept( *this );
809	}
810	output << ";";
811
812	if ( forStmt->get_increment() != 0 ) {
813	// cast the top-level expression to void to reduce gcc warnings.
814	Expression * expr = new CastExpr( forStmt->get_increment() );
815	expr->accept( *this );
816	}
817	output << ") ";
818
819	if ( forStmt->get_body() != 0 ) {
820	output << CodeGenerator::printLabels( forStmt->get_body()->get_labels() );
821	forStmt->get_body()->accept( *this );
822	} // if
823	}
824
825	void CodeGenerator::visit( NullStmt *nullStmt ) {
826	//output << indent << CodeGenerator::printLabels( nullStmt->get_labels() );
827	output << "/* null statement */ ;";
828	}
829
830	void CodeGenerator::visit( DeclStmt *declStmt ) {
831	declStmt->get_decl()->accept( *this );
832
833	if ( doSemicolon( declStmt->get_decl() ) ) {
834	output << ";";
835	} // if
836	}
837
838	void CodeGenerator::handleStorageClass( Declaration *decl ) {
839	switch ( decl->get_storageClass() ) {
840	case DeclarationNode::Extern:
841	output << "extern ";
842	break;
843	case DeclarationNode::Static:
844	output << "static ";
845	break;
846	case DeclarationNode::Auto:
847	// silently drop storage class
848	break;
849	case DeclarationNode::Register:
850	output << "register ";
851	break;
852	case DeclarationNode::Inline:
853	output << "inline ";
854	break;
855	case DeclarationNode::Fortran:
856	output << "fortran ";
857	break;
858	case DeclarationNode::Noreturn:
859	output << "_Noreturn ";
860	break;
861	case DeclarationNode::Threadlocal:
862	output << "_Thread_local ";
863	break;
864	case DeclarationNode::NoStorageClass:
865	break;
866	} // switch
867	}
868	} // namespace CodeGen
869
870	// Local Variables: //
871	// tab-width: 4 //
872	// mode: c++ //
873	// compile-command: "make install" //
874	// End: //

Note: See TracBrowser for help on using the repository browser.

Download in other formats: