Changeset b067d9b for src/GenPoly/Lvalue.cc

Timestamp:

Oct 29, 2019, 4:01:24 PM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

773db65, 9421f3d8

Parents:

7951100 (diff), 8364209 (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

File:

• src/GenPoly/Lvalue.cc (modified) (13 diffs)

src/GenPoly/Lvalue.cc

@@ -21 +21 @@
 #include "Lvalue.h"
 
+#include "InitTweak/InitTweak.h"
 #include "Parser/LinkageSpec.h"          // for Spec, isBuiltin, Intrinsic
 #include "ResolvExpr/TypeEnvironment.h"  // for AssertionSet, OpenVarSet
 #include "ResolvExpr/Unify.h"            // for unify
 #include "ResolvExpr/typeops.h"
-#include "SymTab/Autogen.h"
 #include "SymTab/Indexer.h"              // for Indexer
 #include "SynTree/Declaration.h"         // for Declaration, FunctionDecl
@@ -33 +33 @@
 #include "SynTree/Type.h"                // for PointerType, Type, FunctionType
 #include "SynTree/Visitor.h"             // for Visitor, acceptAll
+#include "Validate/FindSpecialDecls.h"   // for dereferenceOperator
 
 #if 0
@@ -44 +45 @@
                 // TODO: fold this into the general createDeref function??
                 Expression * mkDeref( Expression * arg ) {
-                        if ( SymTab::dereferenceOperator ) {
+                        if ( Validate::dereferenceOperator ) {
                                 // note: reference depth can be arbitrarily deep here, so peel off the outermost pointer/reference, not just pointer because they are effecitvely equivalent in this pass
-                                VariableExpr * deref = new VariableExpr( SymTab::dereferenceOperator );
+                                VariableExpr * deref = new VariableExpr( Validate::dereferenceOperator );
                                 deref->result = new PointerType( Type::Qualifiers(), deref->result );
                                 Type * base = InitTweak::getPointerBase( arg->result );
@@ -53 +54 @@
                                 delete ret->result;
                                 ret->result = base->clone();
-                                ret->result->set_lvalue( true );
                                 return ret;
                         } else {
@@ -146 +146 @@
 
         namespace {
-                // true for intrinsic function calls that return a reference
+                // true for intrinsic function calls that return an lvalue in C
                 bool isIntrinsicReference( Expression * expr ) {
+                        // known intrinsic-reference prelude functions
+                        static std::set<std::string> lvalueFunctions = { "*?", "?[?]" };
                         if ( UntypedExpr * untyped = dynamic_cast< UntypedExpr * >( expr ) ) {
                                 std::string fname = InitTweak::getFunctionName( untyped );
-                                // known intrinsic-reference prelude functions
-                                return fname == "*?" || fname == "?[?]";
+                                return lvalueFunctions.count(fname);
                         } else if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * > ( expr ) ) {
                                 if ( DeclarationWithType * func = InitTweak::getFunction( appExpr ) ) {
-                                        // use type of return variable rather than expr result type, since it may have been changed to a pointer type
-                                        FunctionType * ftype = GenPoly::getFunctionType( func->get_type() );
-                                        Type * ret = ftype->returnVals.empty() ? nullptr : ftype->returnVals.front()->get_type();
-                                        return func->linkage == LinkageSpec::Intrinsic && dynamic_cast<ReferenceType *>( ret );
+                                        return func->linkage == LinkageSpec::Intrinsic && lvalueFunctions.count(func->name);
                                 }
                         }
@@ -168 +166 @@
                                 ReferenceType * result = strict_dynamic_cast< ReferenceType * >( appExpr->result );
                                 appExpr->result = result->base->clone();
-                                appExpr->result->set_lvalue( true );
                                 if ( ! inIntrinsic ) {
                                         // when not in an intrinsic function, add a cast to
@@ -197 +194 @@
                                 unsigned int i = 0;
                                 const unsigned int end = ftype->parameters.size();
+
+                                /// The for loop may eagerly dereference the iterators and fail on empty lists
+                                if(i == end) { return appExpr; }
                                 for ( auto p : unsafe_group_iterate( appExpr->args, ftype->parameters ) ) {
-                                        if (i == end) break;
                                         Expression *& arg = std::get<0>( p );
                                         Type * formal = std::get<1>( p )->get_type();
@@ -212 +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 ) ) {
+                                                if ( function->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
@@ -228 +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 ) {
+                                                } else if ( function->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
                                                         PRINT(
@@ -243 +242 @@
                                         }
                                         ++i;
+                                        if (i == end) break;
                                 }
                         }
@@ -355 +355 @@
                         Type * destType = castExpr->result;
                         Type * srcType = castExpr->arg->result;
+                        assertf( destType, "Cast to no type in: %s", toCString( castExpr ) );
+                        assertf( srcType, "Cast from no type in: %s", toCString( castExpr ) );
                         int depth1 = destType->referenceDepth();
                         int depth2 = srcType->referenceDepth();
                         int diff = depth1 - depth2;
 
-                        if ( diff > 0 && ! srcType->get_lvalue() ) {
+                        if ( diff > 0 && ! castExpr->arg->get_lvalue() ) {
                                 // rvalue to reference conversion -- introduce temporary
                                 // know that reference depth of cast argument is 0, need to introduce n temporaries for reference depth of n, e.g.
@@ -403 +405 @@
                                         ret = new AddressExpr( ret );
                                 }
-                                if ( srcType->get_lvalue() && ! ResolvExpr::typesCompatible( srcType, strict_dynamic_cast<ReferenceType *>( destType )->base, SymTab::Indexer() ) ) {
+                                if ( castExpr->arg->get_lvalue() && ! ResolvExpr::typesCompatible( srcType, strict_dynamic_cast<ReferenceType *>( destType )->base, SymTab::Indexer() ) ) {
                                         // must keep cast if cast-to type is different from the actual type
                                         castExpr->arg = ret;
@@ -432 +434 @@
                                 delete ret->result;
                                 ret->result = castExpr->result;
-                                ret->result->set_lvalue( true ); // ensure result is lvalue
+                                assert( ret->get_lvalue() ); // ensure result is lvalue
                                 castExpr->env = nullptr;
                                 castExpr->arg = nullptr;