Changeset b0440b7

Timestamp:

Aug 8, 2017, 8:01:10 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, 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, resolv-new, with_gc

Children:

9a4e996

Parents:

4618319

Message:

Prevent reference types from being added in Box through createDeref

Location:

src

Files:

• GenPoly/Lvalue.cc (modified) (4 diffs)
• GenPoly/Lvalue.h (modified) (2 diffs)
• SynTree/Expression.cc (modified) (2 diffs)

src/GenPoly/Lvalue.cc

@@ -94 +94 @@
         } // namespace
 
+        static bool referencesEliminated = false;
+        // used by UntypedExpr::createDeref to determine whether result type of dereference should be ReferenceType or value type.
+        bool referencesPermissable() {
+                return ! referencesEliminated;
+        }
+
         void convertLvalue( std::list< Declaration* >& translationUnit ) {
                 std::cerr << "convertLvalue" << std::endl;
@@ -106 +112 @@
                 mutateAll( translationUnit, collapser );
                 mutateAll( translationUnit, elim );  // last because other passes need reference types to work
+
+                // from this point forward, no other pass should create reference types.
+                referencesEliminated = true;
         }
 
@@ -134 +143 @@
                                 // can be of differing lengths only when function is variadic
                                 assertf( ftype->get_parameters().size() == appExpr->get_args().size() || ftype->get_isVarArgs(), "ApplicationExpr args do not match formal parameter type." );
+
+                                if ( isIntrinsicReference( appExpr ) ) {
+                                        // eliminate reference types from intrinsic applications - now they return lvalues
+                                        appExpr->set_result( appExpr->get_result()->stripReferences() );
+                                        appExpr->get_result()->set_lvalue( true );
+                                }
+
                                 unsigned int i = 0;
                                 const unsigned int end = ftype->get_parameters().size();
@@ -252 +268 @@
                                 }
                                 if ( ResolvExpr::typesCompatibleIgnoreQualifiers( castExpr->get_result(), castExpr->get_arg()->get_result()->stripReferences(), SymTab::Indexer() ) ) {
-                                        // can remove cast if types are compatible
+                                        // can remove cast if types are compatible, changing expression type to value type
+                                        ret->set_result( castExpr->get_result()->clone() );
                                         castExpr->set_arg( nullptr );
                                         delete castExpr;

src/GenPoly/Lvalue.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Lvalue.h -- 
+// Lvalue.h --
 //
 // Author           : Richard C. Bilson
@@ -24 +24 @@
         /// replaces return type of `lvalue T` with `T*`, along with appropriate address-of and dereference operators
         void convertLvalue( std::list< Declaration* >& translationUnit );
+
+        /// true after reference types have been eliminated from the source code. After this point, reference types should not be added to the AST.
+        bool referencesPermissable();
 } // namespace GenPoly
 

src/SynTree/Expression.cc

@@ -34 +34 @@
 #include "InitTweak/InitTweak.h"
 
+#include "GenPoly/Lvalue.h"
 
 Expression::Expression( Expression *_aname ) : result( 0 ), env( 0 ), argName( _aname ) {}
@@ -409 +410 @@
                 Type * base = InitTweak::getPointerBase( type );
                 assertf( base, "expected pointer type in dereference (type was %s)", toString( type ).c_str() );
-                ret->set_result( new ReferenceType( Type::Qualifiers(), base->clone() ) );
+                ret->set_result( base->clone() );
+                if ( GenPoly::referencesPermissable() ) {
+                        // if references are still allowed in the AST, dereference returns a reference
+                        ret->set_result( new ReferenceType( Type::Qualifiers(), ret->get_result() ) );
+                } else {
+                        // references have been removed, in which case dereference returns an lvalue of the base type.
+                        ret->get_result()->set_lvalue( true );
+                }
         }
         return ret;