Changes in / [c8ad5d9:da7fe39]

Location:

src

Files:

• GenPoly/Lvalue.cc (modified) (6 diffs)
• InitTweak/InitTweak.cc (modified) (2 diffs)
• ResolvExpr/CommonType.cc (modified) (1 diff)

src/GenPoly/Lvalue.cc

@@ -17 +17 @@
 #include <string>                        // for string
 
+#include "Common/Debug.h"
 #include "Common/PassVisitor.h"
 #include "GenPoly.h"                     // for isPolyType
@@ -128 +129 @@
                 PassVisitor<AddrRef> addrRef;
                 PassVisitor<FixIntrinsicResult> intrinsicResults;
+                Debug::codeGen( translationUnit, "begin" );
                 mutateAll( translationUnit, intrinsicResults );
+                Debug::codeGen( translationUnit, "intrinsicResults" );
                 mutateAll( translationUnit, addrRef );
+                Debug::codeGen( translationUnit, "addrRef" );
                 mutateAll( translationUnit, refCvt );
+                Debug::codeGen( translationUnit, "refCvt" );
                 mutateAll( translationUnit, fixer );
+                Debug::codeGen( translationUnit, "fixer" );
                 mutateAll( translationUnit, collapser );
+                Debug::codeGen( translationUnit, "collapser" );
                 mutateAll( translationUnit, genLval );
+                Debug::codeGen( translationUnit, "genLval" );
                 mutateAll( translationUnit, elim );  // last because other passes need reference types to work
+                Debug::codeGen( translationUnit, "elim" );
 
                 // from this point forward, no other pass should create reference types.
@@ -211 +220 @@
                                                 )
                                                 // 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 +236 @@
                                                         )
                                                         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 +246 @@
                                                         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 ) );
                                                 }
                                         }
@@ -413 +425 @@
                                 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

@@ -520 +520 @@
 
         ApplicationExpr * createBitwiseAssignment( Expression * dst, Expression * src ) {
+                std::cerr << "=== createBitwiseAssignment ===" << std::endl;
+                std::cerr << "== dst: " << dst << std::endl;
+                std::cerr << "== src: " << src << std::endl;
+
                 static FunctionDecl * assign = nullptr;
                 if ( ! assign ) {
@@ -528 +532 @@
                 }
                 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() ) );
+                }
+                std::cerr << "============= endl : " << std::endl;
+                std::cerr << "-- dst: " << dst << std::endl;
+                std::cerr << "-- src: " << src << std::endl;
                 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