Changeset b067d9b for src/SymTab/Autogen.h

Timestamp:

Oct 29, 2019, 4:01:24 PM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

773db65, 9421f3d8

Parents:

7951100 (diff), 8364209 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

• src/SymTab/Autogen.h (modified) (8 diffs)

src/SymTab/Autogen.h

@@ -17 +17 @@
 
 #include <cassert>                // for assert
+#include <iterator>               // for back_inserter
 #include <string>                 // for string
 
+#include "AST/Decl.hpp"
+#include "AST/Expr.hpp"
+#include "AST/Init.hpp"
+#include "AST/Node.hpp"
+#include "AST/Stmt.hpp"
+#include "AST/Type.hpp"
 #include "CodeGen/OperatorTable.h"
 #include "Common/UniqueName.h"    // for UniqueName
+#include "Common/utility.h"       // for splice
 #include "InitTweak/InitTweak.h"  // for InitExpander
 #include "SynTree/Constant.h"     // for Constant
@@ -36 +44 @@
         /// returns true if obj's name is the empty string and it has a bitfield width
         bool isUnnamedBitfield( ObjectDecl * obj );
-
-        /// size_t type - set when size_t typedef is seen. Useful in a few places,
-        /// such as in determining array dimension type
-        extern Type * SizeType;
-
-        /// intrinsic dereference operator for unqualified types - set when *? function is seen in FindSpecialDeclarations.
-        /// Useful for creating dereference ApplicationExprs without a full resolver pass.
-        extern FunctionDecl * dereferenceOperator;
-
-        // generate the type of an assignment function for paramType
-        FunctionType * genAssignType( Type * paramType );
-
-        // generate the type of a default constructor or destructor for paramType
-        FunctionType * genDefaultType( Type * paramType );
-
-        // generate the type of a copy constructor for paramType
-        FunctionType * genCopyType( Type * paramType );
+        bool isUnnamedBitfield( const ast::ObjectDecl * obj );
+
+        /// generate the type of an assignment function for paramType.
+        /// maybePolymorphic is true if the resulting FunctionType is allowed to be polymorphic
+        FunctionType * genAssignType( Type * paramType, bool maybePolymorphic = true );
+
+        /// generate the type of a default constructor or destructor for paramType.
+        /// maybePolymorphic is true if the resulting FunctionType is allowed to be polymorphic
+        FunctionType * genDefaultType( Type * paramType, bool maybePolymorphic = true );
+
+        /// generate the type of a copy constructor for paramType.
+        /// maybePolymorphic is true if the resulting FunctionType is allowed to be polymorphic
+        FunctionType * genCopyType( Type * paramType, bool maybePolymorphic = true );
+
+        /// Enum for loop direction
+        enum LoopDirection { LoopBackward, LoopForward };
 
         /// 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 >
-        Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast = nullptr, bool forward = true );
+        Statement * genCall( InitTweak::InitExpander_old & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast = nullptr, bool forward = true );
+
+        template< typename OutIter >
+        ast::ptr< ast::Stmt > genCall(
+                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
+                const CodeLocation & loc, const std::string & fname, OutIter && out, 
+                const ast::Type * type, const ast::Type * addCast, LoopDirection forward = LoopForward );
 
         /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Should only be called with non-array types.
         /// optionally returns a statement which must be inserted prior to the containing loop, if there is one
         template< typename OutputIterator >
-        Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression * dstParam, std::string fname, OutputIterator out, Type * type, Type * addCast = nullptr ) {
+        Statement * genScalarCall( InitTweak::InitExpander_old & srcParam, Expression * dstParam, std::string fname, OutputIterator out, Type * type, Type * addCast = nullptr ) {
                 bool isReferenceCtorDtor = false;
                 if ( dynamic_cast< ReferenceType * >( type ) && CodeGen::isCtorDtor( fname ) ) {
@@ -84 +97 @@
                         //   type->get_qualifiers() = Type::Qualifiers();
                         Type * castType = addCast->clone();
-                        castType->get_qualifiers() -= Type::Qualifiers( Type::Lvalue | Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
+                        castType->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
                         // castType->set_lvalue( true ); // xxx - might not need this
                         dstParam = new CastExpr( dstParam, new ReferenceType( Type::Qualifiers(), castType ) );
@@ -111 +124 @@
         }
 
+        /// inserts into out a generated call expression to function fname with arguments dstParam and 
+        /// srcParam. Should only be called with non-array types.
+        /// optionally returns a statement which must be inserted prior to the containing loop, if 
+        /// there is one
+        template< typename OutIter >
+        ast::ptr< ast::Stmt > genScalarCall( 
+                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
+                const CodeLocation & loc, std::string fname, OutIter && out, const ast::Type * type, 
+                const ast::Type * addCast = nullptr
+        ) {
+                bool isReferenceCtorDtor = false;
+                if ( dynamic_cast< const ast::ReferenceType * >( type ) && CodeGen::isCtorDtor( fname ) ) {
+                        // reference constructors are essentially application of the rebind operator.
+                        // apply & to both arguments, do not need a cast
+                        fname = "?=?";
+                        dstParam = new ast::AddressExpr{ dstParam };
+                        addCast = nullptr;
+                        isReferenceCtorDtor = true;
+                }
+
+                // want to be able to generate assignment, ctor, and dtor generically, so fname is one of
+                // "?=?", "?{}", or "^?{}"
+                ast::UntypedExpr * fExpr = new ast::UntypedExpr{ loc, new ast::NameExpr{ loc, fname } };
+
+                if ( addCast ) {
+                        // cast to T& with qualifiers removed, so that qualified objects can be constructed and 
+                        // destructed with the same functions as non-qualified objects. Unfortunately, lvalue 
+                        // is considered a qualifier - for AddressExpr to resolve, its argument must have an 
+                        // lvalue-qualified type, so remove all qualifiers except lvalue.
+                        // xxx -- old code actually removed lvalue too...
+                        ast::ptr< ast::Type > guard = addCast;  // prevent castType from mutating addCast
+                        ast::ptr< ast::Type > castType = addCast;
+                        ast::remove_qualifiers( 
+                                castType, 
+                                ast::CV::Const | ast::CV::Volatile | ast::CV::Restrict | ast::CV::Atomic );
+                        dstParam = new ast::CastExpr{ dstParam, new ast::ReferenceType{ castType } };
+                }
+                fExpr->args.emplace_back( dstParam );
+
+                const ast::Stmt * listInit = srcParam.buildListInit( fExpr );
+
+                // fetch next set of arguments
+                ++srcParam;
+
+                // return if adding reference fails -- will happen on default ctor and dtor
+                if ( isReferenceCtorDtor && ! srcParam.addReference() ) return listInit;
+
+                std::vector< ast::ptr< ast::Expr > > args = *srcParam;
+                splice( fExpr->args, args );
+
+                *out++ = new ast::ExprStmt{ loc, fExpr };
+
+                srcParam.clearArrayIndices();
+                
+                return listInit;
+        }
+
         /// 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( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, Type * addCast = nullptr, bool forward = true ) {
+        void genArrayCall( InitTweak::InitExpander_old & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, Type * addCast = nullptr, bool forward = true ) {
                 static UniqueName indexName( "_index" );
 
@@ -175 +245 @@
         }
 
+        /// 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 OutIter >
+        void genArrayCall(
+                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
+                const CodeLocation & loc, const std::string & fname, OutIter && out, 
+                const ast::ArrayType * array, const ast::Type * addCast = nullptr, 
+                LoopDirection forward = LoopForward 
+        ) {
+                static UniqueName indexName( "_index" );
+
+                // for a flexible array member nothing is done -- user must define own assignment
+                if ( ! array->dimension ) return;
+
+                if ( addCast ) {
+                        // peel off array layer from cast
+                        addCast = strict_dynamic_cast< const ast::ArrayType * >( addCast )->base;
+                }
+
+                ast::ptr< ast::Expr > begin, end, cmp, update;
+
+                if ( forward ) {
+                        // generate: for ( int i = 0; i < N; ++i )
+                        begin = ast::ConstantExpr::from_int( loc, 0 );
+                        end = array->dimension;
+                        cmp = new ast::NameExpr{ loc, "?<?" };
+                        update = new ast::NameExpr{ loc, "++?" };
+                } else {
+                        // generate: for ( int i = N-1; i >= 0; --i )
+                        begin = new ast::UntypedExpr{ 
+                                loc, new ast::NameExpr{ loc, "?-?" }, 
+                                { array->dimension, ast::ConstantExpr::from_int( loc, 1 ) } };
+                        end = ast::ConstantExpr::from_int( loc, 0 );
+                        cmp = new ast::NameExpr{ loc, "?>=?" };
+                        update = new ast::NameExpr{ loc, "--?" };
+                }
+
+                ast::ptr< ast::DeclWithType > index = new ast::ObjectDecl{ 
+                        loc, indexName.newName(), new ast::BasicType{ ast::BasicType::SignedInt }, 
+                        new ast::SingleInit{ loc, begin } };
+                
+                ast::ptr< ast::Expr > cond = new ast::UntypedExpr{
+                        loc, cmp, { new ast::VariableExpr{ loc, index }, end } };
+                
+                ast::ptr< ast::Expr > inc = new ast::UntypedExpr{
+                        loc, update, { new ast::VariableExpr{ loc, index } } };
+                
+                ast::ptr< ast::Expr > dstIndex = new ast::UntypedExpr{
+                        loc, new ast::NameExpr{ loc, "?[?]" }, 
+                        { dstParam, new ast::VariableExpr{ loc, index } } };
+                
+                // srcParam must keep track of the array indices to build the source parameter and/or 
+                // array list initializer
+                srcParam.addArrayIndex( new ast::VariableExpr{ loc, index }, array->dimension );
+
+                // for stmt's body, eventually containing call
+                ast::CompoundStmt * body = new ast::CompoundStmt{ loc };
+                ast::ptr< ast::Stmt > listInit = genCall( 
+                        srcParam, dstIndex, loc, fname, std::back_inserter( body->kids ), array->base, addCast, 
+                        forward );
+                
+                // block containing the stmt and index variable
+                ast::CompoundStmt * block = new ast::CompoundStmt{ loc };
+                block->push_back( new ast::DeclStmt{ loc, index } );
+                if ( listInit ) { block->push_back( listInit ); }
+                block->push_back( new ast::ForStmt{ loc, {}, cond, inc, body } );
+
+                *out++ = block;
+        }
+
         template< typename OutputIterator >
-        Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast, bool forward ) {
+        Statement * genCall( InitTweak::InitExpander_old & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast, bool forward ) {
                 if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
                         genArrayCall( srcParam, dstParam, fname, out, at, addCast, forward );
@@ -185 +325 @@
         }
 
+        template< typename OutIter >
+        ast::ptr< ast::Stmt > genCall(
+                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
+                const CodeLocation & loc, const std::string & fname, OutIter && out, 
+                const ast::Type * type, const ast::Type * addCast, LoopDirection forward
+        ) {
+                if ( auto at = dynamic_cast< const ast::ArrayType * >( type ) ) {
+                        genArrayCall( 
+                                srcParam, dstParam, loc, fname, std::forward< OutIter >(out), at, addCast, 
+                                forward );
+                        return {};
+                } else {
+                        return genScalarCall( 
+                                srcParam, dstParam, loc, fname, std::forward< OutIter >( out ), type, addCast );
+                }
+        }
+
         /// 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
@@ -190 +347 @@
         /// ImplicitCtorDtorStmt node.
         template< typename OutputIterator >
-        void genImplicitCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, DeclarationWithType * decl, bool forward = true ) {
+        void genImplicitCall( InitTweak::InitExpander_old & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, DeclarationWithType * decl, bool forward = true ) {
                 ObjectDecl *obj = dynamic_cast<ObjectDecl *>( decl );
                 assert( obj );
@@ -218 +375 @@
                 }
         }
+
+        static inline ast::ptr< ast::Stmt > genImplicitCall( 
+                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
+                const CodeLocation & loc, const std::string & fname, const ast::ObjectDecl * obj, 
+                LoopDirection forward = LoopForward 
+        ) {
+                // unnamed bit fields are not copied as they cannot be accessed
+                if ( isUnnamedBitfield( obj ) ) return {};
+
+                ast::ptr< ast::Type > addCast = nullptr;
+                if ( (fname == "?{}" || fname == "^?{}") && ( ! obj || ( obj && ! obj->bitfieldWidth ) ) ) {
+                        assert( dstParam->result );
+                        addCast = dstParam->result;
+                }
+
+                std::vector< ast::ptr< ast::Stmt > > stmts;
+                genCall( 
+                        srcParam, dstParam, loc, fname, back_inserter( stmts ), obj->type, addCast, forward );
+
+                if ( stmts.empty() ) {
+                        return {};
+                } else if ( stmts.size() == 1 ) {
+                        const ast::Stmt * callStmt = stmts.front();
+                        if ( addCast ) {
+                                // implicitly generated ctor/dtor calls should be wrapped so that later passes are 
+                                // aware they were generated.
+                                callStmt = new ast::ImplicitCtorDtorStmt{ callStmt->location, callStmt };
+                        }
+                        return callStmt;
+                } else {
+                        assert( false );
+                        return {};
+                }
+        }
 } // namespace SymTab