Changeset f5c3b6c


Ignore:
Timestamp:
Nov 8, 2017, 10:58:35 AM (4 years ago)
Author:
Rob Schluntz <rschlunt@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
0fe4e62
Parents:
d06c808
Message:

Use fake bitwise-assignment function when generating copy constructor calls.

This is change prevents assignment calls from being resolved incorrectly, but is an imperfect fix. Ideally this function could exist somewhere as a real function that the resolver never chooses.

Location:
src/InitTweak
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • src/InitTweak/FixInit.cc

    rd06c808 rf5c3b6c  
    393393                        if ( skipCopyConstruct( result ) ) return; // skip certain non-copyable types
    394394
    395                         // type may involve type variables, so apply type substitution to get temporary variable's actual type.
     395                        // type may involve type variables, so apply type substitution to get temporary variable's actual type,
     396                        // since result type may not be substituted (e.g., if the type does not appear in the parameter list)
    396397                        // Use applyFree so that types bound in function pointers are not substituted, e.g. in forall(dtype T) void (*)(T).
    397                         result = result->clone();
    398398                        env->applyFree( result );
    399399                        ObjectDecl * tmp = ObjectDecl::newObject( "__tmp", result, nullptr );
     
    570570
    571571                        if ( returnDecl ) {
    572                                 UntypedExpr * assign = new UntypedExpr( new NameExpr( "?=?" ) );
    573                                 assign->get_args().push_back( new VariableExpr( returnDecl ) );
    574                                 assign->get_args().push_back( callExpr );
    575                                 // know the result type of the assignment is the type of the LHS (minus the pointer), so
    576                                 // add that onto the assignment expression so that later steps have the necessary information
    577                                 assign->set_result( returnDecl->get_type()->clone() );
    578 
     572                                ApplicationExpr * assign = createBitwiseAssignment( new VariableExpr( returnDecl ), callExpr );
    579573                                Expression * retExpr = new CommaExpr( assign, new VariableExpr( returnDecl ) );
    580574                                // move env from callExpr to retExpr
     
    11611155                        assert( ctorExpr->result && ctorExpr->get_result()->size() == 1 );
    11621156
    1163                         // 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.
    1164                         ObjectDecl * tmp = ObjectDecl::newObject( tempNamer.newName(), ctorExpr->get_result()->clone(), nullptr );
    1165                         declsToAddBefore.push_back( tmp );
    1166 
    11671157                        // xxx - this can be TupleAssignExpr now. Need to properly handle this case.
    11681158                        ApplicationExpr * callExpr = strict_dynamic_cast< ApplicationExpr * > ( ctorExpr->get_callExpr() );
     
    11701160                        ctorExpr->set_callExpr( nullptr );
    11711161                        ctorExpr->set_env( nullptr );
     1162
     1163                        // 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.
     1164                        ObjectDecl * tmp = ObjectDecl::newObject( tempNamer.newName(), callExpr->args.front()->result->clone(), nullptr );
     1165                        declsToAddBefore.push_back( tmp );
    11721166                        delete ctorExpr;
    11731167
  • src/InitTweak/InitTweak.cc

    rd06c808 rf5c3b6c  
    1212#include "Parser/LinkageSpec.h"    // for Spec, isBuiltin, Intrinsic
    1313#include "ResolvExpr/typeops.h"    // for typesCompatibleIgnoreQualifiers
     14#include "SymTab/Autogen.h"
    1415#include "SymTab/Indexer.h"        // for Indexer
    1516#include "SynTree/Attribute.h"     // for Attribute
     
    523524        }
    524525
     526        ApplicationExpr * createBitwiseAssignment( Expression * dst, Expression * src ) {
     527                static FunctionDecl * assign = nullptr;
     528                if ( ! assign ) {
     529                        // temporary? Generate a fake assignment operator to represent bitwise assignments.
     530                        // This operator could easily exist as a real function, but it's tricky because nothing should resolve to this function.
     531                        TypeDecl * td = new TypeDecl( "T", noStorageClasses, nullptr, TypeDecl::Dtype, true );
     532                        assign = new FunctionDecl( "?=?", noStorageClasses, LinkageSpec::Intrinsic, SymTab::genAssignType( new TypeInstType( noQualifiers, td->name, td ) ), nullptr );
     533                }
     534                if ( dynamic_cast< ReferenceType * >( dst->result ) ) {
     535                        dst = new AddressExpr( dst );
     536                } else {
     537                        dst = new CastExpr( dst, new ReferenceType( noQualifiers, dst->result->clone() ) );
     538                }
     539                if ( dynamic_cast< ReferenceType * >( src->result ) ) {
     540                        src = new CastExpr( src, new ReferenceType( noQualifiers, src->result->stripReferences()->clone() ) );
     541                }
     542                return new ApplicationExpr( VariableExpr::functionPointer( assign ), { dst, src } );
     543        }
     544
    525545        class ConstExprChecker : public Visitor {
    526546        public:
  • src/InitTweak/InitTweak.h

    rd06c808 rf5c3b6c  
    3535        /// returns the first parameter of a constructor/destructor/assignment function
    3636        ObjectDecl * getParamThis( FunctionType * ftype );
     37
     38        /// generate a bitwise assignment operation.
     39        ApplicationExpr * createBitwiseAssignment( Expression * dst, Expression * src );
    3740
    3841        /// transform Initializer into an argument list that can be passed to a call expression
Note: See TracChangeset for help on using the changeset viewer.