source: src/SymTab/Autogen.h @ 07de76b

ADTarm-ehast-experimentalenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprpthread-emulationqualifiedEnum
Last change on this file since 07de76b was 07de76b, checked in by Peter A. Buhr <pabuhr@…>, 5 years ago

remove file TypeVar?.h* and put TypeVar::Kind into TypeDecl?, move LinkageSpec?.* from directory Parse to SynTree?

  • Property mode set to 100644
File size: 17.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// Autogen.h --
8//
9// Author           : Rob Schluntz
10// Created On       : Sun May 17 21:53:34 2015
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Fri Dec 13 16:38:06 2019
13// Update Count     : 16
14//
15
16#pragma once
17
18#include <cassert>                // for assert
19#include <iterator>               // for back_inserter
20#include <string>                 // for string
21
22#include "AST/Decl.hpp"
23#include "AST/Expr.hpp"
24#include "AST/Init.hpp"
25#include "AST/Node.hpp"
26#include "AST/Stmt.hpp"
27#include "AST/Type.hpp"
28#include "CodeGen/OperatorTable.h"
29#include "Common/UniqueName.h"    // for UniqueName
30#include "Common/utility.h"       // for splice
31#include "InitTweak/InitTweak.h"  // for InitExpander
32#include "SynTree/Constant.h"     // for Constant
33#include "SynTree/Declaration.h"  // for DeclarationWithType, ObjectDecl
34#include "SynTree/Expression.h"   // for NameExpr, ConstantExpr, UntypedExpr...
35#include "SynTree/Type.h"         // for Type, ArrayType, Type::Qualifiers
36#include "SynTree/Statement.h"    // for CompoundStmt, DeclStmt, ExprStmt
37
38class CompoundStmt;
39class Statement;
40
41namespace SymTab {
42        /// Generates assignment operators, constructors, and destructor for aggregate types as required
43        void autogenerateRoutines( std::list< Declaration * > &translationUnit );
44
45        /// returns true if obj's name is the empty string and it has a bitfield width
46        bool isUnnamedBitfield( ObjectDecl * obj );
47        bool isUnnamedBitfield( const ast::ObjectDecl * obj );
48
49        /// generate the type of an assignment function for paramType.
50        /// maybePolymorphic is true if the resulting FunctionType is allowed to be polymorphic
51        FunctionType * genAssignType( Type * paramType, bool maybePolymorphic = true );
52
53        /// generate the type of a default constructor or destructor for paramType.
54        /// maybePolymorphic is true if the resulting FunctionType is allowed to be polymorphic
55        FunctionType * genDefaultType( Type * paramType, bool maybePolymorphic = true );
56
57        /// generate the type of a copy constructor for paramType.
58        /// maybePolymorphic is true if the resulting FunctionType is allowed to be polymorphic
59        FunctionType * genCopyType( Type * paramType, bool maybePolymorphic = true );
60
61        /// Enum for loop direction
62        enum LoopDirection { LoopBackward, LoopForward };
63
64        /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls.
65        template< typename OutputIterator >
66        Statement * genCall( InitTweak::InitExpander_old & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast = nullptr, bool forward = true );
67
68        template< typename OutIter >
69        ast::ptr< ast::Stmt > genCall(
70                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
71                const CodeLocation & loc, const std::string & fname, OutIter && out, 
72                const ast::Type * type, const ast::Type * addCast, LoopDirection forward = LoopForward );
73
74        /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Should only be called with non-array types.
75        /// optionally returns a statement which must be inserted prior to the containing loop, if there is one
76        template< typename OutputIterator >
77        Statement * genScalarCall( InitTweak::InitExpander_old & srcParam, Expression * dstParam, std::string fname, OutputIterator out, Type * type, Type * addCast = nullptr ) {
78                bool isReferenceCtorDtor = false;
79                if ( dynamic_cast< ReferenceType * >( type ) && CodeGen::isCtorDtor( fname ) ) {
80                        // reference constructors are essentially application of the rebind operator.
81                        // apply & to both arguments, do not need a cast
82                        fname = "?=?";
83                        dstParam = new AddressExpr( dstParam );
84                        addCast = nullptr;
85                        isReferenceCtorDtor = true;
86                }
87
88                // want to be able to generate assignment, ctor, and dtor generically,
89                // so fname is either ?=?, ?{}, or ^?{}
90                UntypedExpr * fExpr = new UntypedExpr( new NameExpr( fname ) );
91
92                if ( addCast ) {
93                        // cast to T& with qualifiers removed, so that qualified objects can be constructed
94                        // and destructed with the same functions as non-qualified objects.
95                        // unfortunately, lvalue is considered a qualifier. For AddressExpr to resolve, its argument
96                        // must have an lvalue qualified type, so remove all qualifiers except lvalue. If we ever
97                        // remove lvalue as a qualifier, this can change to
98                        //   type->get_qualifiers() = Type::Qualifiers();
99                        Type * castType = addCast->clone();
100                        castType->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
101                        // castType->set_lvalue( true ); // xxx - might not need this
102                        dstParam = new CastExpr( dstParam, new ReferenceType( Type::Qualifiers(), castType ) );
103                }
104                fExpr->args.push_back( dstParam );
105
106                Statement * listInit = srcParam.buildListInit( fExpr );
107
108                // fetch next set of arguments
109                ++srcParam;
110
111                // return if adding reference fails - will happen on default constructor and destructor
112                if ( isReferenceCtorDtor && ! srcParam.addReference() ) {
113                        delete fExpr;
114                        return listInit;
115                }
116
117                std::list< Expression * > args = *srcParam;
118                fExpr->args.splice( fExpr->args.end(), args );
119
120                *out++ = new ExprStmt( fExpr );
121
122                srcParam.clearArrayIndices();
123
124                return listInit;
125        }
126
127        /// inserts into out a generated call expression to function fname with arguments dstParam and
128        /// srcParam. Should only be called with non-array types.
129        /// optionally returns a statement which must be inserted prior to the containing loop, if
130        /// there is one
131        template< typename OutIter >
132        ast::ptr< ast::Stmt > genScalarCall( 
133                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
134                const CodeLocation & loc, std::string fname, OutIter && out, const ast::Type * type, 
135                const ast::Type * addCast = nullptr
136        ) {
137                bool isReferenceCtorDtor = false;
138                if ( dynamic_cast< const ast::ReferenceType * >( type ) && CodeGen::isCtorDtor( fname ) ) {
139                        // reference constructors are essentially application of the rebind operator.
140                        // apply & to both arguments, do not need a cast
141                        fname = "?=?";
142                        dstParam = new ast::AddressExpr{ dstParam };
143                        addCast = nullptr;
144                        isReferenceCtorDtor = true;
145                }
146
147                // want to be able to generate assignment, ctor, and dtor generically, so fname is one of
148                // "?=?", "?{}", or "^?{}"
149                ast::UntypedExpr * fExpr = new ast::UntypedExpr{ loc, new ast::NameExpr{ loc, fname } };
150
151                if ( addCast ) {
152                        // cast to T& with qualifiers removed, so that qualified objects can be constructed and
153                        // destructed with the same functions as non-qualified objects. Unfortunately, lvalue
154                        // is considered a qualifier - for AddressExpr to resolve, its argument must have an
155                        // lvalue-qualified type, so remove all qualifiers except lvalue.
156                        // xxx -- old code actually removed lvalue too...
157                        ast::ptr< ast::Type > guard = addCast;  // prevent castType from mutating addCast
158                        ast::ptr< ast::Type > castType = addCast;
159                        ast::remove_qualifiers( 
160                                castType, 
161                                ast::CV::Const | ast::CV::Volatile | ast::CV::Restrict | ast::CV::Atomic );
162                        dstParam = new ast::CastExpr{ dstParam, new ast::ReferenceType{ castType } };
163                }
164                fExpr->args.emplace_back( dstParam );
165
166                const ast::Stmt * listInit = srcParam.buildListInit( fExpr );
167
168                // fetch next set of arguments
169                ++srcParam;
170
171                // return if adding reference fails -- will happen on default ctor and dtor
172                if ( isReferenceCtorDtor && ! srcParam.addReference() ) return listInit;
173
174                std::vector< ast::ptr< ast::Expr > > args = *srcParam;
175                splice( fExpr->args, args );
176
177                *out++ = new ast::ExprStmt{ loc, fExpr };
178
179                srcParam.clearArrayIndices();
180               
181                return listInit;
182        }
183
184        /// Store in out a loop which calls fname on each element of the array with srcParam and dstParam as arguments.
185        /// If forward is true, loop goes from 0 to N-1, else N-1 to 0
186        template< typename OutputIterator >
187        void genArrayCall( InitTweak::InitExpander_old & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, Type * addCast = nullptr, bool forward = true ) {
188                static UniqueName indexName( "_index" );
189
190                // for a flexible array member nothing is done -- user must define own assignment
191                if ( ! array->get_dimension() ) return;
192
193                if ( addCast ) {
194                        // peel off array layer from cast
195                        ArrayType * at = strict_dynamic_cast< ArrayType * >( addCast );
196                        addCast = at->base;
197                }
198
199                Expression * begin, * end, * update, * cmp;
200                if ( forward ) {
201                        // generate: for ( int i = 0; i < N; ++i )
202                        begin = new ConstantExpr( Constant::from_int( 0 ) );
203                        end = array->dimension->clone();
204                        cmp = new NameExpr( "?<?" );
205                        update = new NameExpr( "++?" );
206                } else {
207                        // generate: for ( int i = N-1; i >= 0; --i )
208                        begin = new UntypedExpr( new NameExpr( "?-?" ) );
209                        ((UntypedExpr*)begin)->args.push_back( array->dimension->clone() );
210                        ((UntypedExpr*)begin)->args.push_back( new ConstantExpr( Constant::from_int( 1 ) ) );
211                        end = new ConstantExpr( Constant::from_int( 0 ) );
212                        cmp = new NameExpr( "?>=?" );
213                        update = new NameExpr( "--?" );
214                }
215
216                ObjectDecl *index = new ObjectDecl( indexName.newName(), Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin ) );
217
218                UntypedExpr *cond = new UntypedExpr( cmp );
219                cond->args.push_back( new VariableExpr( index ) );
220                cond->args.push_back( end );
221
222                UntypedExpr *inc = new UntypedExpr( update );
223                inc->args.push_back( new VariableExpr( index ) );
224
225                UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?[?]" ) );
226                dstIndex->args.push_back( dstParam );
227                dstIndex->args.push_back( new VariableExpr( index ) );
228                dstParam = dstIndex;
229
230                // srcParam must keep track of the array indices to build the
231                // source parameter and/or array list initializer
232                srcParam.addArrayIndex( new VariableExpr( index ), array->dimension->clone() );
233
234                // for stmt's body, eventually containing call
235                CompoundStmt * body = new CompoundStmt();
236                Statement * listInit = genCall( srcParam, dstParam, fname, back_inserter( body->kids ), array->base, addCast, forward );
237
238                // block containing for stmt and index variable
239                std::list<Statement *> initList;
240                CompoundStmt * block = new CompoundStmt();
241                block->push_back( new DeclStmt( index ) );
242                if ( listInit ) block->get_kids().push_back( listInit );
243                block->push_back( new ForStmt( initList, cond, inc, body ) );
244
245                *out++ = block;
246        }
247
248        /// Store in out a loop which calls fname on each element of the array with srcParam and
249        /// dstParam as arguments. If forward is true, loop goes from 0 to N-1, else N-1 to 0
250        template< typename OutIter >
251        void genArrayCall(
252                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
253                const CodeLocation & loc, const std::string & fname, OutIter && out, 
254                const ast::ArrayType * array, const ast::Type * addCast = nullptr, 
255                LoopDirection forward = LoopForward
256        ) {
257                static UniqueName indexName( "_index" );
258
259                // for a flexible array member nothing is done -- user must define own assignment
260                if ( ! array->dimension ) return;
261
262                if ( addCast ) {
263                        // peel off array layer from cast
264                        addCast = strict_dynamic_cast< const ast::ArrayType * >( addCast )->base;
265                }
266
267                ast::ptr< ast::Expr > begin, end, cmp, update;
268
269                if ( forward ) {
270                        // generate: for ( int i = 0; i < N; ++i )
271                        begin = ast::ConstantExpr::from_int( loc, 0 );
272                        end = array->dimension;
273                        cmp = new ast::NameExpr{ loc, "?<?" };
274                        update = new ast::NameExpr{ loc, "++?" };
275                } else {
276                        // generate: for ( int i = N-1; i >= 0; --i )
277                        begin = new ast::UntypedExpr{ 
278                                loc, new ast::NameExpr{ loc, "?-?" }, 
279                                { array->dimension, ast::ConstantExpr::from_int( loc, 1 ) } };
280                        end = ast::ConstantExpr::from_int( loc, 0 );
281                        cmp = new ast::NameExpr{ loc, "?>=?" };
282                        update = new ast::NameExpr{ loc, "--?" };
283                }
284
285                ast::ptr< ast::DeclWithType > index = new ast::ObjectDecl{ 
286                        loc, indexName.newName(), new ast::BasicType{ ast::BasicType::SignedInt }, 
287                        new ast::SingleInit{ loc, begin } };
288               
289                ast::ptr< ast::Expr > cond = new ast::UntypedExpr{
290                        loc, cmp, { new ast::VariableExpr{ loc, index }, end } };
291               
292                ast::ptr< ast::Expr > inc = new ast::UntypedExpr{
293                        loc, update, { new ast::VariableExpr{ loc, index } } };
294               
295                ast::ptr< ast::Expr > dstIndex = new ast::UntypedExpr{
296                        loc, new ast::NameExpr{ loc, "?[?]" }, 
297                        { dstParam, new ast::VariableExpr{ loc, index } } };
298               
299                // srcParam must keep track of the array indices to build the source parameter and/or
300                // array list initializer
301                srcParam.addArrayIndex( new ast::VariableExpr{ loc, index }, array->dimension );
302
303                // for stmt's body, eventually containing call
304                ast::CompoundStmt * body = new ast::CompoundStmt{ loc };
305                ast::ptr< ast::Stmt > listInit = genCall( 
306                        srcParam, dstIndex, loc, fname, std::back_inserter( body->kids ), array->base, addCast, 
307                        forward );
308               
309                // block containing the stmt and index variable
310                ast::CompoundStmt * block = new ast::CompoundStmt{ loc };
311                block->push_back( new ast::DeclStmt{ loc, index } );
312                if ( listInit ) { block->push_back( listInit ); }
313                block->push_back( new ast::ForStmt{ loc, {}, cond, inc, body } );
314
315                *out++ = block;
316        }
317
318        template< typename OutputIterator >
319        Statement * genCall( InitTweak::InitExpander_old & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast, bool forward ) {
320                if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
321                        genArrayCall( srcParam, dstParam, fname, out, at, addCast, forward );
322                        return 0;
323                } else {
324                        return genScalarCall( srcParam, dstParam, fname, out, type, addCast );
325                }
326        }
327
328        template< typename OutIter >
329        ast::ptr< ast::Stmt > genCall(
330                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
331                const CodeLocation & loc, const std::string & fname, OutIter && out, 
332                const ast::Type * type, const ast::Type * addCast, LoopDirection forward
333        ) {
334                if ( auto at = dynamic_cast< const ast::ArrayType * >( type ) ) {
335                        genArrayCall( 
336                                srcParam, dstParam, loc, fname, std::forward< OutIter >(out), at, addCast, 
337                                forward );
338                        return {};
339                } else {
340                        return genScalarCall( 
341                                srcParam, dstParam, loc, fname, std::forward< OutIter >( out ), type, addCast );
342                }
343        }
344
345        /// inserts into out a generated call expression to function fname with arguments dstParam
346        /// and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls. decl is the
347        /// object being constructed. The function wraps constructor and destructor calls in an
348        /// ImplicitCtorDtorStmt node.
349        template< typename OutputIterator >
350        void genImplicitCall( InitTweak::InitExpander_old & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, DeclarationWithType * decl, bool forward = true ) {
351                ObjectDecl *obj = dynamic_cast<ObjectDecl *>( decl );
352                assert( obj );
353                // unnamed bit fields are not copied as they cannot be accessed
354                if ( isUnnamedBitfield( obj ) ) return;
355
356                Type * addCast = nullptr;
357                if ( (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && ! obj->get_bitfieldWidth() ) ) ) {
358                        assert( dstParam->result );
359                        addCast = dstParam->result;
360                }
361                std::list< Statement * > stmts;
362                genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->type, addCast, forward );
363
364                // currently genCall should produce at most one element, but if that changes then the next line needs to be updated to grab the statement which contains the call
365                assert( stmts.size() <= 1 );
366                if ( stmts.size() == 1 ) {
367                        Statement * callStmt = stmts.front();
368                        if ( addCast ) {
369                                // implicitly generated ctor/dtor calls should be wrapped
370                                // so that later passes are aware they were generated.
371                                // xxx - don't mark as an implicit ctor/dtor if obj is a bitfield,
372                                // because this causes the address to be taken at codegen, which is illegal in C.
373                                callStmt = new ImplicitCtorDtorStmt( callStmt );
374                        }
375                        *out++ = callStmt;
376                }
377        }
378
379        static inline ast::ptr< ast::Stmt > genImplicitCall( 
380                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
381                const CodeLocation & loc, const std::string & fname, const ast::ObjectDecl * obj, 
382                LoopDirection forward = LoopForward
383        ) {
384                // unnamed bit fields are not copied as they cannot be accessed
385                if ( isUnnamedBitfield( obj ) ) return {};
386
387                ast::ptr< ast::Type > addCast = nullptr;
388                if ( (fname == "?{}" || fname == "^?{}") && ( ! obj || ( obj && ! obj->bitfieldWidth ) ) ) {
389                        assert( dstParam->result );
390                        addCast = dstParam->result;
391                }
392
393                std::vector< ast::ptr< ast::Stmt > > stmts;
394                genCall( 
395                        srcParam, dstParam, loc, fname, back_inserter( stmts ), obj->type, addCast, forward );
396
397                if ( stmts.empty() ) {
398                        return {};
399                } else if ( stmts.size() == 1 ) {
400                        const ast::Stmt * callStmt = stmts.front();
401                        if ( addCast ) {
402                                // implicitly generated ctor/dtor calls should be wrapped so that later passes are
403                                // aware they were generated.
404                                callStmt = new ast::ImplicitCtorDtorStmt{ callStmt->location, callStmt };
405                        }
406                        return callStmt;
407                } else {
408                        assert( false );
409                        return {};
410                }
411        }
412} // namespace SymTab
413
414// Local Variables: //
415// tab-width: 4 //
416// mode: c++ //
417// compile-command: "make install" //
418// End: //
419
Note: See TracBrowser for help on using the repository browser.