source: src/CodeGen/GenType.cc @ 450805a

aaron-thesisarm-ehcleanup-dtorsdeferred_resndemanglerjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprno_listpersistent-indexer
Last change on this file since 450805a was 450805a, checked in by Rob Schluntz <rschlunt@…>, 3 years ago

Add codegen for variable with qualified type

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