Changeset 5527759

Timestamp:

Apr 27, 2018, 2:35:11 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, 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, with_gc

Children:

399a908, a0c7d5cc

Parents:

b9f383f (diff), 9d5fb67 (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

Files:

• GenPoly/Lvalue.cc (modified) (5 diffs)
• InitTweak/InitTweak.cc (modified) (1 diff)
• ResolvExpr/CommonType.cc (modified) (1 diff)
• tests/references.c (modified) (1 diff)

src/GenPoly/Lvalue.cc

@@ -211 +211 @@
                                                 )
                                                 // TODO: it's likely that the second condition should be ... && ! isIntrinsicReference( arg ), but this requires investigation.
+
                                                 if ( function->get_linkage() != LinkageSpec::Intrinsic && isIntrinsicReference( arg ) ) {
+                                                        // needed for definition of prelude functions, etc.
                                                         // if argument is dereference or array subscript, the result isn't REALLY a reference, but non-intrinsic functions expect a reference: take address
 
@@ -225 +227 @@
                                                         )
                                                         arg = new AddressExpr( arg );
+                                                // } else if ( function->get_linkage() == LinkageSpec::Intrinsic && InitTweak::getPointerBase( arg->result ) ) {
                                                 } else if ( function->get_linkage() == LinkageSpec::Intrinsic && arg->result->referenceDepth() != 0 ) {
                                                         // argument is a 'real' reference, but function expects a C lvalue: add a dereference to the reference-typed argument
@@ -234 +237 @@
                                                         PointerType * ptrType = new PointerType( Type::Qualifiers(), baseType->clone() );
                                                         delete arg->result;
-                                                        arg->set_result( ptrType );
+                                                        arg->result = ptrType;
                                                         arg = mkDeref( arg );
-                                                        assertf( arg->result->referenceDepth() == 0, "Reference types should have been eliminated from intrinsic function calls, but weren't: %s", toCString( arg->result ) );
+                                                        // assertf( arg->result->referenceDepth() == 0, "Reference types should have been eliminated from intrinsic function calls, but weren't: %s", toCString( arg->result ) );
                                                 }
                                         }
@@ -298 +301 @@
                                 }
 
-                                if ( addCast ) {
-                                        PRINT( std::cerr << "adding cast..." << std::endl; )
+                                // if addrExpr depth is 0, then the result is a pointer because the arg was depth 1 and not lvalue.
+                                // This means the dereference result is not a reference, is lvalue, and one less pointer depth than
+                                // the addrExpr. Thus the cast is meaningless.
+                                // TODO: One thing to double check is whether it is possible for the types to differ outside of the single
+                                // pointer level (i.e. can the base type of addrExpr differ from the type of addrExpr-arg?).
+                                // If so then the cast might need to be added, conditional on a more sophisticated check.
+                                if ( addCast && addrExpr->result->referenceDepth() != 0 ) {
+                                        PRINT( std::cerr << "adding cast to " << addrExpr->result << std::endl; )
                                         return new CastExpr( ret, addrExpr->result->clone() );
                                 }
@@ -413 +422 @@
                                 for ( int i = 0; i < diff; ++i ) {
                                         ret = mkDeref( ret );
+                                        // xxx - try removing one reference here? actually, looks like mkDeref already does this, so more closely look at the types generated.
                                 }
                                 if ( ! ResolvExpr::typesCompatibleIgnoreQualifiers( destType->stripReferences(), srcType->stripReferences(), SymTab::Indexer() ) ) {

src/InitTweak/InitTweak.cc

@@ -528 +528 @@
                 }
                 if ( dynamic_cast< ReferenceType * >( dst->result ) ) {
-                        dst = new AddressExpr( dst );
+                        for (int depth = dst->result->referenceDepth(); depth > 0; depth--) {
+                                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() ) );
+                        for (int depth = src->result->referenceDepth(); depth > 0; depth--) {
+                                src = new AddressExpr( src );
+                        }
+                        // src = new CastExpr( src, new ReferenceType( noQualifiers, src->result->stripReferences()->clone() ) );
                 }
                 return new ApplicationExpr( VariableExpr::functionPointer( assign ), { dst, src } );

src/ResolvExpr/CommonType.cc

@@ -101 +101 @@
                         int diff = depth1-depth2;
                         // TODO: should it be possible for commonType to generate complicated conversions? I would argue no, only conversions that involve types of the same reference level or a difference of 1 should be allowed.
-                        if ( diff > 1 || diff < -1 ) return nullptr;
+                        // if ( diff > 1 || diff < -1 ) return nullptr;
 
                         // special case where one type has a reference depth of 1 larger than the other

src/tests/references.c

@@ -75 +75 @@
         printf("%d %d\n", r1, x);
 
-        ((int&)r3) = 6;                       // change x, ***r3
+        r3 = 6;                               // change x, ***r3
         printf("x = %d ; x2 = %d\n", x, x2);  // check that x was changed
-        ((int*&)&r3) = &x2;                   // change r1 to refer to x2, (&*)**r3
-        ((int&)r3) = 999;                     // modify x2
+        &r3 = &x2;                            // change r1 to refer to x2, (&*)**r3
+        r3 = 999;                             // modify x2
         printf("x = %d ; x2 = %d\n", x, x2);  // check that x2 was changed
-        ((int**&)&&r3) = p2;                  // change r2, (&(&*)*)*r3
-        ((int&)r3) = 12345;                   // modify x
+        ((int**&)&&r3) = p2;                  // change r2, (&(&*)*)*r3, ensure explicit cast to reference works
+        r3 = 12345;                           // modify x
         printf("x = %d ; x2 = %d\n", x, x2);  // check that x was changed
-        ((int***&)&&&r3) = p3;                // change r3 to p3, (&(&(&*)*)*)r3
-        ((int&)r3) = 22222;                   // modify x
+        &&&r3 = p3;                           // change r3 to p3, (&(&(&*)*)*)r3
+        ((int&)r3) = 22222;                   // modify x, ensure explicit cast to reference works
         printf("x = %d ; x2 = %d\n", x, x2);  // check that x was changed