source: src/SymTab/Autogen.h @ c13e8dc8

arm-ehcleanup-dtorsjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-expr
Last change on this file since c13e8dc8 was c13e8dc8, checked in by Rob Schluntz <rschlunt@…>, 4 years ago

Merge branch 'master' into cleanup-dtors

  • Property mode set to 100644
File size: 9.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// 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 : Sat Jul 22 09:50:25 2017
13// Update Count     : 15
14//
15
16#pragma once
17
18#include <cassert>                // for assert
19#include <string>                 // for string
20
21#include "CodeGen/OperatorTable.h"
22#include "Common/UniqueName.h"    // for UniqueName
23#include "InitTweak/InitTweak.h"  // for InitExpander
24#include "SynTree/Constant.h"     // for Constant
25#include "SynTree/Declaration.h"  // for DeclarationWithType, ObjectDecl
26#include "SynTree/Expression.h"   // for NameExpr, ConstantExpr, UntypedExpr...
27#include "SynTree/Type.h"         // for Type, ArrayType, Type::Qualifiers
28
29class CompoundStmt;
30class Statement;
31
32namespace SymTab {
33        /// Generates assignment operators, constructors, and destructor for aggregate types as required
34        void autogenerateRoutines( std::list< Declaration * > &translationUnit );
35
36        /// returns true if obj's name is the empty string and it has a bitfield width
37        bool isUnnamedBitfield( ObjectDecl * obj );
38
39        /// size_t type - set when size_t typedef is seen. Useful in a few places,
40        /// such as in determining array dimension type
41        extern Type * SizeType;
42
43        /// intrinsic dereference operator for unqualified types - set when *? function is seen in FindSpecialDeclarations.
44        /// Useful for creating dereference ApplicationExprs without a full resolver pass.
45        extern FunctionDecl * dereferenceOperator;
46
47        /// generate the type of an assignment function for paramType.
48        /// maybePolymorphic is true if the resulting FunctionType is allowed to be polymorphic
49        FunctionType * genAssignType( Type * paramType, bool maybePolymorphic = true );
50
51        /// generate the type of a default constructor or destructor for paramType.
52        /// maybePolymorphic is true if the resulting FunctionType is allowed to be polymorphic
53        FunctionType * genDefaultType( Type * paramType, bool maybePolymorphic = true );
54
55        /// generate the type of a copy constructor for paramType.
56        /// maybePolymorphic is true if the resulting FunctionType is allowed to be polymorphic
57        FunctionType * genCopyType( Type * paramType, bool maybePolymorphic = true );
58
59        /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls.
60        template< typename OutputIterator >
61        Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast = nullptr, bool forward = true );
62
63        /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Should only be called with non-array types.
64        /// optionally returns a statement which must be inserted prior to the containing loop, if there is one
65        template< typename OutputIterator >
66        Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression * dstParam, std::string fname, OutputIterator out, Type * type, Type * addCast = nullptr ) {
67                bool isReferenceCtorDtor = false;
68                if ( dynamic_cast< ReferenceType * >( type ) && CodeGen::isCtorDtor( fname ) ) {
69                        // reference constructors are essentially application of the rebind operator.
70                        // apply & to both arguments, do not need a cast
71                        fname = "?=?";
72                        dstParam = new AddressExpr( dstParam );
73                        addCast = nullptr;
74                        isReferenceCtorDtor = true;
75                }
76
77                // want to be able to generate assignment, ctor, and dtor generically,
78                // so fname is either ?=?, ?{}, or ^?{}
79                UntypedExpr * fExpr = new UntypedExpr( new NameExpr( fname ) );
80
81                if ( addCast ) {
82                        // cast to T& with qualifiers removed, so that qualified objects can be constructed
83                        // and destructed with the same functions as non-qualified objects.
84                        // unfortunately, lvalue is considered a qualifier. For AddressExpr to resolve, its argument
85                        // must have an lvalue qualified type, so remove all qualifiers except lvalue. If we ever
86                        // remove lvalue as a qualifier, this can change to
87                        //   type->get_qualifiers() = Type::Qualifiers();
88                        Type * castType = addCast->clone();
89                        castType->get_qualifiers() -= Type::Qualifiers( Type::Lvalue | Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
90                        // castType->set_lvalue( true ); // xxx - might not need this
91                        dstParam = new CastExpr( dstParam, new ReferenceType( Type::Qualifiers(), castType ) );
92                }
93                fExpr->args.push_back( dstParam );
94
95                Statement * listInit = srcParam.buildListInit( fExpr );
96
97                // fetch next set of arguments
98                ++srcParam;
99
100                // return if adding reference fails - will happen on default constructor and destructor
101                if ( isReferenceCtorDtor && ! srcParam.addReference() ) {
102                        delete fExpr;
103                        return listInit;
104                }
105
106                std::list< Expression * > args = *srcParam;
107                fExpr->args.splice( fExpr->args.end(), args );
108
109                *out++ = new ExprStmt( fExpr );
110
111                srcParam.clearArrayIndices();
112
113                return listInit;
114        }
115
116        /// Store in out a loop which calls fname on each element of the array with srcParam and dstParam as arguments.
117        /// If forward is true, loop goes from 0 to N-1, else N-1 to 0
118        template< typename OutputIterator >
119        void genArrayCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, Type * addCast = nullptr, bool forward = true ) {
120                static UniqueName indexName( "_index" );
121
122                // for a flexible array member nothing is done -- user must define own assignment
123                if ( ! array->get_dimension() ) return;
124
125                if ( addCast ) {
126                        // peel off array layer from cast
127                        ArrayType * at = strict_dynamic_cast< ArrayType * >( addCast );
128                        addCast = at->base;
129                }
130
131                Expression * begin, * end, * update, * cmp;
132                if ( forward ) {
133                        // generate: for ( int i = 0; i < N; ++i )
134                        begin = new ConstantExpr( Constant::from_int( 0 ) );
135                        end = array->dimension->clone();
136                        cmp = new NameExpr( "?<?" );
137                        update = new NameExpr( "++?" );
138                } else {
139                        // generate: for ( int i = N-1; i >= 0; --i )
140                        begin = new UntypedExpr( new NameExpr( "?-?" ) );
141                        ((UntypedExpr*)begin)->args.push_back( array->dimension->clone() );
142                        ((UntypedExpr*)begin)->args.push_back( new ConstantExpr( Constant::from_int( 1 ) ) );
143                        end = new ConstantExpr( Constant::from_int( 0 ) );
144                        cmp = new NameExpr( "?>=?" );
145                        update = new NameExpr( "--?" );
146                }
147
148                ObjectDecl *index = new ObjectDecl( indexName.newName(), Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin ) );
149
150                UntypedExpr *cond = new UntypedExpr( cmp );
151                cond->args.push_back( new VariableExpr( index ) );
152                cond->args.push_back( end );
153
154                UntypedExpr *inc = new UntypedExpr( update );
155                inc->args.push_back( new VariableExpr( index ) );
156
157                UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?[?]" ) );
158                dstIndex->args.push_back( dstParam );
159                dstIndex->args.push_back( new VariableExpr( index ) );
160                dstParam = dstIndex;
161
162                // srcParam must keep track of the array indices to build the
163                // source parameter and/or array list initializer
164                srcParam.addArrayIndex( new VariableExpr( index ), array->dimension->clone() );
165
166                // for stmt's body, eventually containing call
167                CompoundStmt * body = new CompoundStmt();
168                Statement * listInit = genCall( srcParam, dstParam, fname, back_inserter( body->kids ), array->base, addCast, forward );
169
170                // block containing for stmt and index variable
171                std::list<Statement *> initList;
172                CompoundStmt * block = new CompoundStmt();
173                block->push_back( new DeclStmt( index ) );
174                if ( listInit ) block->get_kids().push_back( listInit );
175                block->push_back( new ForStmt( initList, cond, inc, body ) );
176
177                *out++ = block;
178        }
179
180        template< typename OutputIterator >
181        Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast, bool forward ) {
182                if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
183                        genArrayCall( srcParam, dstParam, fname, out, at, addCast, forward );
184                        return 0;
185                } else {
186                        return genScalarCall( srcParam, dstParam, fname, out, type, addCast );
187                }
188        }
189
190        /// inserts into out a generated call expression to function fname with arguments dstParam
191        /// and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls. decl is the
192        /// object being constructed. The function wraps constructor and destructor calls in an
193        /// ImplicitCtorDtorStmt node.
194        template< typename OutputIterator >
195        void genImplicitCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, DeclarationWithType * decl, bool forward = true ) {
196                ObjectDecl *obj = dynamic_cast<ObjectDecl *>( decl );
197                assert( obj );
198                // unnamed bit fields are not copied as they cannot be accessed
199                if ( isUnnamedBitfield( obj ) ) return;
200
201                Type * addCast = nullptr;
202                if ( (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && ! obj->get_bitfieldWidth() ) ) ) {
203                        assert( dstParam->result );
204                        addCast = dstParam->result;
205                }
206                std::list< Statement * > stmts;
207                genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->type, addCast, forward );
208
209                // 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
210                assert( stmts.size() <= 1 );
211                if ( stmts.size() == 1 ) {
212                        Statement * callStmt = stmts.front();
213                        if ( addCast ) {
214                                // implicitly generated ctor/dtor calls should be wrapped
215                                // so that later passes are aware they were generated.
216                                // xxx - don't mark as an implicit ctor/dtor if obj is a bitfield,
217                                // because this causes the address to be taken at codegen, which is illegal in C.
218                                callStmt = new ImplicitCtorDtorStmt( callStmt );
219                        }
220                        *out++ = callStmt;
221                }
222        }
223} // namespace SymTab
224
225// Local Variables: //
226// tab-width: 4 //
227// mode: c++ //
228// compile-command: "make install" //
229// End: //
230
Note: See TracBrowser for help on using the repository browser.