Changes in src/GenPoly/Box.cc [cb4c607:2e3a379]

File:

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

src/GenPoly/Box.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Feb  5 16:45:07 2016
-// Update Count     : 286
+// Last Modified By : Rob Schluntz
+// Last Modified On : Tue May 03 16:44:47 2016
+// Update Count     : 295
 //
 
@@ -133 +133 @@
                         Value *lookup( Key *key, const std::list< TypeExpr* >& params ) const {
                                 TypeList typeList( params );
-                                
+
                                 // scan scopes for matches to the key
                                 for ( typename InnerMap::const_iterator insts = instantiations.find( key ); insts != instantiations.end(); insts = instantiations.findNext( insts, key ) ) {
@@ -160 +160 @@
                         virtual Declaration *mutate( UnionDecl *unionDecl );
                 };
-                
+
                 /// Replaces polymorphic return types with out-parameters, replaces calls to polymorphic functions with adapter calls as needed, and adds appropriate type variables to the function call
                 class Pass1 : public PolyMutator {
@@ -208 +208 @@
                         ResolvExpr::TypeMap< DeclarationWithType > scopedAssignOps;  ///< Currently known assignment operators
                         ScopedMap< std::string, DeclarationWithType* > adapters;     ///< Set of adapter functions in the current scope
-                        
+
                         DeclarationWithType *retval;
                         bool useRetval;
@@ -226 +226 @@
                         virtual Type *mutate( PointerType *pointerType );
                         virtual Type *mutate( FunctionType *funcType );
-                        
+
                   private:
                         void addAdapters( FunctionType *functionType );
@@ -297 +297 @@
                         /// Exits the type-variable scope
                         void endTypeScope();
-                        
+
                         ScopedSet< std::string > knownLayouts;          ///< Set of generic type layouts known in the current scope, indexed by sizeofName
                         ScopedSet< std::string > knownOffsets;          ///< Set of non-generic types for which the offset array exists in the current scope, indexed by offsetofName
@@ -351 +351 @@
                 PolyGenericCalculator polyCalculator;
                 Pass3 pass3;
-                
+
                 layoutBuilder.mutateDeclarationList( translationUnit );
                 mutateTranslationUnit/*All*/( translationUnit, pass1 );
@@ -370 +370 @@
                 return functionDecl;
         }
-        
+
         /// Get a list of type declarations that will affect a layout function
         std::list< TypeDecl* > takeOtypeOnly( std::list< TypeDecl* > &decls ) {
@@ -380 +380 @@
                         }
                 }
-                
+
                 return otypeDecls;
         }
@@ -387 +387 @@
         void addOtypeParams( FunctionType *layoutFnType, std::list< TypeDecl* > &otypeParams ) {
                 BasicType sizeAlignType( Type::Qualifiers(), BasicType::LongUnsignedInt );
-                
+
                 for ( std::list< TypeDecl* >::const_iterator param = otypeParams.begin(); param != otypeParams.end(); ++param ) {
                         TypeInstType paramType( Type::Qualifiers(), (*param)->get_name(), *param );
@@ -444 +444 @@
                 return makeCond( ifCond, ifExpr );
         }
-        
+
         /// adds an expression to a compound statement
         void addExpr( CompoundStmt *stmts, Expression *expr ) {
@@ -454 +454 @@
                 stmts->get_kids().push_back( stmt );
         }
-        
+
         Declaration *LayoutFunctionBuilder::mutate( StructDecl *structDecl ) {
                 // do not generate layout function for "empty" tag structs
@@ -467 +467 @@
                 BasicType *sizeAlignType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
                 PointerType *sizeAlignOutType = new PointerType( Type::Qualifiers(), sizeAlignType );
-                
+
                 ObjectDecl *sizeParam = new ObjectDecl( sizeofName( structDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
                 layoutFnType->get_parameters().push_back( sizeParam );
@@ -497 +497 @@
                                 addStmt( layoutDecl->get_statements(), makeAlignTo( derefVar( sizeParam ), new AlignofExpr( memberType->clone() ) ) );
                         }
-                        
+
                         // place current size in the current offset index
-                        addExpr( layoutDecl->get_statements(), makeOp( "?=?", makeOp( "?[?]", new VariableExpr( offsetParam ), new ConstantExpr( Constant::from_ulong( n_members ) ) ),
+                        addExpr( layoutDecl->get_statements(), makeOp( "?=?", makeOp( "?[?]", new VariableExpr( offsetParam ), new ConstantExpr( Constant::from( n_members ) ) ),
                                                                               derefVar( sizeParam ) ) );
                         ++n_members;
@@ -505 +505 @@
                         // add member size to current size
                         addExpr( layoutDecl->get_statements(), makeOp( "?+=?", derefVar( sizeParam ), new SizeofExpr( memberType->clone() ) ) );
-                        
+
                         // take max of member alignment and global alignment
                         addStmt( layoutDecl->get_statements(), makeAssignMax( derefVar( alignParam ), new AlignofExpr( memberType->clone() ) ) );
@@ -515 +515 @@
                 return structDecl;
         }
-        
+
         Declaration *LayoutFunctionBuilder::mutate( UnionDecl *unionDecl ) {
                 // do not generate layout function for "empty" tag unions
                 if ( unionDecl->get_members().empty() ) return unionDecl;
-                
+
                 // get parameters that can change layout, exiting early if none
                 std::list< TypeDecl* > otypeParams = takeOtypeOnly( unionDecl->get_parameters() );
@@ -528 +528 @@
                 BasicType *sizeAlignType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
                 PointerType *sizeAlignOutType = new PointerType( Type::Qualifiers(), sizeAlignType );
-                
+
                 ObjectDecl *sizeParam = new ObjectDecl( sizeofName( unionDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
                 layoutFnType->get_parameters().push_back( sizeParam );
@@ -545 +545 @@
                         assert( dwt );
                         Type *memberType = dwt->get_type();
-                        
+
                         // take max member size and global size
                         addStmt( layoutDecl->get_statements(), makeAssignMax( derefVar( sizeParam ), new SizeofExpr( memberType->clone() ) ) );
-                        
+
                         // take max of member alignment and global alignment
                         addStmt( layoutDecl->get_statements(), makeAssignMax( derefVar( alignParam ), new AlignofExpr( memberType->clone() ) ) );
@@ -558 +558 @@
                 return unionDecl;
         }
-        
+
         ////////////////////////////////////////// Pass1 ////////////////////////////////////////////////////
 
@@ -619 +619 @@
                         return 0;
                 }
-                
+
                 /// returns T if the given declaration is: (*?=?)(T *, T) for some type T (return not checked, but maybe should be), NULL otherwise
                 /// Only picks assignments where neither parameter is cv-qualified
@@ -631 +631 @@
                                                 Type *paramType2 = funType->get_parameters().back()->get_type();
                                                 if ( paramType2->get_qualifiers() != defaultQualifiers ) return 0;
-                                                
+
                                                 if ( PointerType *pointerType = dynamic_cast< PointerType* >( paramType1 ) ) {
                                                         Type *baseType1 = pointerType->get_base();
@@ -784 +784 @@
                                                 arg++;
                                         } else {
-                                                throw SemanticError( "unbound type variable in application ", appExpr );
+                                                /// xxx - should this be an assertion?
+                                                throw SemanticError( "unbound type variable: " + tyParm->first + " in application ", appExpr );
                                         } // if
                                 } // if
@@ -803 +804 @@
                                 passArgTypeVars( appExpr, polyRetType, concRetType, arg, exprTyVars, seenTypes );
                         }
-                        
+
                         // add type information args for presently unseen types in parameter list
                         for ( ; fnParm != funcType->get_parameters().end() && fnArg != appExpr->get_args().end(); ++fnParm, ++fnArg ) {
@@ -882 +883 @@
                         assert( env );
                         Type *concrete = replaceWithConcrete( appExpr, polyType );
-                        // add out-parameter for return value   
+                        // add out-parameter for return value
                         return addRetParam( appExpr, function, concrete, arg );
                 }
@@ -910 +911 @@
                                 } else if ( arg->get_results().front()->get_isLvalue() ) {
                                         // 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() ) );
@@ -1291 +1293 @@
                         } else if ( needsAdapter( function, scopeTyVars ) ) {
                                 // std::cerr << "needs adapter: ";
-                                // for ( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) {
-                                //      std::cerr << i->first << " ";
-                                // }
-                                // std::cerr << "\n";
+                                // printTyVarMap( std::cerr, scopeTyVars );
+                                // std::cerr << *env << std::endl;
                                 // change the application so it calls the adapter rather than the passed function
                                 ret = applyAdapter( appExpr, function, arg, scopeTyVars );
@@ -1345 +1345 @@
                                 } // if
                         } // if
+                        // isPolyType check needs to happen before mutating addrExpr arg, so pull it forward
+                        // out of the if condition.
+                        bool polytype = isPolyType( addrExpr->get_arg()->get_results().front(), scopeTyVars, env );
                         addrExpr->set_arg( mutateExpression( addrExpr->get_arg() ) );
-                        if ( isPolyType( addrExpr->get_arg()->get_results().front(), scopeTyVars, env ) || needs ) {
+                        if ( polytype || needs ) {
                                 Expression *ret = addrExpr->get_arg();
                                 delete ret->get_results().front();
@@ -1366 +1369 @@
                         return new VariableExpr( functionObj );
                 }
-                
+
                 Statement * Pass1::mutate( ReturnStmt *returnStmt ) {
                         if ( retval && returnStmt->get_expr() ) {
@@ -1886 +1889 @@
                                 }
                         }
-                        
+
                         Type *ret = Mutator::mutate( funcType );
 
@@ -1905 +1908 @@
 
                                         std::list<Expression*> designators;
-                                        objectDecl->set_init( new SingleInit( alloc, designators ) );
+                                        objectDecl->set_init( new SingleInit( alloc, designators, false ) ); // not constructed
                                 }
                         }
@@ -1946 +1949 @@
                         return derefdVar;
                 }
-                
+
                 Expression *PolyGenericCalculator::mutate( MemberExpr *memberExpr ) {
                         // mutate, exiting early if no longer MemberExpr
@@ -2066 +2069 @@
                                 if ( n_members == 0 ) {
                                         // all empty structs have the same layout - size 1, align 1
-                                        makeVar( sizeofName( typeName ), layoutType, new SingleInit( new ConstantExpr( Constant::from_ulong( 1 ) ) ) );
-                                        makeVar( alignofName( typeName ), layoutType->clone(), new SingleInit( new ConstantExpr( Constant::from_ulong( 1 ) ) ) );
+                                        makeVar( sizeofName( typeName ), layoutType, new SingleInit( new ConstantExpr( Constant::from( (unsigned long)1 ) ) ) );
+                                        makeVar( alignofName( typeName ), layoutType->clone(), new SingleInit( new ConstantExpr( Constant::from( (unsigned long)1 ) ) ) );
                                         // NOTE zero-length arrays are forbidden in C, so empty structs have no offsetof array
                                 } else {
                                         ObjectDecl *sizeVar = makeVar( sizeofName( typeName ), layoutType );
                                         ObjectDecl *alignVar = makeVar( alignofName( typeName ), layoutType->clone() );
-                                        ObjectDecl *offsetVar = makeVar( offsetofName( typeName ), new ArrayType( Type::Qualifiers(), layoutType->clone(), new ConstantExpr( Constant::from_int( n_members ) ), false, false ) );
+                                        ObjectDecl *offsetVar = makeVar( offsetofName( typeName ), new ArrayType( Type::Qualifiers(), layoutType->clone(), new ConstantExpr( Constant::from( n_members ) ), false, false ) );
 
                                         // generate call to layout function
@@ -2144 +2147 @@
                         Type *ty = offsetofExpr->get_type();
                         if ( ! findGeneric( ty ) ) return offsetofExpr;
-                        
+
                         if ( StructInstType *structType = dynamic_cast< StructInstType* >( ty ) ) {
                                 // replace offsetof expression by index into offset array
@@ -2191 +2194 @@
 
                                         // build the offset array and replace the pack with a reference to it
-                                        ObjectDecl *offsetArray = makeVar( offsetName, new ArrayType( Type::Qualifiers(), offsetType, new ConstantExpr( Constant::from_ulong( baseMembers.size() ) ), false, false ),
+                                        ObjectDecl *offsetArray = makeVar( offsetName, new ArrayType( Type::Qualifiers(), offsetType, new ConstantExpr( Constant::from( baseMembers.size() ) ), false, false ),
                                                         new ListInit( inits ) );
                                         ret = new VariableExpr( offsetArray );