source: src/SymTab/Autogen.h @ d56e5bc

aaron-thesisarm-ehcleanup-dtorsdeferred_resndemanglerjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerresolv-newwith_gc
Last change on this file since d56e5bc was d56e5bc, checked in by Peter A. Buhr <pabuhr@…>, 4 years ago

add constant value into constants

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