Context Navigation

source: src/CodeGen/GenType.cc @ 7e4b44db

new-envwith_gc

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

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

Download in other formats: