source: src/SymTab/Autogen.h @ ba3706f

aaron-thesisarm-ehcleanup-dtorsdeferred_resndemanglerjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerresolv-newwith_gc
Last change on this file since ba3706f was ba3706f, checked in by Rob Schluntz <rschlunt@…>, 4 years ago

Remove label lists from various Statement constructors

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