Changeset 9d48a17

Timestamp:

Nov 29, 2017, 1:42:51 PM (7 years ago)

Author:

Thierry Delisle <tdelisle@…>

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:

389528b0, 6090518

Parents:

383e159 (diff), 8d5b9cf (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/InstantiateGeneric.cc (modified) (6 diffs)

src/GenPoly/InstantiateGeneric.cc

@@ -21 +21 @@
 #include <vector>                      // for vector
 
+#include "CodeGen/OperatorTable.h"
 #include "Common/PassVisitor.h"        // for PassVisitor, WithDeclsToAdd
 #include "Common/ScopedMap.h"          // for ScopedMap
@@ -27 +28 @@
 #include "Common/utility.h"            // for deleteAll, cloneAll
 #include "GenPoly.h"                   // for isPolyType, typesPolyCompatible
+#include "InitTweak/InitTweak.h"
 #include "ResolvExpr/typeops.h"
 #include "ScopedSet.h"                 // for ScopedSet, ScopedSet<>::iterator
@@ -154 +156 @@
 
         /// Add cast to dtype-static member expressions so that type information is not lost in GenericInstantiator
-        struct FixDtypeStatic final {
+        struct FixDtypeStatic final : public WithGuards, public WithVisitorRef<FixDtypeStatic>, public WithShortCircuiting, public WithStmtsToAdd {
                 Expression * postmutate( MemberExpr * memberExpr );
+
+                void premutate( ApplicationExpr * appExpr );
+                void premutate( AddressExpr * addrExpr );
 
                 template<typename AggrInst>
                 Expression * fixMemberExpr( AggrInst * inst, MemberExpr * memberExpr );
+
+                bool isLvalueArg = false;
         };
 
@@ -210 +217 @@
                 PassVisitor<GenericInstantiator> instantiator;
 
-                // mutateAll( translationUnit, fixer );
+                mutateAll( translationUnit, fixer );
                 mutateAll( translationUnit, instantiator );
         }
@@ -501 +508 @@
                 if ( isDtypeStatic( baseParams ) ) {
                         if ( ! ResolvExpr::typesCompatible( memberExpr->result, memberExpr->member->get_type(), SymTab::Indexer() ) ) {
-                                // type of member and type of expression differ, so add cast to actual type
-                                return new CastExpr( memberExpr, memberExpr->result->clone() );
+                                // type of member and type of expression differ
+                                Type * concType = memberExpr->result->clone();
+                                if ( isLvalueArg ) {
+                                        // result must be C lvalue, so make a new reference variable with the correct actual type to replace the member expression
+                                        //   forall(dtype T)
+                                        //   struct Ptr {
+                                        //     T * x
+                                        //   };
+                                        //   Ptr(int) p;
+                                        //   int i;
+                                        //   p.x = &i;
+                                        // becomes
+                                        //   int *& _dtype_static_member_0 = (int **)&p.x;
+                                        //   _dtype_static_member_0 = &i;
+                                        // Note: this currently creates more temporaries than is strictly necessary, since it does not check for duplicate uses of the same member expression.
+                                        static UniqueName tmpNamer( "_dtype_static_member_" );
+                                        Expression * init = new CastExpr( new AddressExpr( memberExpr ), new PointerType( Type::Qualifiers(), concType->clone() ) );
+                                        ObjectDecl * tmp = ObjectDecl::newObject( tmpNamer.newName(), new ReferenceType( Type::Qualifiers(), concType ), new SingleInit( init ) );
+                                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, tmp ) );
+                                        return new VariableExpr( tmp );
+                                } else {
+                                        // can simply add a cast to actual type
+                                        return new CastExpr( memberExpr, concType );
+                                }
                         }
                 }
@@ -520 +549 @@
         }
 
+        void FixDtypeStatic::premutate( ApplicationExpr * appExpr ) {
+                GuardValue( isLvalueArg );
+                isLvalueArg = false;
+                DeclarationWithType * function = InitTweak::getFunction( appExpr );
+                if ( function->linkage == LinkageSpec::Intrinsic && CodeGen::isAssignment( function->name ) ) {
+                        // explicitly visit children because only the first argument must be a C lvalue.
+                        visit_children = false;
+                        appExpr->env = maybeMutate( appExpr->env, *visitor );
+                        appExpr->result = maybeMutate( appExpr->result, *visitor );
+                        appExpr->function = maybeMutate( appExpr->function, *visitor );
+                        isLvalueArg = true;
+                        for ( Expression * arg : appExpr->args ) {
+                                arg = maybeMutate( arg, *visitor );
+                                isLvalueArg = false;
+                        }
+                }
+        }
+
+        void FixDtypeStatic::premutate( AddressExpr * ) {
+                // argument of & must be C lvalue
+                GuardValue( isLvalueArg );
+                isLvalueArg = true;
+        }
 } // namespace GenPoly