source: src/SymTab/Autogen.h @ 8135d4c

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

Merge branch 'master' into references

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