Changes in src/GenPoly/Lvalue.cpp [b6f2e7ab:bdf40650]

File:

• src/GenPoly/Lvalue.cpp (modified) (7 diffs)

src/GenPoly/Lvalue.cpp

@@ -85 +85 @@
 struct ReferenceConversions final :
                 public ast::WithConstTranslationUnit,
-                public ast::WithGuards, public ast::WithStmtsToAdd<> {
+                public ast::WithGuards, public ast::WithStmtsToAdd {
         ast::Expr const * postvisit( ast::CastExpr const * expr );
         ast::Expr const * postvisit( ast::AddressExpr const * expr );
@@ -316 +316 @@
                         Warning::RvalueToReferenceConversion, toCString( expr->arg ) );
 
+                // allowing conversion in the rvalue to const ref case
+                // use the referenced-to type to create temp variables
+                ast::Type const * targetType = dstType;
+                for (int i = 0; i < diff; ++i) targetType = (strict_dynamic_cast<ast::ReferenceType const *>(targetType))->base;
+
                 static UniqueName tmpNamer( "__ref_tmp_" );
                 ast::ObjectDecl * tmp = new ast::ObjectDecl( expr->arg->location,
                         tmpNamer.newName(),
-                        ast::deepCopy( expr->arg->result ),
+                        // ast::deepCopy( expr->arg->result ),
+                        ast::deepCopy (targetType),
                         new ast::SingleInit( expr->arg->location, expr->arg ) );
                 PRINT( std::cerr << "make tmp: " << tmp << std::endl; )
@@ -359 +365 @@
                         ret = new ast::AddressExpr( ret->location, ret );
                 }
-                if ( expr->arg->get_lvalue() &&
-                                !ResolvExpr::typesCompatible(
-                                        srcType,
-                                        strict_dynamic_cast<ast::ReferenceType const *>( dstType )->base ) ) {
-                        // Must keep cast if cast-to type is different from the actual type.
+                // Must keep cast if types are different.
+                if ( !ResolvExpr::typesCompatible(
+                                srcType,
+                                strict_dynamic_cast<ast::ReferenceType const *>( dstType )->base ) ) {
                         return ast::mutate_field( expr, &ast::CastExpr::arg, ret );
                 }
@@ -377 +382 @@
                 }
                 // Must keep cast if types are different.
-                if ( !ResolvExpr::typesCompatibleIgnoreQualifiers(
+                if ( !ResolvExpr::typesCompatible(
                                 dstType->stripReferences(),
                                 srcType->stripReferences() ) ) {
@@ -390 +395 @@
         } else {
                 assert( 0 == diff );
-                // Remove useless generated casts.
-                if ( expr->isGenerated == ast::GeneratedFlag::GeneratedCast &&
-                                ResolvExpr::typesCompatible(
+                // Must keep cast if types are different. (Or it is explicit.)
+                if ( ast::ExplicitCast == expr->isGenerated ||
+                                !ResolvExpr::typesCompatible(
                                         expr->result,
                                         expr->arg->result ) ) {
-                        PRINT(
-                                std::cerr << "types are compatible, removing cast: " << expr << '\n';
-                                std::cerr << "-- " << expr->result << '\n';
-                                std::cerr << "-- " << expr->arg->result << std::endl;
-                        )
-                        auto argAsEnum = expr->arg.as<ast::EnumInstType>();
-                        auto resultAsEnum = expr->result.as<ast::EnumInstType>();
-                        if (argAsEnum && resultAsEnum) {
-                                if (argAsEnum->base->name != resultAsEnum->base->name) {
-                                        return expr;
-                                }
-                        }
-                        return ast::mutate_field( expr->arg.get(),
-                                        &ast::Expr::env, expr->env.get() );
-                }
-                return expr;
+                        return expr;
+                }
+                PRINT(
+                        std::cerr << "types are compatible, removing cast: " << expr << '\n';
+                        std::cerr << "-- " << expr->result << '\n';
+                        std::cerr << "-- " << expr->arg->result << std::endl;
+                )
+                return ast::mutate_field( expr->arg.get(),
+                                &ast::Expr::env, expr->env.get() );
         }
 }
@@ -505 +503 @@
 }
 
+/// Recursively move an address expression underneath casts. Casts are not
+/// lvalue expressions in C but are sometimes considered as such in Cforall,
+/// (passes like InstantiateGeneric can add them.) - &(int) => (int*)&
+ast::Expr const * moveAddressUnderCast( ast::AddressExpr const * expr ) {
+        if ( !dynamic_cast<ast::CastExpr const *>( expr->arg.get() ) ) {
+                return expr;
+        }
+        auto mutExpr = ast::mutate( expr );
+        auto mutCast = strict_dynamic_cast<ast::CastExpr *>(
+                        ast::mutate( mutExpr->arg.release() ) );
+        mutExpr->arg = mutCast->arg;
+        mutCast->arg = moveAddressUnderCast( mutExpr );
+        mutCast->result = new ast::PointerType( mutCast->result );
+        return mutCast;
+}
+
 ast::Expr const * CollapseAddressDeref::postvisit(
                 ast::AddressExpr const * expr ) {
@@ -516 +530 @@
                         return ret;
                 }
-        } else if ( auto cast = dynamic_cast<ast::CastExpr const *>( arg ) ) {
-                // Need to move cast to pointer type out a level since address of
-                // pointer is not valid C code (can be introduced in prior passes,
-                // e.g., InstantiateGeneric)
-                if ( ast::getPointerBase( cast->result ) ) {
-                        auto mutExpr = ast::mutate( expr );
-                        auto mutCast = strict_dynamic_cast<ast::CastExpr *>(
-                                        ast::mutate( mutExpr->arg.release() ) );
-                        mutExpr->arg = mutCast->arg;
-                        mutCast->arg = mutExpr;
-                        mutCast->result = new ast::PointerType( mutCast->result );
-                        return mutCast;
-                }
+        } else {
+                return moveAddressUnderCast( expr );
         }
         return expr;