Changes in / [36ebd03:4040425]

Location:

src

Files:

• GenPoly/Box.cc (modified) (5 diffs)
• GenPoly/DeclMutator.cc (modified) (8 diffs)
• GenPoly/DeclMutator.h (modified) (1 diff)
• SynTree/Constant.cc (modified) (2 diffs)
• SynTree/Constant.h (modified) (1 diff)

src/GenPoly/Box.cc

@@ -22 +22 @@
 
 #include "Box.h"
-#include "DeclMutator.h"
 #include "InstantiateGeneric.h"
 #include "PolyMutator.h"
@@ -55 +54 @@
                 FunctionType *makeAdapterType( FunctionType *adaptee, const TyVarMap &tyVars );
 
-                /// Adds layout-generation functions to polymorphic types
-                class LayoutFunctionBuilder : public DeclMutator {
-                        unsigned int functionNesting;  // current level of nested functions
-                public:
-                        LayoutFunctionBuilder() : functionNesting( 0 ) {}
-
-                        virtual DeclarationWithType *mutate( FunctionDecl *functionDecl );
-                        virtual Declaration *mutate( StructDecl *structDecl );
-                        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 {
@@ -171 +159 @@
         } // anonymous namespace
 
+        void printAllNotBuiltin( const std::list< Declaration *>& translationUnit, std::ostream &os ) {
+                for ( std::list< Declaration *>::const_iterator i = translationUnit.begin(); i != translationUnit.end(); ++i ) {
+                        if ( ! LinkageSpec::isBuiltin( (*i)->get_linkage() ) ) {
+                                (*i)->print( os );
+                                os << std::endl;
+                        } // if
+                } // for
+        }
+
         /// version of mutateAll with special handling for translation unit so you can check the end of the prelude when debugging
         template< typename MutatorType >
@@ -198 +195 @@
 
         void box( std::list< Declaration *>& translationUnit ) {
-                LayoutFunctionBuilder layoutBuilder;
                 Pass1 pass1;
                 Pass2 pass2;
                 MemberExprFixer memberFixer;
                 Pass3 pass3;
-                layoutBuilder.mutateDeclarationList( translationUnit );
                 mutateTranslationUnit/*All*/( translationUnit, pass1 );
                 mutateTranslationUnit/*All*/( translationUnit, pass2 );
@@ -211 +206 @@
         }
 
-        ////////////////////////////////// LayoutFunctionBuilder ////////////////////////////////////////////
-
-        DeclarationWithType *LayoutFunctionBuilder::mutate( FunctionDecl *functionDecl ) {
-                functionDecl->set_functionType( maybeMutate( functionDecl->get_functionType(), *this ) );
-                mutateAll( functionDecl->get_oldDecls(), *this );
-                ++functionNesting;
-                functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) );
-                --functionNesting;
-                return functionDecl;
-        }
-        
-        /// Get a list of type declarations that will affect a layout function
-        std::list< TypeDecl* > takeOtypeOnly( std::list< TypeDecl* > &decls ) {
-                std::list< TypeDecl * > otypeDecls;
-
-                for ( std::list< TypeDecl* >::const_iterator decl = decls.begin(); decl != decls.end(); ++decl ) {
-                        if ( decl->get_kind() == TypeDecl::Any ) {
-                                otypeDecls.push_back( *decl );
-                        }
-                }
-                
-                return otypeDecls;
-        }
-
-        /// Adds parameters for otype layout to a function type
-        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 ) {
-                        layoutFnType->get_parameters().push_back( new ObjectDecl( sizeofName( (*param)->get_base() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
-                }
-        }
-
-        /// Builds a layout function declaration
-        FunctionDecl *buildLayoutFunctionDecl( const std::string &typeName, unsigned int functionNesting, FunctionType *layoutFnType ) {
-                // Routines at global scope marked "static" to prevent multiple definitions is separate translation units
-                // because each unit generates copies of the default routines for each aggregate.
-                FunctionDecl *layoutDecl = new FunctionDecl(
-                        "__layoutof_" + typeName, functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, layoutFnType, new CompoundStmt( noLabels ), true, false );
-                layoutDecl->fixUniqueId();
-                return layoutDecl;
-        }
-
-        /// Makes a unary operation
-        Expression *makeOp( const std::string &name, Expression *arg ) {
-                UntypedExpr *expr = new UntypedExpr( new NameExpr( name ) );
-                expr->get_args().push_back( arg );
-                return expr;
-        }
-
-        /// Makes a binary operation
-        Expression *makeOp( const std::string &name, Expression *lhs, Expression *rhs ) {
-                UntypedExpr *expr = new UntypedExpr( new NameExpr( name ) );
-                expr->get_args().push_back( lhs );
-                expr->get_args().push_back( rhs );
-                return expr;
-        }
-
-        /// Returns the dereference of a local pointer variable
-        Expression *derefVar( ObjectDecl *var ) {
-                return makeOp( "*?", new VariableExpr( var ) );
-        }
-
-        /// makes an if-statement with a single-expression if-block and no then block
-        Statement *makeCond( Expression *cond, Expression *ifPart ) {
-                return new IfStmt( noLabels, cond, new ExprStmt( ifPart ), 0 );
-        }
-
-        /// makes a statement that assigns rhs to lhs if lhs < rhs
-        Statement *makeAssignMax( Expression *lhs, Expression *rhs ) {
-                return makeCond( makeOp( "?<?", lhs, rhs ), makeOp( "?=?", lhs->clone(), rhs->clone() ) );
-        }
-
-        /// makes a statement that aligns lhs to rhs (rhs should be an integer power of two)
-        Statement *makeAlignTo( Expression *lhs, Expression *rhs ) {
-                // check that the lhs is zeroed out to the level of rhs
-                Expression *ifCond = makeOp( "?&?", lhs, makeOp( "?-?", rhs, new ConstantExpr( Constant( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), "1" ) ) ) );
-                // if not aligned, increment to alignment
-                Expression *ifExpr = makeOp( "?+=?", lhs->clone(), makeOp( "?-?", rhs->clone(), ifCond->clone() ) );
-                return makeCond( ifCond, ifExpr );
-        }
-        
-        /// adds an expression to a compound statement
-        void addExpr( CompoundStmt *stmts, Expression *expr ) {
-                stmts->get_kids().push_back( new ExprStmt( noLabels, expr ) );
-        }
-
-        /// adds a statement to a compound statement
-        void addStmt( CompoundStmt *stmts, Statement *stmt ) {
-                stmts->get_kids().push_back( stmt );
-        }
-        
-        virtual Declaration *LayoutFunctionBuilder::mutate( StructDecl *structDecl ) {
-                // do not generate layout function for "empty" tag structs
-                if ( structDecl->get_members().empty() ) return structDecl;
-
-                // get parameters that can change layout, exiting early if none
-                std::list< TypeDecl* > otypeParams = takeOtypeOnly( structDecl->get_parameters() );
-                if ( otypeParams.empty() ) return structDecl;
-
-                // build layout function signature
-                FunctionType *layoutFnType = new FunctionType( Type::Qualifiers(), false );
-                BasicType *sizeAlignType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
-                PointerType *sizeAlignOutType = new PointerType( Type::Qualifiers(), sizeAlignType );
-                
-                ObjectDecl *sizeParam = new ObjectDecl( "__sizeof_" + structDecl->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
-                layoutFnType->get_parameters().push_back( sizeParam );
-                ObjectDecl *alignParam = new ObjectDecl( "__alignof_" + structDecl->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
-                layoutFnType->get_parameters().push_back( alignParam );
-                ObjectDecl *offsetParam = new ObjectDecl( "__offsetof_" + structDecl->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
-                layoutFnType->get_parameters().push_back( offsetParam );
-                addOtypeParams( layoutFnType, otypeParams );
-
-                // build function decl
-                FunctionDecl *layoutDecl = buildLayoutFunctionDecl( structDecl->get_name(), functionNesting, layoutFnType );
-
-                // calculate struct layout in function body
-
-                // initialize size and alignment to 0 and 1 (will have at least one member to re-edit size
-                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "0" ) ) ) );
-                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "1" ) ) ) );
-                unsigned long n_members = 0;
-                bool firstMember = true;
-                for ( std::list< Declaration* >::const_iterator member = structDecl->get_members().begin(); member != structDecl->get_members().end(); ++member ) {
-                        DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( *member );
-                        assert( dwt );
-
-                        if ( firstMember ) {
-                                firstMember = false;
-                        } else {
-                                // make sure all members after the first (automatically aligned at 0) are properly padded for alignment
-                                addStmt( layoutDecl->get_statements(), makeAlignTo( derefVar( sizeParam ), new AlignofExpr( dwt->get_type() ) ) );
-                        }
-                        
-                        // place current size in the current offset index
-                        addExpr( layoutDecl->get_statements(), makeOp( "?=?", makeOp( "?[?]", new VariableExpr( offsetParam ), new ConstantExpr( Constant::from( n_members ) ) ),
-                                                                              derefVar( sizeParam ) ) );
-                        ++n_members;
-
-                        // add member size to current size
-                        addExpr( layoutDecl->get_statements(), makeOp( "?+=?", derefVar( sizeParam ), new SizeofExpr( dwt->get_type() ) ) );
-                        
-                        // take max of member alignment and global alignment
-                        addStmt( layoutDecl->get_statements(), makeAssignMax( derefVar( alignParam ), new AlignofExpr( dwt->get_type() ) ) );
-                }
-                // make sure the type is end-padded to a multiple of its alignment
-                addStmt( layoutDecl->get_statements(), makeAlignTo( derefVar( sizeParam ), derefVar( alignParam ) ) );
-
-                addDeclarationAfter( layoutDecl );
-                return structDecl;
-        }
-        
-        virtual 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() );
-                if ( otypeParams.empty() ) return unionDecl;
-
-                // build layout function signature
-                FunctionType *layoutFnType = new FunctionType( Type::Qualifiers(), false );
-                BasicType *sizeAlignType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
-                PointerType *sizeAlignOutType = new PointerType( Type::Qualifiers(), sizeAlignType );
-                
-                ObjectDecl *sizeParam = new ObjectDecl( "__sizeof_" + unionDecl->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
-                layoutFnType->get_parameters().push_back( sizeParam );
-                ObjectDecl *alignParam = new ObjectDecl( "__alignof_" + unionDecl->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
-                layoutFnType->get_parameters().push_back( alignParam );
-                addOtypeParams( layoutFnType, otypeParams );
-
-                // build function decl
-                FunctionDecl *layoutDecl = buildLayoutFunctionDecl( unionDecl->get_name(), functionNesting, layoutFnType );
-
-                // calculate union layout in function body
-                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "1" ) ) ) );
-                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "1" ) ) ) );
-                for ( std::list< Declaration* >::const_iterator member = unionDecl->get_members().begin(); member != unionDecl->get_members().end(); ++member ) {
-                        DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( *member );
-                        assert( dwt );
-                        
-                        // take max member size and global size
-                        addStmt( layoutDecl->get_statements(), makeAssignMax( derefVar( sizeParam ), new SizeofExpr( dwt->get_type() ) ) );
-                        
-                        // take max of member alignment and global alignment
-                        addStmt( layoutDecl->get_statements(), makeAssignMax( derefVar( alignParam ), new AlignofExpr( dwt->get_type() ) ) );
-                }
-                // make sure the type is end-padded to a multiple of its alignment
-                addStmt( layoutDecl->get_statements(), makeAlignTo( derefVar( sizeParam ), derefVar( alignParam ) ) );
-
-                addDeclarationAfter( layoutDecl );
-                return unionDecl;
-        }
-        
         ////////////////////////////////////////// Pass1 ////////////////////////////////////////////////////
 

src/GenPoly/DeclMutator.cc

@@ -24 +24 @@
         }
 
-        DeclMutator::DeclMutator() : Mutator(), declsToAdd(1), declsToAddAfter(1) {}
+        DeclMutator::DeclMutator() : Mutator(), declsToAdd(1) {}
 
         DeclMutator::~DeclMutator() {}
         
         void DeclMutator::mutateDeclarationList( std::list< Declaration* > &decls ) {
-                for ( std::list< Declaration* >::iterator decl = decls.begin(); ; ++decl ) {
-                        // splice in new declarations after previous decl
-                        decls.splice( decl, declsToAddAfter.back() );
-
-                        if ( decl == decls.end() ) break;
-                        
+                for ( std::list< Declaration* >::iterator decl = decls.begin(); decl != decls.end(); ++decl ) {
                         // run mutator on declaration
                         *decl = maybeMutate( *decl, *this );
@@ -44 +39 @@
 
         void DeclMutator::doBeginScope() {
-                // add new decl lists for inside of scope
+                // add new decl list for inside of scope
                 declsToAdd.resize( declsToAdd.size()+1 );
-                declsToAddAfter.resize( declsToAddAfter.size()+1 );
         }
 
@@ -55 +49 @@
                 newBack->splice( newBack->end(), *back );
                 declsToAdd.pop_back();
-                
-                back = declsToAddAfter.rbegin();
-                newBack = back + 1;
-                newBack->splice( newBack->end(), *back );
-                declsToAddAfter.pop_back();
         }
 
@@ -72 +61 @@
                 stmt = maybeMutate( stmt, *this );
                 // return if no declarations to add
-                if ( declsToAdd.back().empty() && declsToAddAfter.back().empty() ) {
-                        doEndScope();
-                        return stmt;
-                }
+                if ( declsToAdd.back().empty() ) return stmt;
 
                 // otherwise add declarations to new compound statement
@@ -85 +71 @@
                 declsToAdd.back().clear();
 
-                // add mutated statement
+                doEndScope();
+
+                // add mutated statement and return
                 compound->get_kids().push_back( stmt );
-
-                // add declarations after to new compound statement
-                for ( std::list< Declaration* >::iterator decl = declsToAddAfter.back().begin(); decl != declsToAddAfter.back().end(); ++decl ) {
-                        DeclStmt *declStmt = new DeclStmt( noLabels, *decl );
-                        compound->get_kids().push_back( declStmt );
-                }
-                declsToAddAfter.back().clear();
-
-                doEndScope();
                 return compound;
         }
@@ -101 +80 @@
         void DeclMutator::mutateStatementList( std::list< Statement* > &stmts ) {
                 doBeginScope();
-
                 
-                for ( std::list< Statement* >::iterator stmt = stmts.begin(); ; ++stmt ) {
-                        // add any new declarations after the previous statement
-                        for ( std::list< Declaration* >::iterator decl = declsToAddAfter.back().begin(); decl != declsToAddAfter.back().end(); ++decl ) {
-                                DeclStmt *declStmt = new DeclStmt( noLabels, *decl );
-                                stmts.insert( stmt, declStmt );
-                        }
-                        declsToAddAfter.back().clear();
-
-                        if ( stmt == stmts.end() ) break;
-                        
+                for ( std::list< Statement* >::iterator stmt = stmts.begin(); stmt != stmts.end(); ++stmt ) {
                         // run mutator on statement
                         *stmt = maybeMutate( *stmt, *this );
@@ -123 +92 @@
                         declsToAdd.back().clear();
                 }
-                
+
                 doEndScope();
         }
@@ -129 +98 @@
         void DeclMutator::addDeclaration( Declaration *decl ) {
                 declsToAdd.back().push_back( decl );
-        }
-
-        void DeclMutator::addDeclarationAfter( Declaration *decl ) {
-                declsToAddAfter.back().push_back( decl );
         }
 

src/GenPoly/DeclMutator.h

@@ -55 +55 @@
                 /// Add a declaration to the list to be added before the current position
                 void addDeclaration( Declaration* decl );
-                /// Add a declaration to the list to be added after the current position
-                void addDeclarationAfter( Declaration* decl );
         private:
                 /// A stack of declarations to add before the current declaration or statement
                 std::vector< std::list< Declaration* > > declsToAdd;
-                /// A stack of declarations to add after the current declaration or statement
-                std::vector< std::list< Declaration* > > declsToAddAfter;
         };
 } // namespace

src/SynTree/Constant.cc

@@ -16 +16 @@
 #include <iostream>
 #include <list>
-#include <string>
 
 #include "Constant.h"
@@ -29 +28 @@
 
 Constant::~Constant() { delete type; }
-
-Constant Constant::from( int i ) {
-        return Constant( new BasicType( Type::Qualifiers(), BasicType::SignedInt ), std::to_string( i ) );
-}
-
-Constant Constant::from( unsigned long i ) {
-        return Constant( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), std::to_string( i ) );
-}
-
-Constant Constant::from( double d ) {
-        return Constant( new BasicType( Type::Qualifiers(), BasicType::Double ), std::to_string( d ) );
-}
 
 Constant *Constant::clone() const { assert( false ); return 0; }

src/SynTree/Constant.h

@@ -32 +32 @@
         void set_value( std::string newValue ) { value = newValue; }
 
-        /// generates an integer constant of the given int
-        static Constant from( int i );
-        /// generates an integer constant of the given unsigned long int
-        static Constant from( unsigned long i );
-        /// generates a floating point constant of the given double
-        static Constant from( double d );
-
         virtual Constant *clone() const;
         virtual void accept( Visitor &v ) { v.visit( this ); }