source: src/SymTab/Autogen.h @ 1744e6d

ADTaaron-thesisarm-ehast-experimentalcleanup-dtorsdeferred_resndemanglerenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerpthread-emulationqualifiedEnumresolv-newwith_gc
Last change on this file since 1744e6d was 8a6cf7e, checked in by Rob Schluntz <rschlunt@…>, 7 years ago

Fix various reference features.

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