Changes in / [f678663e:093f1a0]

Location:

src

Files:

• ControlStruct/LabelFixer.cc (modified) (6 diffs)
• ControlStruct/LabelFixer.h (modified) (3 diffs)
• GenPoly/Box.cc (modified) (7 diffs)
• ResolvExpr/Cost.h (modified) (2 diffs)
• main.cc (modified) (3 diffs)

src/ControlStruct/LabelFixer.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Rob Schluntz
-// Last Modified On : Tue Jul 28 13:32:43 2015
-// Update Count     : 156
+// Last Modified On : Wed Jul 08 12:36:46 2015
+// Update Count     : 145
 //
 
@@ -27 +27 @@
 
 namespace ControlStruct {
+        LabelFixer::Entry::Entry( Statement *to, Statement *from ) : definition ( to ) {
+                if ( from != 0 ) {
+                        UsageLoc loc; loc.stmt = from;
+                        usage.push_back( loc );
+                }
+        }
+
+        LabelFixer::Entry::Entry( Statement *to, Expression *from ) : definition ( to ) {
+                if ( from != 0 ) {
+                        UsageLoc loc; loc.expr = from;
+                        usage.push_back( loc );
+                }
+        }
+
+
         bool LabelFixer::Entry::insideLoop() {
                 return ( dynamic_cast< ForStmt * > ( definition ) ||
                         dynamic_cast< WhileStmt * > ( definition )  );
+        }
+
+        void LabelFixer::Entry::UsageLoc::accept( Visitor & visitor ) {
+                if ( dynamic_cast< Statement * >( stmt ) ) {
+                        stmt->accept( visitor );
+                } else {
+                        expr->accept( visitor );
+                }
         }
 
@@ -54 +77 @@
         // prune to at most one label definition for each statement
         void LabelFixer::visit( Statement *stmt ) {
+                currentStatement = stmt;
                 std::list< Label > &labels = stmt->get_labels();
 
@@ -59 +83 @@
                         // only remember one label for each statement
                         Label current = setLabelsDef( labels, stmt );
+                        labels.clear();
+                        labels.push_front( current );
                 } // if
         }
@@ -104 +130 @@
                         }       else {
                                 // used previously, but undefined until now -> link with this entry
-                                delete labelTable[ *i ];
+                                Entry * oldEntry = labelTable[ *i ];
+                                e->add_uses( *oldEntry );
                                 labelTable[ *i ] = e;
                         } // if
@@ -114 +141 @@
         }
 
-        // A label was used, add it ot the table if it isn't already there
+        // Remember all uses of a label.
         template< typename UsageNode >
         void LabelFixer::setLabelsUsg( Label orgValue, UsageNode *use ) {
                 assert( use != 0 );
 
-                // add label with an unknown origin
-                if ( labelTable.find( orgValue ) == labelTable.end() ) {
-                        labelTable[ orgValue ] = new Entry( 0 );
-                }
-        }
-
-        // Builds a table that maps a label to its defining statement.
+                if ( labelTable.find( orgValue ) != labelTable.end() ) {
+                        // the label has been defined or used before
+                        labelTable[ orgValue ]->add_use( use );
+                } else {
+                        labelTable[ orgValue ] = new Entry( 0, use );
+                }
+        }
+
+        class LabelGetter : public Visitor {
+                public:
+                LabelGetter( Label &label ) : label( label ) {}
+
+                virtual void visit( BranchStmt * branchStmt ) {
+                        label = branchStmt->get_target();
+                }
+
+                virtual void visit( UntypedExpr * untyped ) {
+                        NameExpr * name = dynamic_cast< NameExpr * >( untyped->get_function() );
+                        assert( name );
+                        assert( name->get_name() == "&&" );
+                        NameExpr * arg = dynamic_cast< NameExpr * >( untyped->get_args().front() );
+                        assert( arg );
+                        label = arg->get_name();
+                }               
+
+                private:
+                        Label &label;
+        };
+
+        class LabelSetter : public Visitor {
+                public:
+                LabelSetter( Label label ) : label( label ) {}
+
+                virtual void visit( BranchStmt * branchStmt ) {
+                        branchStmt->set_target( label );
+                }
+
+                virtual void visit( UntypedExpr * untyped ) {
+                        NameExpr * name = dynamic_cast< NameExpr * >( untyped->get_function() );
+                        assert( name );
+                        assert( name->get_name() == "&&" );
+                        NameExpr * arg = dynamic_cast< NameExpr * >( untyped->get_args().front() );
+                        assert( arg );
+                        arg->set_name( label );
+                }
+
+        private:
+                Label label;
+        };
+
+        // Ultimately builds a table that maps a label to its defining statement.
+        // In the process, 
         std::map<Label, Statement * > *LabelFixer::resolveJumps() throw ( SemanticError ) {
+                std::map< Statement *, Entry * > def_us;
+
+                // combine the entries for all labels that target the same location
+                for ( std::map< Label, Entry *>::iterator i = labelTable.begin(); i != labelTable.end(); ++i ) {
+                        Entry *e = i->second;
+
+                        if ( def_us.find ( e->get_definition() ) == def_us.end() ) {
+                                def_us[ e->get_definition() ] = e;
+                        } else if ( e->used() ) {
+                                def_us[ e->get_definition() ]->add_uses( *e );
+                        }
+                }
+
+                // create a unique label for each target location. 
+                for ( std::map< Statement *, Entry * >::iterator i = def_us.begin(); i != def_us.end(); ++i ) {
+                        Statement *to = (*i).first;
+                        Entry * entry = (*i).second;
+                        std::list< Entry::UsageLoc > &from = entry->get_uses();
+
+                        // no label definition found
+                        if ( to == 0 ) {
+                                Label undef;
+                                LabelGetter getLabel( undef );
+                                from.back().accept( getLabel );
+                                // Label undef = getLabel( from.back()->get_target() );
+                                throw SemanticError ( "'" + undef + "' label not defined");
+                        } // if
+
+                        // generate a new label, and attach it to its defining statement as the only label on that statement
+                        Label finalLabel = generator->newLabel( to->get_labels().back() );
+                        entry->set_label( finalLabel );
+
+                        to->get_labels().clear();
+                        to->get_labels().push_back( finalLabel );
+
+                        // redirect each of the source branch statements to the new target label
+                        for ( std::list< Entry::UsageLoc >::iterator j = from.begin(); j != from.end(); ++j ) {
+                                LabelSetter setLabel( finalLabel );
+                                (*j).accept( setLabel );
+                                // setLabel( *j, finalLabel );
+
+                                // BranchStmt *jump = *j;
+                                // assert( jump != 0 );
+                                // jump->set_target( finalLabel );
+                        } // for
+                } // for
+
+                // create a table where each label maps to its defining statement
                 std::map< Label, Statement * > *ret = new std::map< Label, Statement * >();
-                for ( std::map< Label, Entry * >::iterator i = labelTable.begin(); i != labelTable.end(); ++i ) {
-                        if ( ! i->second->defined() ) {
-                                throw SemanticError( "Use of undefined label: " + i->first );
-                        }
-                        (*ret)[ i->first ] = i->second->get_definition();
+                for ( std::map< Statement *, Entry * >::iterator i = def_us.begin(); i != def_us.end(); ++i ) {
+                        (*ret)[ (*i).second->get_label() ] = (*i).first;
                 }
 

src/ControlStruct/LabelFixer.h

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Rob Schluntz
-// Last Modified On : Tue Jul 28 13:09:02 2015
-// Update Count     : 31
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Jun 29 17:24:39 2015
+// Update Count     : 29
 //
 
@@ -63 +63 @@
                 class Entry {
                         public:
+                        union UsageLoc {
+                                Statement * stmt;
+                                Expression * expr;
+
+                                void accept( Visitor &visitor );
+                        };
+
                         Entry( Statement *to ) : definition( to ) {}
+                        Entry( Statement *to, Statement *from );
+                        Entry( Statement *to, Expression *from );
+                        bool used() { return ( usage.empty() ); }
                         bool defined() { return ( definition != 0 ); }
                         bool insideLoop();
@@ -73 +83 @@
                         void set_definition( Statement *def ) { definition = def; }
 
+                        std::list< UsageLoc > &get_uses() { return usage; }
+                        void add_use( Statement *use ) {
+                                UsageLoc loc;
+                                loc.stmt = use;
+                                usage.push_back( loc ); 
+                        }
+                        void add_use( Expression *use ) {
+                                UsageLoc loc;
+                                loc.expr = use;
+                                usage.push_back( loc );                                 
+                        }
+
+                        void add_uses ( Entry &other ) { usage.insert( usage.end(), other.usage.begin(), other.usage.end() ); }
                   private:
                         Label label;  
                         Statement *definition;
+                        std::list<UsageLoc> usage;
                 };
                   
                 std::map < Label, Entry *> labelTable;
                 LabelGenerator *generator;
+                Statement * currentStatement;
         };
 } // namespace ControlStruct

src/GenPoly/Box.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Rob Schluntz
-// Last Modified On : Thu Jul 30 14:35:40 2015
-// Update Count     : 54
+// Last Modified On : Wed Jun 24 16:19:07 2015
+// Update Count     : 10
 //
 
@@ -527 +527 @@
 
                 void Pass1::passAdapters( ApplicationExpr *appExpr, FunctionType *functionType, const TyVarMap &exprTyVars ) {
-                        // collect a list of function types passed as parameters or implicit parameters (assertions)
                         std::list< DeclarationWithType *> &paramList = functionType->get_parameters();
                         std::list< FunctionType *> functions;
@@ -538 +537 @@
                                 findFunction( (*arg)->get_type(), functions, exprTyVars, needsAdapter );
                         } // for
-
-                        // parameter function types for which an appropriate adapter has been generated.
-                        // we cannot use the types after applying substitutions, since two different 
-                        // parameter types may be unified to the same type
                         std::set< std::string > adaptersDone;
-
                         for ( std::list< FunctionType *>::iterator funType = functions.begin(); funType != functions.end(); ++funType ) {
                                 FunctionType *realFunction = (*funType)->clone();
+                                assert( env );
+                                env->apply( realFunction );
+
                                 std::string mangleName = SymTab::Mangler::mangle( realFunction );
-
-                                // only attempt to create an adapter or pass one as a parameter if we haven't 
-                                // already done so for this pre-substitution parameter function type.
                                 if ( adaptersDone.find( mangleName ) == adaptersDone.end() ) {
-                                        std::string mangleName = SymTab::Mangler::mangle( realFunction );
-                                        adaptersDone.insert( adaptersDone.begin(), mangleName );
-                                        
-                                        // apply substitution to type variables to figure out what the 
-                                        // adapter's type should look like
-                                        assert( env );
-                                        env->apply( realFunction );
-                                        mangleName = SymTab::Mangler::mangle( realFunction );
                                         AdapterMap & adapters = Pass1::adapters.top();
                                         AdapterMap::iterator adapter = adapters.find( mangleName );
@@ -569 +555 @@
                                                 continue;
                                         } else if ( adapter == adapters.end() ) {
-                                                // adapter has not been created yet in the current scope, so define it
                                                 FunctionDecl *newAdapter = makeAdapter( *funType, realFunction, mangleName, exprTyVars );
                                                 adapter = adapters.insert( adapters.begin(), std::pair< std::string, FunctionDecl *>( mangleName, newAdapter ) );
@@ -575 +560 @@
                                         } // if
                                         assert( adapter != adapters.end() );
-
-                                        // add the appropriate adapter as a parameter
                                         appExpr->get_args().push_front( new VariableExpr( adapter->second ) );
+                                        // appExpr->get_args().push_front( new NameExpr( makeAdapterName ( mangleName ) ) );
+                                        adaptersDone.insert( adaptersDone.begin(), mangleName );
                                 } // if
                         } // for
@@ -895 +880 @@
 
                 void Pass1::doBeginScope() {
-                        // actually, maybe this could (should?) push
-                        // a copy of the current map
                         adapters.push(AdapterMap());
                 }
@@ -1068 +1051 @@
                         if ( ObjectDecl *objectDecl = dynamic_cast< ObjectDecl *>( declStmt->get_decl() ) ) {
                                 if ( isPolyVal( objectDecl->get_type(), scopeTyVars ) ) {
-                                        // change initialization of a polymorphic value object
-                                        // to allocate storage with alloca
                                         TypeInstType *typeInst = dynamic_cast< TypeInstType *>( objectDecl->get_type() );
                                         assert( typeInst );
                                         UntypedExpr *alloc = new UntypedExpr( new NameExpr( "__builtin_alloca" ) );
                                         alloc->get_args().push_back( new NameExpr( typeInst->get_name() ) );
-
-                                        delete objectDecl->get_init();
-
-                                        std::list<Expression*> designators;
-                                        objectDecl->set_init( new SingleInit( alloc, designators ) );
+                                        UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
+                                        assign->get_args().push_back( new VariableExpr( objectDecl ) );
+                                        assign->get_args().push_back( alloc );
+                                        stmtsToAddAfter.push_back( new ExprStmt( noLabels, assign ) );
                                 }
                         }

src/ResolvExpr/Cost.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 09:39:50 2015
-// Last Modified By : Rob Schluntz
-// Last Modified On : Wed Jul 22 16:43:10 2015
-// Update Count     : 4
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun May 17 09:42:04 2015
+// Update Count     : 3
 //
 
@@ -56 +56 @@
 
         inline void Cost::incPoly( int inc ) {
-                poly += inc;
+                unsafe += inc;
         }
 
         inline void Cost::incSafe( int inc ) {
-                safe += inc;
+                unsafe += inc;
         }
 

src/main.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Fri May 15 23:12:02 2015
-// Last Modified By : Rob Schluntz
-// Last Modified On : Thu Jul 30 16:08:18 2015
-// Update Count     : 167
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Jul 30 15:36:41 2015
+// Update Count     : 146
 //
 
@@ -228 +228 @@
                 // add the assignment statement after the 
                 // initialization of a type parameter
+                OPTPRINT( "tweak" )
+                InitTweak::tweak( translationUnit );
                 OPTPRINT( "validate" )
                 SymTab::validate( translationUnit, symtabp );
@@ -249 +251 @@
                 OPTPRINT( "fixNames" ) 
                 CodeGen::fixNames( translationUnit );
-                OPTPRINT( "tweak" )
-                InitTweak::tweak( translationUnit );
 
                 if ( libcfap ) {