Changeset 9cdfb4d0 for src/GenPoly

Timestamp:

Jan 22, 2018, 3:09:01 PM (8 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, stuck-waitfor-destruct, with_gc

Children:

e23d20b

Parents:

326cd2b (diff), 4bf3b2b (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

Location:

src/GenPoly

Files:

• Box.cc (modified) (4 diffs)
• Lvalue.cc (modified) (7 diffs)
• ScrubTyVars.cc (modified) (6 diffs)
• ScrubTyVars.h (modified) (6 diffs)

src/GenPoly/Box.cc

@@ -302 +302 @@
         Expression *makeOp( const std::string &name, Expression *arg ) {
                 UntypedExpr *expr = new UntypedExpr( new NameExpr( name ) );
-                expr->get_args().push_back( arg );
+                expr->args.push_back( arg );
                 return expr;
         }
@@ -309 +309 @@
         Expression *makeOp( const std::string &name, Expression *lhs, Expression *rhs ) {
                 UntypedExpr *expr = new UntypedExpr( new NameExpr( name ) );
-                expr->get_args().push_back( lhs );
-                expr->get_args().push_back( rhs );
+                expr->args.push_back( lhs );
+                expr->args.push_back( rhs );
                 return expr;
         }
@@ -316 +316 @@
         /// Returns the dereference of a local pointer variable
         Expression *derefVar( ObjectDecl *var ) {
-                return makeOp( "*?", new VariableExpr( var ) );
+                return UntypedExpr::createDeref( new VariableExpr( var ) );
         }
 
@@ -831 +831 @@
                                 if ( ! isPolyType( arg->get_type() ) ) {
                                         UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
-                                        deref->get_args().push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) );
-                                        deref->set_result( arg->get_type()->clone() );
+                                        deref->args.push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) );
+                                        deref->result = arg->get_type()->clone();
+                                        deref->result->set_lvalue( true );
                                         return deref;
                                 } // if

src/GenPoly/Lvalue.cc

@@ -47 +47 @@
                         if ( SymTab::dereferenceOperator ) {
                                 VariableExpr * deref = new VariableExpr( SymTab::dereferenceOperator );
-                                deref->set_result( new PointerType( Type::Qualifiers(), deref->get_result() ) );
-                                Type * base = InitTweak::getPointerBase( arg->get_result() );
-                                assertf( base, "expected pointer type in dereference (type was %s)", toString( arg->get_result() ).c_str() );
+                                deref->result = new PointerType( Type::Qualifiers(), deref->result );
+                                Type * base = InitTweak::getPointerBase( arg->result );
+                                assertf( base, "expected pointer type in dereference (type was %s)", toString( arg->result ).c_str() );
                                 ApplicationExpr * ret = new ApplicationExpr( deref, { arg } );
-                                delete ret->get_result();
-                                ret->set_result( base->clone() );
-                                ret->get_result()->set_lvalue( true );
+                                delete ret->result;
+                                ret->result = base->clone();
+                                ret->result->set_lvalue( true );
                                 return ret;
                         } else {
@@ -308 +308 @@
                                         int diff = depth1-depth2;
                                         if ( diff == 0 ) {
+                                                // conversion between references of the same depth
                                                 assertf( depth1 == depth2, "non-intrinsic reference with cast of reference to reference not yet supported: %d %d %s", depth1, depth2, toString( castExpr ).c_str() );
                                                 PRINT( std::cerr << castExpr << std::endl; )
                                                 return castExpr;
                                         } else if ( diff < 0 ) {
-                                                Expression * ret = castExpr->get_arg();
+                                                // conversion from reference to reference with less depth (e.g. int && -> int &): add dereferences
+                                                Expression * ret = castExpr->arg;
                                                 for ( int i = 0; i < diff; ++i ) {
                                                         ret = mkDeref( ret );
                                                 }
-                                                ret->set_env( castExpr->get_env() );
-                                                delete ret->get_result();
-                                                ret->set_result( castExpr->get_result() );
-                                                castExpr->set_env( nullptr );
-                                                castExpr->set_arg( nullptr );
-                                                castExpr->set_result( nullptr );
+                                                ret->env = castExpr->env;
+                                                delete ret->result;
+                                                ret->result = castExpr->result;
+                                                ret->result->set_lvalue( true ); // ensure result is lvalue
+                                                castExpr->env = nullptr;
+                                                castExpr->arg = nullptr;
+                                                castExpr->result = nullptr;
                                                 delete castExpr;
                                                 return ret;
                                         } else if ( diff > 0 ) {
-                                                Expression * ret = castExpr->get_arg();
+                                                // conversion from reference to reference with more depth (e.g. int & -> int &&): add address-of
+                                                Expression * ret = castExpr->arg;
                                                 for ( int i = 0; i < diff; ++i ) {
                                                         ret = new AddressExpr( ret );
                                                 }
-                                                ret->set_env( castExpr->get_env() );
-                                                delete ret->get_result();
-                                                ret->set_result( castExpr->get_result() );
-                                                castExpr->set_env( nullptr );
-                                                castExpr->set_arg( nullptr );
-                                                castExpr->set_result( nullptr );
+                                                ret->env = castExpr->env;
+                                                delete ret->result;
+                                                ret->result = castExpr->result;
+                                                castExpr->env = nullptr;
+                                                castExpr->arg = nullptr;
+                                                castExpr->result = nullptr;
                                                 delete castExpr;
                                                 return ret;
@@ -342 +346 @@
                                         PRINT( std::cerr << castExpr << std::endl; )
                                         return castExpr;
-                                } else if ( castExpr->get_arg()->get_result()->get_lvalue() ) {
+                                } else if ( castExpr->arg->result->get_lvalue() ) {
                                         // conversion from lvalue to reference
                                         // xxx - keep cast, but turn into pointer cast??
@@ -348 +352 @@
                                         PRINT(
                                                 std::cerr << "convert lvalue to reference -- &" << std::endl;
-                                                std::cerr << castExpr->get_arg() << std::endl;
+                                                std::cerr << castExpr->arg << std::endl;
                                         )
-                                        AddressExpr * ret = new AddressExpr( castExpr->get_arg() );
-                                        if ( refType->get_base()->get_qualifiers() != castExpr->get_arg()->get_result()->get_qualifiers() ) {
+                                        AddressExpr * ret = new AddressExpr( castExpr->arg );
+                                        if ( refType->base->get_qualifiers() != castExpr->arg->result->get_qualifiers() ) {
                                                 // must keep cast if cast-to type is different from the actual type
-                                                castExpr->set_arg( ret );
+                                                castExpr->arg = ret;
                                                 return castExpr;
                                         }
-                                        ret->set_env( castExpr->get_env() );
-                                        delete ret->get_result();
-                                        ret->set_result( castExpr->get_result() );
-                                        castExpr->set_env( nullptr );
-                                        castExpr->set_arg( nullptr );
-                                        castExpr->set_result( nullptr );
+                                        ret->env = castExpr->env;
+                                        delete ret->result;
+                                        ret->result = castExpr->result;
+                                        castExpr->env = nullptr;
+                                        castExpr->arg = nullptr;
+                                        castExpr->result = nullptr;
                                         delete castExpr;
                                         return ret;
@@ -368 +372 @@
                                 }
                                 assertf( false, "Only conversions to reference from lvalue are currently supported: %s", toString( castExpr ).c_str() );
-                        } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( castExpr->get_arg()->get_result() ) ) {
+                        } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( castExpr->arg->result ) ) {
                                 (void)refType;
                                 // conversion from reference to rvalue
@@ -375 +379 @@
                                         std::cerr << "was = " << castExpr << std::endl;
                                 )
-                                Expression * ret = castExpr->get_arg();
-                                TypeSubstitution * env = castExpr->get_env();
+                                Expression * ret = castExpr->arg;
+                                TypeSubstitution * env = castExpr->env;
                                 castExpr->set_env( nullptr );
                                 if ( ! isIntrinsicReference( ret ) ) {
@@ -382 +386 @@
                                         ret = mkDeref( ret );
                                 }
-                                if ( ResolvExpr::typesCompatibleIgnoreQualifiers( castExpr->get_result(), castExpr->get_arg()->get_result()->stripReferences(), SymTab::Indexer() ) ) {
+                                if ( ResolvExpr::typesCompatibleIgnoreQualifiers( castExpr->result, castExpr->arg->result->stripReferences(), SymTab::Indexer() ) ) {
                                         // can remove cast if types are compatible, changing expression type to value type
-                                        ret->set_result( castExpr->get_result()->clone() );
-                                        castExpr->set_arg( nullptr );
+                                        ret->result = castExpr->result->clone();
+                                        ret->result->set_lvalue( true );  // ensure result is lvalue
+                                        castExpr->arg = nullptr;
                                         delete castExpr;
                                 } else {
                                         // must keep cast if types are different
-                                        castExpr->set_arg( ret );
+                                        castExpr->arg = ret;
                                         ret = castExpr;
                                 }

src/GenPoly/ScrubTyVars.cc

@@ -25 +25 @@
 
 namespace GenPoly {
-        Type * ScrubTyVars::mutate( TypeInstType *typeInst ) {
+        Type * ScrubTyVars::postmutate( TypeInstType * typeInst ) {
                 if ( ! tyVars ) {
                         if ( typeInst->get_isFtype() ) {
@@ -31 +31 @@
                                 return new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) );
                         } else {
-                                PointerType *ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) );
+                                PointerType * ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) );
                                 delete typeInst;
                                 return ret;
@@ -37 +37 @@
                 }
 
-                TyVarMap::const_iterator tyVar = tyVars->find( typeInst->get_name() );
+                TyVarMap::const_iterator tyVar = tyVars->find( typeInst->name );
                 if ( tyVar != tyVars->end() ) {
                         switch ( tyVar->second.kind ) {
@@ -43 +43 @@
                           case TypeDecl::Ttype:
                                 {
-                                        PointerType *ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) );
+                                        PointerType * ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) );
                                         delete typeInst;
                                         return ret;
@@ -55 +55 @@
         }
 
-        Type * ScrubTyVars::mutateAggregateType( Type *ty ) {
+        Type * ScrubTyVars::mutateAggregateType( Type * ty ) {
                 if ( shouldScrub( ty ) ) {
-                        PointerType *ret = new PointerType( Type::Qualifiers(), new VoidType( ty->get_qualifiers() ) );
+                        PointerType * ret = new PointerType( Type::Qualifiers(), new VoidType( ty->get_qualifiers() ) );
                         delete ty;
                         return ret;
@@ -64 +64 @@
         }
 
-        Type * ScrubTyVars::mutate( StructInstType *structInst ) {
+        Type * ScrubTyVars::postmutate( StructInstType * structInst ) {
                 return mutateAggregateType( structInst );
         }
 
-        Type * ScrubTyVars::mutate( UnionInstType *unionInst ) {
+        Type * ScrubTyVars::postmutate( UnionInstType * unionInst ) {
                 return mutateAggregateType( unionInst );
         }
 
-        Expression * ScrubTyVars::mutate( SizeofExpr *szeof ) {
+        void ScrubTyVars::primeBaseScrub( Type * type ) {
+                // need to determine whether type needs to be scrubbed to determine whether
+                // automatic recursion is necessary
+                if ( Type * t = shouldScrub( type ) ) {
+                        visit_children = false;
+                        GuardValue( dynType );
+                        dynType = t;
+                }
+        }
+
+        Expression * ScrubTyVars::postmutate( SizeofExpr * szeof ) {
                 // sizeof( T ) => _sizeof_T parameter, which is the size of T
-                if ( Type *dynType = shouldScrub( szeof->get_type() ) ) {
+                if ( dynType ) {
                         Expression *expr = new NameExpr( sizeofName( mangleType( dynType ) ) );
                         return expr;
-                } else {
-                        return Mutator::mutate( szeof );
                 } // if
+                return szeof;
         }
 
-        Expression * ScrubTyVars::mutate( AlignofExpr *algnof ) {
+        Expression * ScrubTyVars::postmutate( AlignofExpr * algnof ) {
                 // alignof( T ) => _alignof_T parameter, which is the alignment of T
-                if ( Type *dynType = shouldScrub( algnof->get_type() ) ) {
+                if ( dynType ) {
                         Expression *expr = new NameExpr( alignofName( mangleType( dynType ) ) );
                         return expr;
-                } else {
-                        return Mutator::mutate( algnof );
                 } // if
+                return algnof;
         }
 
-        Type * ScrubTyVars::mutate( PointerType *pointer ) {
-//              // special case of shouldScrub that takes all TypeInstType pointer bases, even if they're not dynamic
-//              Type *base = pointer->get_base();
-//              Type *dynType = 0;
-//              if ( dynamicOnly ) {
-//                      if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( base ) ) {
-//                              if ( tyVars.find( typeInst->get_name() ) != tyVars.end() ) { dynType = typeInst; }
-//                      } else {
-//                              dynType = isDynType( base, tyVars );
-//                      }
-//              } else {
-//                      dynType = isPolyType( base, tyVars );
-//              }
-//              if ( dynType ) {
-                if ( Type *dynType = shouldScrub( pointer->get_base() ) ) {
-                        Type *ret = dynType->acceptMutator( *this );
+        Type * ScrubTyVars::postmutate( PointerType * pointer ) {
+                if ( dynType ) {
+                        Type * ret = dynType->acceptMutator( *visitor );
                         ret->get_qualifiers() |= pointer->get_qualifiers();
-                        pointer->set_base( 0 );
+                        pointer->base = nullptr;
                         delete pointer;
                         return ret;
                 }
-                return Mutator::mutate( pointer );
+                return pointer;
         }
 } // namespace GenPoly

src/GenPoly/ScrubTyVars.h

@@ -18 +18 @@
 #include <cassert>            // for assert
 
+#include "Common/PassVisitor.h"
 #include "GenPoly.h"          // for TyVarMap, isPolyType, isDynType
 #include "SynTree/Mutator.h"  // for Mutator
@@ -27 +28 @@
 
 namespace GenPoly {
-        class ScrubTyVars : public Mutator {
+        struct ScrubTyVars : public WithVisitorRef<ScrubTyVars>, public WithShortCircuiting, public WithGuards {
                 /// Whether to scrub all type variables from the provided map, dynamic type variables from the provided map, or all type variables
                 enum ScrubMode { FromMap, DynamicFromMap, All };
@@ -51 +52 @@
                 static SynTreeClass *scrubAll( SynTreeClass *target );
 
-                virtual Type* mutate( TypeInstType *typeInst );
-                virtual Type* mutate( StructInstType *structInst );
-                virtual Type* mutate( UnionInstType *unionInst );
-                virtual Expression* mutate( SizeofExpr *szeof );
-                virtual Expression* mutate( AlignofExpr *algnof );
-                virtual Type* mutate( PointerType *pointer );
+                /// determine if children should be visited based on whether base type should be scrubbed.
+                void primeBaseScrub( Type * );
+
+                void premutate( TypeInstType * ) { visit_children = false; }
+                void premutate( StructInstType * ) { visit_children = false; }
+                void premutate( UnionInstType * ) { visit_children = false; }
+                void premutate( SizeofExpr * szeof ) { primeBaseScrub( szeof->type ); }
+                void premutate( AlignofExpr * algnof ) { primeBaseScrub( algnof->type ); }
+                void premutate( PointerType * pointer ) { primeBaseScrub( pointer->base ); }
+
+                Type * postmutate( TypeInstType * typeInst );
+                Type * postmutate( StructInstType * structInst );
+                Type * postmutate( UnionInstType * unionInst );
+                Expression * postmutate( SizeofExpr * szeof );
+                Expression * postmutate( AlignofExpr * algnof );
+                Type * postmutate( PointerType * pointer );
 
           private:
@@ -75 +86 @@
                 const TyVarMap *tyVars;  ///< Type variables to scrub
                 ScrubMode mode;          ///< which type variables to scrub? [FromMap]
+
+                Type * dynType = nullptr; ///< result of shouldScrub
         };
 
         template< typename SynTreeClass >
         SynTreeClass * ScrubTyVars::scrub( SynTreeClass *target, const TyVarMap &tyVars ) {
-                ScrubTyVars scrubber( tyVars );
+                PassVisitor<ScrubTyVars> scrubber( tyVars );
                 return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) );
         }
@@ -85 +98 @@
         template< typename SynTreeClass >
         SynTreeClass * ScrubTyVars::scrubDynamic( SynTreeClass *target, const TyVarMap &tyVars ) {
-                ScrubTyVars scrubber( tyVars, ScrubTyVars::DynamicFromMap );
+                PassVisitor<ScrubTyVars> scrubber( tyVars, ScrubTyVars::DynamicFromMap );
                 return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) );
         }
@@ -91 +104 @@
         template< typename SynTreeClass >
         SynTreeClass * ScrubTyVars::scrubAll( SynTreeClass *target ) {
-                ScrubTyVars scrubber;
+                PassVisitor<ScrubTyVars> scrubber;
                 return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) );
         }