Context Navigation

source: src/CodeTools/ResolvProtoDump.cc @ b181639

aaron-thesisarm-ehcleanup-dtorsdeferred_resnenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprno_listpersistent-indexerpthread-emulationqualifiedEnum

Last change on this file since b181639 was b181639, checked in by Aaron Moss <a3moss@…>, 5 years ago
refinements to ResolvProtoDump? output
Property mode set to `100644`
File size: 16.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	// ResolvProtoDump.cc -- Translates CFA resolver instances into resolv-proto instances
8	//
9	// Author : Aaron Moss
10	// Created On : Tue Sep 11 09:04:00 2018
11	// Last Modified By : Aaron Moss
12	// Last Modified On : Tue Sep 11 09:04:00 2018
13	// Update Count : 1
14	//
15
16	#include <algorithm>
17	#include <cctype>
18	#include <iostream>
19	#include <memory>
20	#include <list>
21	#include <set>
22	#include <sstream>
23	#include <string>
24	#include <unordered_set>
25	#include <vector>
26
27	#include "Common/PassVisitor.h"
28	#include "CodeGen/OperatorTable.h"
29	#include "SynTree/Declaration.h"
30	#include "SynTree/Expression.h"
31	#include "SynTree/Statement.h"
32	#include "SynTree/Type.h"
33
34	namespace CodeTools {
35
36	/// Visitor for dumping resolver prototype output
37	class ProtoDump : public WithShortCircuiting, public WithVisitorRef<ProtoDump> {
38	std::set<std::string> decls; ///< Declarations in this scope
39	std::vector<std::string> exprs; ///< Expressions in this scope
40	std::vector<PassVisitor<ProtoDump>> subs; ///< Sub-scopes
41	const ProtoDump* parent; ///< Outer lexical scope
42
43	public:
44	/// Default constructor for root ProtoDump
45	ProtoDump() : decls(), exprs(), subs(), parent(nullptr) {}
46
47	/// Child constructor
48	ProtoDump(const ProtoDump& p) : decls(), exprs(), subs(), parent(&p) {}
49
50	private:
51	/// checks if this declaration is contained in the scope or one of its parents
52	bool hasDecl( const std::string& s ) const {
53	if ( decls.count( s ) ) return true;
54	if ( parent ) return parent->hasDecl( s );
55	return false;
56	}
57
58	/// adds a new declaration to this scope, providing it does not already exist
59	void addDecl( const std::string& s ) {
60	if ( ! hasDecl( s ) ) decls.insert( s );
61	}
62
63	/// adds a new expression to this scope
64	void addExpr( const std::string& s ) {
65	if ( ! s.empty() ) { exprs.emplace_back( s ); }
66	}
67
68	/// adds a new subscope to this scope, returning a reference
69	PassVisitor<ProtoDump>& addSub() {
70	subs.emplace_back( *this );
71	return subs.back();
72	}
73
74	/// Whether lists should be separated, terminated, or preceded by their separator
75	enum septype { separated, terminated, preceded };
76
77	/// builds space-separated list of types
78	template<typename V>
79	static void build( V& visitor, const std::list< Type* >& tys, std::stringstream& ss,
80	septype mode = separated ) {
81	if ( tys.empty() ) return;
82
83	if ( mode == preceded ) { ss << ' '; }
84
85	auto it = tys.begin();
86	(*it)->accept( visitor );
87
88	while ( ++it != tys.end() ) {
89	ss << ' ';
90	(*it)->accept( visitor );
91	}
92
93	if ( mode == terminated ) { ss << ' '; }
94	}
95
96	/// builds list of types wrapped as tuple type
97	template<typename V>
98	static void buildAsTuple( V& visitor, const std::list< Type* >& tys,
99	std::stringstream& ss ) {
100	switch ( tys.size() ) {
101	case 0: ss << "#void"; break;
102	case 1: tys.front()->accept( visitor ); break;
103	default:
104	ss << "#$" << tys.size() << '<';
105	build( visitor, tys, ss );
106	ss << '>';
107	break;
108	}
109	}
110
111	/// gets types from DWT list
112	static std::list< Type* > from_decls( const std::list< DeclarationWithType* >& decls ) {
113	std::list< Type* > tys;
114	for ( auto decl : decls ) { tys.emplace_back( decl->get_type() ); }
115	return tys;
116	}
117
118	/// gets types from TypeExpr list
119	static std::list< Type* > from_exprs( const std::list< Expression* >& exprs ) {
120	std::list< Type* > tys;
121	for ( auto expr : exprs ) {
122	if ( TypeExpr* tyExpr = dynamic_cast<TypeExpr*>(expr) ) {
123	tys.emplace_back( tyExpr->type );
124	}
125	}
126	return tys;
127	}
128
129	/// builds prefixes for rp_name
130	static std::string new_prefix( const std::string& old, const char* added ) {
131	if ( old.empty() ) return std::string{"$"} + added;
132	return old + added;
133	}
134
135	/// shortens operator names
136	static void op_name( const std::string& name, std::stringstream& ss ) {
137	if ( name.compare( 0, 10, "_operator_" ) == 0 ) {
138	ss << name.substr(10);
139	} else if ( name.compare( "_constructor" ) == 0
140	\|\| name.compare( "_destructor" ) == 0 ) {
141	ss << name.substr(1);
142	} else if ( name.compare( 0, 11, "__operator_" ) == 0 ) {
143	ss << name.substr(11);
144	} else {
145	ss << name;
146	}
147	}
148
149	/// replaces operators with resolv-proto names
150	static void rp_name( const std::string& name, std::stringstream& ss,
151	std::string&& pre = "" ) {
152	// safety check for anonymous names
153	if ( name.empty() ) {
154	ss << new_prefix(pre, "anon");
155	return;
156	}
157
158	// replace operator names
159	CodeGen::OperatorInfo info;
160	if ( CodeGen::operatorLookup( name, info ) ) {
161	ss << new_prefix(pre, "");
162	op_name( info.outputName, ss );
163	return;
164	}
165
166	// replace retval names
167	if ( name.compare( 0, 8, "_retval_" ) == 0 ) {
168	ss << new_prefix(pre, "rtn_");
169	op_name( name.substr(8), ss );
170	return;
171	}
172
173	// default to just name
174	ss << pre << name;
175	}
176
177	/// ensures type inst names are uppercase
178	static void ti_name( const std::string& name, std::stringstream& ss ) {
179	ss << (char)std::toupper( static_cast<unsigned char>(name[0]) )
180	<< (name.c_str() + 1);
181	}
182
183	/// Visitor for printing types
184	struct TypePrinter : public WithShortCircuiting, WithVisitorRef<TypePrinter>, WithGuards {
185	std::stringstream& ss; ///< Output to print to
186	unsigned depth; ///< Depth of nesting from root type
187
188	TypePrinter( std::stringstream& ss ) : ss(ss), depth(0) {}
189
190	// basic type represented as integer type
191	// TODO maybe hard-code conversion graph and make named type
192	void previsit( BasicType* bt ) { ss << (int)bt->get_kind(); }
193
194	// pointers represented as generic type
195	// TODO except pointer to function
196	void previsit( PointerType* ) { ss << "#$ptr<"; ++depth; }
197	void postvisit( PointerType* ) { --depth; ss << '>'; }
198
199	// arrays represented as generic type
200	void previsit( ArrayType* at ) {
201	ss << "#$arr<";
202	++depth;
203	at->base->accept( *visitor );
204	--depth;
205	ss << '>';
206	visit_children = false;
207	}
208
209	// ignore top-level reference types, they're mostly transparent to resolution
210	void previsit( ReferenceType* ) {
211	if ( depth > 0 ) { ss << "#$ref<"; }
212	++depth;
213	}
214	void postvisit( ReferenceType* ) {
215	--depth;
216	if ( depth > 0 ) { ss << '>'; }
217	}
218
219	// encode function type as a 2-param generic type
220	// TODO handle forall functions
221	void previsit( FunctionType* ft ) {
222	ss << "#$fn<";
223	++depth;
224	buildAsTuple( *visitor, from_decls( ft->returnVals ), ss );
225	ss << ' ';
226	buildAsTuple( *visitor, from_decls( ft->parameters ), ss );
227	--depth;
228	ss << '>';
229	visit_children = false;
230	}
231
232	private:
233	// prints aggregate type name as NamedType with optional paramters
234	void handleAggregate( ReferenceToType* at ) {
235	ss << '#' << at->name;
236	if ( ! at->parameters.empty() ) {
237	ss << '<';
238	++depth;
239	build( *visitor, from_exprs( at->parameters ), ss );
240	--depth;
241	ss << '>';
242	}
243	visit_children = false;
244	}
245
246	public:
247	// handle aggregate types using NamedType
248	void previsit( StructInstType* st ) { handleAggregate( st ); }
249	void previsit( UnionInstType* ut ) { handleAggregate( ut ); }
250
251	// replace enums with int
252	void previsit( EnumInstType* ) { ss << (int)BasicType::SignedInt; }
253
254	// make sure first letter of TypeInstType is capitalized
255	void previsit( TypeInstType* vt ) {
256	ti_name( vt->name, ss );
257	}
258
259	// flattens empty and singleton tuples
260	void previsit( TupleType* tt ) {
261	++depth;
262	buildAsTuple( *visitor, tt->types, ss );
263	--depth;
264	visit_children = false;
265	}
266
267	// TODO support VarArgsType
268
269	// replace 0 and 1 with int
270	// TODO support 0 and 1 with their proper type names and conversions
271	void previsit( ZeroType* ) { ss << (int)BasicType::SignedInt; }
272	void previsit( OneType* ) { ss << (int)BasicType::SignedInt; }
273
274	// only print void type if not at top level
275	void previsit( VoidType* ) {
276	if ( depth > 0 ) { ss << "#void"; }
277	}
278	};
279
280	/// builds description of function
281	void build( const std::string& name, FunctionType* fnTy, std::stringstream& ss ) {
282	PassVisitor<TypePrinter> printTy{ ss };
283	build( printTy, from_decls( fnTy->returnVals ), ss, terminated );
284	rp_name( name, ss );
285	build( printTy, from_decls( fnTy->parameters ), ss, preceded );
286	// TODO handle assertions
287	}
288
289	/// builds description of a variable (falls back to function if function type)
290	void build( const std::string& name, Type* ty, std::stringstream& ss ) {
291	// ignore top-level references
292	Type *norefs = ty->stripReferences();
293
294	// fall back to function declaration if function type
295	if ( PointerType* pTy = dynamic_cast< PointerType* >(norefs) ) {
296	if ( FunctionType* fnTy = dynamic_cast< FunctionType* >(pTy->base) ) {
297	build( name, fnTy, ss );
298	return;
299	}
300	} else if ( FunctionType* fnTy = dynamic_cast< FunctionType* >(norefs) ) {
301	build( name, fnTy, ss );
302	return;
303	}
304
305	// print variable declaration as zero-arg function
306	PassVisitor<TypePrinter> printTy{ ss };
307	norefs->accept( printTy );
308	ss << ' ';
309	rp_name( name, ss );
310	}
311
312	/// builds description of a field access
313	void build( const std::string& name, AggregateDecl* agg, Type* ty, std::stringstream& ss ) {
314	// ignore top-level references
315	Type *norefs = ty->stripReferences();
316
317	// print access as new field name
318	PassVisitor<TypePrinter> printTy{ ss };
319	norefs->accept( printTy );
320	ss << ' ';
321	rp_name( name, ss, "$field_" );
322	ss << " #" << agg->name;
323	// handle type parameters
324	if ( ! agg->parameters.empty() ) {
325	ss << '<';
326	auto it = agg->parameters.begin();
327	while (true) {
328	ti_name( (*it)->name, ss );
329	if ( ++it == agg->parameters.end() ) break;
330	ss << ' ';
331	}
332	ss << '>';
333	}
334	}
335
336	/// Visitor for printing expressions
337	struct ExprPrinter : WithShortCircuiting, WithVisitorRef<ExprPrinter> {
338	// TODO change interface to generate multiple expression candidates
339
340	std::stringstream& ss; ///< Output to print to
341
342	ExprPrinter( std::stringstream& ss ) : ss(ss) {}
343
344	/// Names handled as nullary function calls
345	void previsit( NameExpr* expr ) {
346	rp_name( expr->name, ss );
347	ss << "()";
348	}
349
350	/// Calls handled as calls
351	void previsit( UntypedExpr* expr ) {
352	// TODO handle name extraction more generally
353	NameExpr* name = dynamic_cast<NameExpr*>(expr->function);
354
355	// fall back on just resolving call to function name
356	// TODO incorporate function type into resolv-proto
357	if ( ! name ) {
358	expr->function->accept( *visitor );
359	visit_children = false;
360	return;
361	}
362
363	rp_name( name->name, ss );
364	if ( expr->args.empty() ) {
365	ss << "()";
366	} else {
367	ss << "( ";
368	auto it = expr->args.begin();
369	while (true) {
370	(it)->accept( visitor );
371	if ( ++it == expr->args.end() ) break;
372	ss << ' ';
373	}
374	ss << " )";
375	}
376	visit_children = false;
377	}
378
379	/// Address-of handled as operator
380	void previsit( AddressExpr* expr ) {
381	// TODO global function to implement this
382	ss << "$addr( ";
383	expr->arg->accept( *visitor );
384	ss << " )";
385	visit_children = false;
386	}
387
388	/// Casts replaced with result type
389	/// TODO put cast target functions in, and add second expression for target
390	void previsit( CastExpr* cast ) {
391	PassVisitor<TypePrinter> tyPrinter{ ss };
392	cast->result->accept( tyPrinter );
393	visit_children = false;
394	}
395
396	/// Member access handled as function from aggregate to member
397	void previsit( UntypedMemberExpr* expr ) {
398	// TODO handle name extraction more generally
399	NameExpr* name = dynamic_cast<NameExpr*>(expr->member);
400
401	// fall back on just resolving call to member name
402	// TODO incorporate function type into resolv-proto
403	if ( ! name ) {
404	expr->member->accept( *visitor );
405	visit_children = false;
406	return;
407	}
408
409	rp_name( name->name, ss, "$field_" );
410	ss << "( ";
411	expr->aggregate->accept( *visitor );
412	ss << " )";
413	visit_children = false;
414	}
415
416	/// Constant expression replaced by its type
417	void previsit( ConstantExpr* expr ) {
418	PassVisitor<TypePrinter> tyPrinter{ ss };
419	expr->constant.get_type()->accept( tyPrinter );
420	visit_children = false;
421	}
422
423	/// sizeof( ... ), alignof( ... ), offsetof( ... ) replaced by unsigned long constant
424	/// TODO extra expression to resolve argument
425	void previsit( SizeofExpr* ) {
426	ss << (int)BasicType::LongUnsignedInt;
427	visit_children = false;
428	}
429	void previsit( AlignofExpr* ) {
430	ss << (int)BasicType::LongUnsignedInt;
431	visit_children = false;
432	}
433	void previsit( UntypedOffsetofExpr* ) {
434	ss << (int)BasicType::LongUnsignedInt;
435	visit_children = false;
436	}
437
438	/// Logical expressions represented as operators
439	void previsit( LogicalExpr* expr ) {
440	// TODO global functions for these
441	ss << '$' << ( expr->get_isAnd() ? "and" : "or" ) << "( ";
442	expr->arg1->accept( *visitor );
443	ss << ' ';
444	expr->arg2->accept( *visitor );
445	ss << " )";
446	visit_children = false;
447	}
448
449	/// Conditional expression represented as operator
450	void previsit( ConditionalExpr* expr ) {
451	// TODO global function for this
452	ss << "$if( ";
453	expr->arg1->accept( *visitor );
454	ss << ' ';
455	expr->arg2->accept( *visitor );
456	ss << ' ';
457	expr->arg3->accept( *visitor );
458	ss << " )";
459	visit_children = false;
460	}
461
462	/// Comma expression represented as operator
463	void previsit( CommaExpr* expr ) {
464	// TODO global function for this
465	ss << "$seq( ";
466	expr->arg1->accept( *visitor );
467	ss << ' ';
468	expr->arg2->accept( *visitor );
469	ss << " )";
470	visit_children = false;
471	}
472
473	// TODO handle ignored ImplicitCopyCtorExpr and below
474	};
475
476	/// Adds all named declarations in a list to the local scope
477	void addAll( const std::list<DeclarationWithType*>& decls ) {
478	for ( auto decl : decls ) {
479	// skip anonymous decls
480	if ( decl->name.empty() ) continue;
481
482	// handle objects
483	if ( ObjectDecl* obj = dynamic_cast< ObjectDecl* >( decl ) ) {
484	previsit( obj );
485	}
486	}
487	}
488
489	/// encode field access as function
490	void addAggregateFields( AggregateDecl* agg ) {
491	// make field names functions
492	for ( Declaration* member : agg->members ) {
493	if ( ObjectDecl* obj = dynamic_cast< ObjectDecl* >(member) ) {
494	std::stringstream ss;
495	build( obj->name, agg, obj->type, ss );
496	addDecl( ss.str() );
497	}
498	}
499
500	visit_children = false;
501	}
502
503	public:
504	void previsit( ObjectDecl *obj ) {
505	// add variable as declaration
506	std::stringstream ss;
507	build( obj->name, obj->type, ss );
508	addDecl( ss.str() );
509	}
510
511	void previsit( FunctionDecl *decl ) {
512	// add function as declaration
513	std::stringstream ss;
514	build( decl->name, decl->type, ss );
515	addDecl( ss.str() );
516
517	// add body if available
518	if ( decl->statements ) {
519	PassVisitor<ProtoDump>& body = addSub();
520
521	// add named parameters and returns to local scope
522	body.pass.addAll( decl->type->returnVals );
523	body.pass.addAll( decl->type->parameters );
524
525	// TODO add assertions to local scope
526
527	// TODO add set of "closed" types to body so that it can print them as NamedType
528
529	// add contents of function to new scope
530	decl->statements->accept( body );
531	}
532
533	visit_children = false;
534	}
535
536	void previsit( StructDecl* sd ) { addAggregateFields(sd); }
537	void previsit( UnionDecl* ud ) { addAggregateFields(ud); }
538
539	void previsit( EnumDecl* ed ) {
540	std::unique_ptr<Type> eType =
541	std::make_unique<BasicType>( Type::Qualifiers{}, BasicType::SignedInt );
542
543	// add field names directly to enclosing scope
544	for ( Declaration* member : ed->members ) {
545	if ( ObjectDecl* obj = dynamic_cast< ObjectDecl* >(member) ) {
546	previsit(obj);
547	}
548	}
549
550	visit_children = false;
551	}
552
553	void previsit( Expression* expr ) {
554	std::stringstream ss;
555	PassVisitor<ExprPrinter> exPrinter{ss};
556	expr->accept( exPrinter );
557	addExpr( ss.str() );
558	visit_children = false;
559	}
560
561	public:
562	/// Prints this ProtoDump instance
563	void print(unsigned indent = 0) const {
564	std::string tab( indent, '\t' );
565	// print decls
566	for ( const std::string& d : decls ) {
567	std::cout << tab << d << std::endl;
568	}
569	// print divider
570	std::cout << tab << "%%" << std::endl;
571	// print top-level expressions
572	for ( const std::string& e : exprs ) {
573	std::cout << tab << e << std::endl;
574	}
575	// print child scopes
576	++indent;
577	for ( const PassVisitor<ProtoDump>& s : subs ) {
578	std::cout << tab << '{' << std::endl;
579	s.pass.print( indent );
580	std::cout << tab << '}' << std::endl;
581	}
582	}
583	};
584
585	void dumpAsResolvProto( std::list< Declaration * > &translationUnit ) {
586	PassVisitor<ProtoDump> dump;
587	acceptAll( translationUnit, dump );
588	dump.pass.print();
589	}
590
591	} // namespace CodeTools
592
593	// Local Variables: //
594	// tab-width: 4 //
595	// mode: c++ //
596	// compile-command: "make install" //
597	// End: //

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

Download in other formats: