Changes in src/ControlStruct/LabelFixer.cc [e766208:0a0a65b]

File:

• src/ControlStruct/LabelFixer.cc (modified) (6 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;
                 }