Changeset c0d00b6 for src/InitTweak

Timestamp:

Nov 25, 2017, 3:22:18 PM (6 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

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

Children:

c6e2c18

Parents:

9d06142 (diff), 3de176d (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' into cleanup-dtors

Location:

src/InitTweak

Files:

• FixInit.cc (modified) (7 diffs)
• InitTweak.cc (modified) (5 diffs)
• InitTweak.h (modified) (1 diff)

src/InitTweak/FixInit.cc

@@ -396 +396 @@
                         if ( skipCopyConstruct( result ) ) return; // skip certain non-copyable types
 
-                        // type may involve type variables, so apply type substitution to get temporary variable's actual type.
+                        // type may involve type variables, so apply type substitution to get temporary variable's actual type,
+                        // since result type may not be substituted (e.g., if the type does not appear in the parameter list)
                         // Use applyFree so that types bound in function pointers are not substituted, e.g. in forall(dtype T) void (*)(T).
-                        result = result->clone();
                         env->applyFree( result );
                         ObjectDecl * tmp = ObjectDecl::newObject( "__tmp", result, nullptr );
@@ -573 +573 @@
 
                         if ( returnDecl ) {
-                                UntypedExpr * assign = new UntypedExpr( new NameExpr( "?=?" ) );
-                                assign->get_args().push_back( new VariableExpr( returnDecl ) );
-                                assign->get_args().push_back( callExpr );
-                                // know the result type of the assignment is the type of the LHS (minus the pointer), so
-                                // add that onto the assignment expression so that later steps have the necessary information
-                                assign->set_result( returnDecl->get_type()->clone() );
-
+                                ApplicationExpr * assign = createBitwiseAssignment( new VariableExpr( returnDecl ), callExpr );
                                 Expression * retExpr = new CommaExpr( assign, new VariableExpr( returnDecl ) );
                                 // move env from callExpr to retExpr
@@ -937 +931 @@
                 }
 
-                void addIds( SymTab::Indexer & indexer, const std::list< DeclarationWithType * > & decls ) {
-                        for ( auto d : decls ) {
-                                indexer.addId( d );
-                        }
-                }
-
-                void addTypes( SymTab::Indexer & indexer, const std::list< TypeDecl * > & tds ) {
-                        for ( auto td : tds ) {
-                                indexer.addType( td );
-                                addIds( indexer, td->assertions );
-                        }
-                }
-
                 void GenStructMemberCalls::previsit( StructDecl * structDecl ) {
                         if ( ! dtorStruct && structDecl->name == "__Destructor" ) {
@@ -1018 +999 @@
                                 // need to explicitly re-add function parameters to the indexer in order to resolve copy constructors
                                 auto guard = makeFuncGuard( [this]() { indexer.enterScope(); }, [this]() { indexer.leaveScope(); } );
-                                addTypes( indexer, function->type->forall );
-                                addIds( indexer, function->type->returnVals );
-                                addIds( indexer, function->type->parameters );
+                                indexer.addFunctionType( function->type );
 
                                 // need to iterate through members in reverse in order for
@@ -1035 +1014 @@
                                         // insert and resolve default/copy constructor call for each field that's unhandled
                                         std::list< Statement * > stmt;
-                                        Expression * arg2 = 0;
+                                        Expression * arg2 = nullptr;
                                         if ( isCopyConstructor( function ) ) {
                                                 // if copy ctor, need to pass second-param-of-this-function.field
@@ -1188 +1167 @@
                         assert( ctorExpr->result && ctorExpr->get_result()->size() == 1 );
 
-                        // xxx - ideally we would reuse the temporary generated from the copy constructor passes from within firstArg if it exists and not generate a temporary if it's unnecessary.
-                        ObjectDecl * tmp = ObjectDecl::newObject( tempNamer.newName(), ctorExpr->get_result()->clone(), nullptr );
-                        declsToAddBefore.push_back( tmp );
-
                         // xxx - this can be TupleAssignExpr now. Need to properly handle this case.
                         ApplicationExpr * callExpr = strict_dynamic_cast< ApplicationExpr * > ( ctorExpr->get_callExpr() );
@@ -1197 +1172 @@
                         ctorExpr->set_callExpr( nullptr );
                         ctorExpr->set_env( nullptr );
+
+                        // xxx - ideally we would reuse the temporary generated from the copy constructor passes from within firstArg if it exists and not generate a temporary if it's unnecessary.
+                        ObjectDecl * tmp = ObjectDecl::newObject( tempNamer.newName(), callExpr->args.front()->result->clone(), nullptr );
+                        declsToAddBefore.push_back( tmp );
                         delete ctorExpr;
 

src/InitTweak/InitTweak.cc

@@ -12 +12 @@
 #include "Parser/LinkageSpec.h"    // for Spec, isBuiltin, Intrinsic
 #include "ResolvExpr/typeops.h"    // for typesCompatibleIgnoreQualifiers
+#include "SymTab/Autogen.h"
 #include "SymTab/Indexer.h"        // for Indexer
 #include "SynTree/Attribute.h"     // for Attribute
@@ -98 +99 @@
         class InitExpander::ExpanderImpl {
         public:
+                virtual ~ExpanderImpl() = default;
                 virtual std::list< Expression * > next( std::list< Expression * > & indices ) = 0;
                 virtual Statement * buildListInit( UntypedExpr * callExpr, std::list< Expression * > & indices ) = 0;
@@ -105 +107 @@
         public:
                 InitImpl( Initializer * init ) : init( init ) {}
+                virtual ~InitImpl() = default;
 
                 virtual std::list< Expression * > next( __attribute((unused)) std::list< Expression * > & indices ) {
@@ -121 +124 @@
         public:
                 ExprImpl( Expression * expr ) : arg( expr ) {}
-
-                ~ExprImpl() { delete arg; }
+                virtual ~ExprImpl() { delete arg; }
 
                 virtual std::list< Expression * > next( std::list< Expression * > & indices ) {
@@ -523 +525 @@
         }
 
+        ApplicationExpr * createBitwiseAssignment( Expression * dst, Expression * src ) {
+                static FunctionDecl * assign = nullptr;
+                if ( ! assign ) {
+                        // temporary? Generate a fake assignment operator to represent bitwise assignments.
+                        // This operator could easily exist as a real function, but it's tricky because nothing should resolve to this function.
+                        TypeDecl * td = new TypeDecl( "T", noStorageClasses, nullptr, TypeDecl::Dtype, true );
+                        assign = new FunctionDecl( "?=?", noStorageClasses, LinkageSpec::Intrinsic, SymTab::genAssignType( new TypeInstType( noQualifiers, td->name, td ) ), nullptr );
+                }
+                if ( dynamic_cast< ReferenceType * >( dst->result ) ) {
+                        dst = new AddressExpr( dst );
+                } else {
+                        dst = new CastExpr( dst, new ReferenceType( noQualifiers, dst->result->clone() ) );
+                }
+                if ( dynamic_cast< ReferenceType * >( src->result ) ) {
+                        src = new CastExpr( src, new ReferenceType( noQualifiers, src->result->stripReferences()->clone() ) );
+                }
+                return new ApplicationExpr( VariableExpr::functionPointer( assign ), { dst, src } );
+        }
+
         class ConstExprChecker : public Visitor {
         public:

src/InitTweak/InitTweak.h

@@ -35 +35 @@
         /// returns the first parameter of a constructor/destructor/assignment function
         ObjectDecl * getParamThis( FunctionType * ftype );
+
+        /// generate a bitwise assignment operation.
+        ApplicationExpr * createBitwiseAssignment( Expression * dst, Expression * src );
 
         /// transform Initializer into an argument list that can be passed to a call expression