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

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 (targetType),
+                        ast::deepCopy( expr->arg->result ),
                         new ast::SingleInit( expr->arg->location, expr->arg ) );
                 PRINT( std::cerr << "make tmp: " << tmp << std::endl; )
@@ -365 +359 @@
                         ret = new ast::AddressExpr( ret->location, ret );
                 }
-                // Must keep cast if types are different.
-                if ( !ResolvExpr::typesCompatible(
-                                srcType,
-                                strict_dynamic_cast<ast::ReferenceType const *>( dstType )->base ) ) {
+                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.
                         return ast::mutate_field( expr, &ast::CastExpr::arg, ret );
                 }
@@ -382 +377 @@
                 }
                 // Must keep cast if types are different.
-                if ( !ResolvExpr::typesCompatible(
+                if ( !ResolvExpr::typesCompatibleIgnoreQualifiers(
                                 dstType->stripReferences(),
                                 srcType->stripReferences() ) ) {
@@ -395 +390 @@
         } else {
                 assert( 0 == diff );
-                // Must keep cast if types are different. (Or it is explicit.)
-                if ( ast::ExplicitCast == expr->isGenerated ||
-                                !ResolvExpr::typesCompatible(
+                // Remove useless generated casts.
+                if ( expr->isGenerated == ast::GeneratedFlag::GeneratedCast &&
+                                ResolvExpr::typesCompatible(
                                         expr->result,
                                         expr->arg->result ) ) {
-                        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() );
+                        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;
         }
 }
@@ -503 +505 @@
 }
 
-/// 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 ) {
@@ -530 +516 @@
                         return ret;
                 }
-        } else {
-                return moveAddressUnderCast( expr );
+        } 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;
+                }
         }
         return expr;