Changeset 0720e049 for src/GenPoly/Box.cc

Timestamp:

Aug 11, 2017, 10:33:37 AM (8 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:

54cd58b0

Parents:

3d4b23fa (diff), 59a75cb (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:/u/cforall/software/cfa/cfa-cc

File:

• src/GenPoly/Box.cc (modified) (7 diffs)

src/GenPoly/Box.cc

@@ -27 +27 @@
 #include "Box.h"
 #include "DeclMutator.h"
+#include "Lvalue.h"
+#include "FindFunction.h"
 #include "PolyMutator.h"
-#include "FindFunction.h"
 #include "ScopedSet.h"
 #include "ScrubTyVars.h"
@@ -202 +203 @@
                 };
 
-                /// Replaces initialization of polymorphic values with alloca, declaration of dtype/ftype with appropriate void expression, and sizeof expressions of polymorphic types with the proper variable
+                /// Replaces initialization of polymorphic values with alloca, declaration of dtype/ftype with appropriate void expression, sizeof expressions of polymorphic types with the proper variable, and strips fields from generic struct declarations.
                 class Pass3 final : public PolyMutator {
                   public:
@@ -210 +211 @@
                         using PolyMutator::mutate;
                         virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
+                        virtual Declaration *mutate( StructDecl *structDecl ) override;
+                        virtual Declaration *mutate( UnionDecl *unionDecl ) override;
                         virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override;
                         virtual TypedefDecl *mutate( TypedefDecl *objectDecl ) override;
@@ -753 +756 @@
 
                 void Pass1::boxParam( Type *param, Expression *&arg, const TyVarMap &exprTyVars ) {
-                        assert( arg->has_result() );
+                        assertf( arg->has_result(), "arg does not have result: %s", toString( arg ).c_str() );
                         if ( isPolyType( param, exprTyVars ) ) {
-                                if ( isPolyType( arg->get_result() ) ) {
+                                Type * newType = arg->get_result()->clone();
+                                if ( env ) env->apply( newType );
+                                std::auto_ptr<Type> manager( newType );
+                                if ( isPolyType( newType ) ) {
                                         // if the argument's type is polymorphic, we don't need to box again!
                                         return;
                                 } else if ( arg->get_result()->get_lvalue() ) {
-                                        // VariableExpr and MemberExpr are lvalues; need to check this isn't coming from the second arg of a comma expression though (not an lvalue)
-                                        // xxx - need to test that this code is still reachable
-                                        if ( CommaExpr *commaArg = dynamic_cast< CommaExpr* >( arg ) ) {
-                                                commaArg->set_arg2( new AddressExpr( commaArg->get_arg2() ) );
-                                        } else {
-                                                arg = new AddressExpr( arg );
-                                        }
+                                        // argument expression may be CFA lvalue, but not C lvalue -- apply generalizedLvalue transformations.
+                                        arg =  generalizedLvalue( new AddressExpr( arg ) );
                                         if ( ! ResolvExpr::typesCompatible( param, arg->get_result(), SymTab::Indexer() ) ) {
                                                 // silence warnings by casting boxed parameters when the actual type does not match up with the formal type.
@@ -1748 +1749 @@
 
                 Expression *PolyGenericCalculator::mutate( SizeofExpr *sizeofExpr ) {
-                        Type *ty = sizeofExpr->get_type();
+                        Type *ty = sizeofExpr->get_isType() ? sizeofExpr->get_type() : sizeofExpr->get_expr()->get_result();
                         if ( findGeneric( ty ) ) {
                                 Expression *ret = new NameExpr( sizeofName( mangleType( ty ) ) );
@@ -1758 +1759 @@
 
                 Expression *PolyGenericCalculator::mutate( AlignofExpr *alignofExpr ) {
-                        Type *ty = alignofExpr->get_type();
+                        Type *ty = alignofExpr->get_isType() ? alignofExpr->get_type() : alignofExpr->get_expr()->get_result();
                         if ( findGeneric( ty ) ) {
                                 Expression *ret = new NameExpr( alignofName( mangleType( ty ) ) );
@@ -1868 +1869 @@
                 }
 
+                /// Strips the members from a generic aggregate
+                void stripGenericMembers(AggregateDecl* decl) {
+                        if ( ! decl->get_parameters().empty() ) decl->get_members().clear();
+                }
+
+                Declaration *Pass3::mutate( StructDecl *structDecl ) {
+                        stripGenericMembers( structDecl );
+                        return structDecl;
+                }
+
+                Declaration *Pass3::mutate( UnionDecl *unionDecl ) {
+                        stripGenericMembers( unionDecl );
+                        return unionDecl;
+                }
+
                 TypeDecl * Pass3::mutate( TypeDecl *typeDecl ) {
 //   Initializer *init = 0;