source: src/SymTab/Autogen.h@ 2be1023

//
// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
//
// The contents of this file are covered under the licence agreement in the
// file "LICENCE" distributed with Cforall.
//
// Autogen.h --
//
// Author           : Rob Schluntz
// Created On       : Sun May 17 21:53:34 2015
// Last Modified By : Rob Schluntz
// Last Modified On : Tue May 19 16:49:43 2015
// Update Count     : 1
//

#ifndef AUTOGEN_H
#define AUTOGEN_H

#include <string>
#include "SynTree/Statement.h"
#include "SynTree/Expression.h"
#include "SynTree/Declaration.h"
#include "SynTree/Initializer.h"

namespace SymTab {
        /// Generates assignment operators, constructors, and destructor for aggregate types as required
        void autogenerateRoutines( std::list< Declaration * > &translationUnit );

        /// returns true if obj's name is the empty string and it has a bitfield width
        bool isUnnamedBitfield( ObjectDecl * obj );

        /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls.
        template< typename OutputIterator >
        void genCall( Expression * srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool forward = true );

        /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Should only be called with non-array types.
        template< typename OutputIterator >
        void genScalarCall( Expression *srcParam, Expression *dstParam, const std::string & fname, OutputIterator out ) {
                // want to be able to generate assignment, ctor, and dtor generically,
                // so fname is either ?=?, ?{}, or ^?{}
                UntypedExpr *fExpr = new UntypedExpr( new NameExpr( fname ) );

                // do something special for unnamed members
                fExpr->get_args().push_back( new AddressExpr( dstParam ) );

                if ( srcParam ) {
                        fExpr->get_args().push_back( srcParam );
                }

                *out++ = new ExprStmt( noLabels, fExpr );
        }

        /// Store in out a loop which calls fname on each element of the array with srcParam and dstParam as arguments.
        /// If forward is true, loop goes from 0 to N-1, else N-1 to 0
        template< typename OutputIterator >
        void genArrayCall( Expression *srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, bool forward = true ) {
                static UniqueName indexName( "_index" );

                // for a flexible array member nothing is done -- user must define own assignment
                if ( ! array->get_dimension() ) return ;

                Expression * begin, * end, * update, * cmp;
                if ( forward ) {
                        // generate: for ( int i = 0; i < 0; ++i )
                        begin = new NameExpr( "0" );
                        end = array->get_dimension()->clone();
                        cmp = new NameExpr( "?<?" );
                        update = new NameExpr( "++?" );
                } else {
                        // generate: for ( int i = N-1; i >= 0; --i )
                        begin = new UntypedExpr( new NameExpr( "?-?" ) );
                        ((UntypedExpr*)begin)->get_args().push_back( array->get_dimension()->clone() );
                        ((UntypedExpr*)begin)->get_args().push_back( new NameExpr( "1" ) );
                        end = new NameExpr( "0" );
                        cmp = new NameExpr( "?>=?" );
                        update = new NameExpr( "--?" );
                }

                ObjectDecl *index = new ObjectDecl( indexName.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), NULL );

                UntypedExpr *init = new UntypedExpr( new NameExpr( "?=?" ) );
                init->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) );
                init->get_args().push_back( begin );
                index->set_init( new SingleInit( init, std::list<Expression*>() ) );

                UntypedExpr *cond = new UntypedExpr( cmp );
                cond->get_args().push_back( new VariableExpr( index ) );
                cond->get_args().push_back( end );

                UntypedExpr *inc = new UntypedExpr( update );
                inc->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) );

                UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?[?]" ) );
                dstIndex->get_args().push_back( dstParam );
                dstIndex->get_args().push_back( new VariableExpr( index ) );
                dstParam = dstIndex;

                // srcParam is NULL for default ctor/dtor
                if ( srcParam ) {
                        UntypedExpr *srcIndex = new UntypedExpr( new NameExpr( "?[?]" ) );
                        srcIndex->get_args().push_back( srcParam );
                        srcIndex->get_args().push_back( new VariableExpr( index ) );
                        srcParam = srcIndex;
                }

                // for stmt's body, eventually containing call
                CompoundStmt * body = new CompoundStmt( noLabels );
                genCall( srcParam, dstParam, fname, back_inserter( body->get_kids() ), array->get_base(), forward );

                // block containing for stmt and index variable
                std::list<Statement *> initList;
                CompoundStmt * block = new CompoundStmt( noLabels );
                block->get_kids().push_back( new DeclStmt( noLabels, index ) );
                block->get_kids().push_back( new ForStmt( noLabels, initList, cond, inc, body ) );

                *out++ = block;
        }

        template< typename OutputIterator >
        void genCall( Expression * srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool forward ) {
                if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
                        genArrayCall( srcParam, dstParam, fname, out, at, forward );
                } else {
                        genScalarCall( srcParam, dstParam, fname, out );
                }
        }

        /// inserts into out a generated call expression to function fname with arguments dstParam
        /// and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls. decl is the
        /// object being constructed. The function wraps constructor and destructor calls in an
        /// ImplicitCtorDtorStmt node.
        template< typename OutputIterator >
        void genImplicitCall( Expression * srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, DeclarationWithType * decl, bool forward = true ) {
                ObjectDecl *obj = dynamic_cast<ObjectDecl *>( decl );
                assert( obj );
                // unnamed bit fields are not copied as they cannot be accessed
                if ( isUnnamedBitfield( obj ) ) return;

                std::list< Statement * > stmts;
                genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->get_type(), forward );

                // currently genCall should produce only one element, but if that changes then the next line needs to be updated to grab the statement which contains the call
                assert( stmts.size() == 1 );
                Statement * callStmt = stmts.front();
                if ( (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && obj->get_bitfieldWidth() == NULL ) ) ) {
                        // implicitly generated ctor/dtor calls should be wrapped
                        // so that later passes are aware they were generated.
                        // xxx - don't mark as an implicit ctor/dtor if obj is a bitfield,
                        // because this causes the address to be taken at codegen, which is illegal in C.
                        callStmt = new ImplicitCtorDtorStmt( callStmt );
                }
                *out++ = callStmt;
        }
} // namespace SymTab
#endif // AUTOGEN_H