Changes in src/GenPoly/Box.cc [acd7c5dd:83794e1]

File:

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

src/GenPoly/Box.cc

@@ -27 +27 @@
 #include "Box.h"
 #include "DeclMutator.h"
-#include "Lvalue.h"
+#include "PolyMutator.h"
 #include "FindFunction.h"
-#include "PolyMutator.h"
 #include "ScopedSet.h"
 #include "ScrubTyVars.h"
@@ -56 +55 @@
 #include "Common/UniqueName.h"
 #include "Common/utility.h"
+
+#include "CodeGen/OperatorTable.h"
 
 #include "InitTweak/InitTweak.h"
@@ -203 +204 @@
                 };
 
-                /// 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.
+                /// 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
                 class Pass3 final : public PolyMutator {
                   public:
@@ -211 +212 @@
                         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;
@@ -570 +569 @@
                         // To compound the issue, the right side can be *x, etc. because of lvalue-returning functions
                         if ( UntypedExpr * assign = dynamic_cast< UntypedExpr * >( commaExpr->get_arg1() ) ) {
-                                if ( InitTweak::isAssignment( InitTweak::getFunctionName( assign ) ) ) {
+                                if ( CodeGen::isAssignment( InitTweak::getFunctionName( assign ) ) ) {
                                         assert( assign->get_args().size() == 2 );
                                         if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * > ( assign->get_args().back() ) ) {
@@ -610 +609 @@
                                                 }
                                         } else {
-                                                throw SemanticError( "Cannot pass non-struct type for generic struct" );
+                                                throw SemanticError( "Cannot pass non-struct type for generic struct: ", argBaseType );
                                         }
                                 }
@@ -758 +757 @@
                         assertf( arg->has_result(), "arg does not have result: %s", toString( arg ).c_str() );
                         if ( isPolyType( param, exprTyVars ) ) {
-                                Type * newType = arg->get_result()->clone();
-                                if ( env ) env->apply( newType );
-                                std::auto_ptr<Type> manager( newType );
-                                if ( isPolyType( newType ) ) {
+                                if ( isPolyType( arg->get_result() ) ) {
                                         // if the argument's type is polymorphic, we don't need to box again!
                                         return;
-                                } else if ( arg->get_result()->get_lvalue() ) {
-                                        // argument expression may be CFA lvalue, but not C lvalue -- apply generalizedLvalue transformations.
-                                        arg =  generalizedLvalue( new AddressExpr( arg ) );
+                                } else if ( arg->get_result()->get_lvalue() ) {  // xxx - is this still right??
+                                // xxx - dynamic_cast<ReferenceType *>( arg->get_result() )??
+                                        // 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 );
+                                        }
                                         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.
@@ -1025 +1027 @@
                                                 } // if
                                                 if ( baseType1 || baseType2 ) {
+                                                        delete ret->get_result();
                                                         ret->set_result( appExpr->get_result()->clone() );
                                                         if ( appExpr->get_env() ) {
@@ -1038 +1041 @@
                                                 assert( ! appExpr->get_args().empty() );
                                                 if ( isPolyType( appExpr->get_result(), scopeTyVars, env ) ) {
+                                                        // remove dereference from polymorphic types since they are boxed.
                                                         Expression *ret = appExpr->get_args().front();
+                                                        // fix expr type to remove pointer
                                                         delete ret->get_result();
                                                         ret->set_result( appExpr->get_result()->clone() );
@@ -1128 +1133 @@
 
                         assert( appExpr->get_function()->has_result() );
-                        PointerType *pointer = safe_dynamic_cast< PointerType *>( appExpr->get_function()->get_result() );
-                        FunctionType *function = safe_dynamic_cast< FunctionType *>( pointer->get_base() );
+                        FunctionType * function = getFunctionType( appExpr->get_function()->get_result() );
+                        assertf( function, "ApplicationExpr has non-function type: %s", toString( appExpr->get_function()->get_result() ).c_str() );
 
                         if ( Expression *newExpr = handleIntrinsics( appExpr ) ) {
@@ -1206 +1211 @@
                                                         if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr->get_args().front() ) ) {
                                                                 assert( appExpr->get_function()->has_result() );
-                                                                PointerType *pointer = safe_dynamic_cast< PointerType *>( appExpr->get_function()->get_result() );
-                                                                FunctionType *function = safe_dynamic_cast< FunctionType *>( pointer->get_base() );
+                                                                FunctionType *function = getFunctionType( appExpr->get_function()->get_result() );
+                                                                assert( function );
                                                                 needs = needsAdapter( function, scopeTyVars );
                                                         } // if
@@ -1216 +1221 @@
                         // isPolyType check needs to happen before mutating addrExpr arg, so pull it forward
                         // out of the if condition.
+                        addrExpr->set_arg( mutateExpression( addrExpr->get_arg() ) );
+                        // ... but must happen after mutate, since argument might change (e.g. intrinsic *?, ?[?]) - re-evaluate above comment
                         bool polytype = isPolyType( addrExpr->get_arg()->get_result(), scopeTyVars, env );
-                        addrExpr->set_arg( mutateExpression( addrExpr->get_arg() ) );
                         if ( polytype || needs ) {
                                 Expression *ret = addrExpr->get_arg();
@@ -1284 +1290 @@
                                 if ( adaptersDone.find( mangleName ) == adaptersDone.end() ) {
                                         std::string adapterName = makeAdapterName( mangleName );
-                                        paramList.push_front( new ObjectDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), 0 ) );
+                                        // adapter may not be used in body, pass along with unused attribute.
+                                        paramList.push_front( new ObjectDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), 0, { new Attribute( "unused" ) } ) );
                                         adaptersDone.insert( adaptersDone.begin(), mangleName );
                                 }
@@ -1390 +1397 @@
                         std::list< DeclarationWithType *>::iterator last = funcType->get_parameters().begin();
                         std::list< DeclarationWithType *> inferredParams;
-                        ObjectDecl newObj( "", Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0 );
+                        // size/align/offset parameters may not be used in body, pass along with unused attribute.
+                        ObjectDecl newObj( "", Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0,
+                                           { new Attribute( "unused" ) } );
                         ObjectDecl newPtr( "", Type::StorageClasses(), LinkageSpec::C, 0,
                                            new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) ), 0 );
@@ -1413 +1422 @@
                                 for ( std::list< DeclarationWithType *>::iterator assert = (*tyParm)->get_assertions().begin(); assert != (*tyParm)->get_assertions().end(); ++assert ) {
 //      *assert = (*assert)->acceptMutator( *this );
+                                        // assertion parameters may not be used in body, pass along with unused attribute.
+                                        (*assert)->get_attributes().push_back( new Attribute( "unused" ) );
                                         inferredParams.push_back( *assert );
                                 }
@@ -1749 +1760 @@
 
                 Expression *PolyGenericCalculator::mutate( SizeofExpr *sizeofExpr ) {
-                        Type *ty = sizeofExpr->get_isType() ? sizeofExpr->get_type() : sizeofExpr->get_expr()->get_result();
+                        Type *ty = sizeofExpr->get_type();
                         if ( findGeneric( ty ) ) {
                                 Expression *ret = new NameExpr( sizeofName( mangleType( ty ) ) );
@@ -1759 +1770 @@
 
                 Expression *PolyGenericCalculator::mutate( AlignofExpr *alignofExpr ) {
-                        Type *ty = alignofExpr->get_isType() ? alignofExpr->get_type() : alignofExpr->get_expr()->get_result();
+                        Type *ty = alignofExpr->get_type();
                         if ( findGeneric( ty ) ) {
                                 Expression *ret = new NameExpr( alignofName( mangleType( ty ) ) );
@@ -1869 +1880 @@
                 }
 
-                /// 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;