Changeset 46cbfe1

Timestamp:

May 29, 2015, 4:02:20 PM (10 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, string, with_gc

Children:

76934fb

Parents:

be5aa1b

Message:

reorganization and refactoring of most of LabelFixer?

Location:

src/ControlStruct

Files:

• LabelFixer.cc (modified) (5 diffs)
• LabelFixer.h (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 : Wed May 27 16:16:14 2015
-// Update Count     : 4
+// Last Modified On : Fri May 29 15:57:12 2015
+// Update Count     : 82
 //
 
@@ -23 +23 @@
 #include "utility.h"
 
+#include <iostream>
+
 namespace ControlStruct {
-        LabelFixer::Entry::Entry( Statement *to, Statement *from ) : definition ( to ) {
+        LabelFixer::Entry::Entry( Statement *to, BranchStmt *from ) : definition ( to ) {
                 if ( from != 0 )
                         usage.push_back( from );
@@ -31 +33 @@
         bool LabelFixer::Entry::insideLoop() {
                 return ( dynamic_cast< ForStmt * > ( definition ) ||
-                                 dynamic_cast< WhileStmt * > ( definition )  );
+                        dynamic_cast< WhileStmt * > ( definition )  );
         }
 
@@ -46 +48 @@
         }
 
+        // prune to at most one label definition for each statement
         void LabelFixer::visit( Statement *stmt ) {
                 std::list< Label > &labels = stmt->get_labels();
 
                 if ( ! labels.empty() ) {
+                        // only remember one label for each statement
                         Label current = setLabelsDef( labels, stmt );
                         labels.clear();
@@ -57 +61 @@
 
         void LabelFixer::visit( BranchStmt *branchStmt ) {
-                visit ( ( Statement * )branchStmt );  // the labels this statement might have
+                visit ( ( Statement * )branchStmt );
 
-                Label target;
-                if ( (target = branchStmt->get_target()) != "" ) {
+                // for labeled branches, add an entry to the label table
+                Label target = branchStmt->get_target();
+                if ( target != "" ) {
                         setLabelsUsg( target, branchStmt );
-                } //else       /* computed goto or normal exit-loop statements */
+                }
         }
 
+        // sets the definition of the labelTable entry to be the provided 
+        // statement for every label in the list parameter. Happens for every kind of statement
         Label LabelFixer::setLabelsDef( std::list< Label > &llabel, Statement *definition ) {
                 assert( definition != 0 );
-                Entry *entry = new Entry( definition );
-                bool used = false;
+                assert( llabel.size() > 0 );
 
-                for ( std::list< Label >::iterator i = llabel.begin(); i != llabel.end(); i++ )
-                        if ( labelTable.find( *i ) == labelTable.end() )
-                                { used = true; labelTable[ *i ] = entry; } // undefined and unused
-                        else
-                                if ( labelTable[ *i ]->defined() )
-                                        throw SemanticError( "Duplicate definition of label: " + *i );
-                                else
-                                        labelTable[ *i ]->set_definition( definition );
+                for ( std::list< Label >::iterator i = llabel.begin(); i != llabel.end(); i++ ) {
+                        if ( labelTable.find( *i ) == labelTable.end() ) { 
+                                // undefined and unused until now, add an entry
+                                labelTable[ *i ] =  new Entry( definition ); 
+                        } else if ( labelTable[ *i ]->defined() ) {\
+                                // defined twice, error
+                                throw SemanticError( "Duplicate definition of label: " + *i );
+                        }       else {
+                                // used previously, but undefined until now -> set its definition to this location
+                                labelTable[ *i ]->set_definition( definition );
+                        } // if
+                } // for
 
-                if ( ! used ) delete entry;
-
-                return labelTable[ llabel.front() ]->get_label();  // this *must* exist
+                // produce one of the labels attached to this statement to be 
+                // temporarily used as the canonical label
+                return labelTable[ llabel.front() ]->get_label();
         }
 
-        Label LabelFixer::setLabelsUsg( Label orgValue, Statement *use ) {
+        // Remember all uses of a label.
+        void LabelFixer::setLabelsUsg( Label orgValue, BranchStmt *use ) {
                 assert( use != 0 );
 
-                if ( labelTable.find( orgValue ) != labelTable.end() )
-                        labelTable[ orgValue ]->add_use( use );         // the label has been defined or used before
-                else
+                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 );
-
-                return labelTable[ orgValue ]->get_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;
 
-                for ( std::map< Label, Entry *>::iterator i = labelTable.begin(); i != labelTable.end(); i++ ) {
+                // 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->get_uses() );
+                        } else if ( e->used() ) {
+                                def_us[ e->get_definition() ]->add_uses( e->get_uses() );
                         }
                 }
 
-                // get rid of labelTable
-                for ( std::map< Statement *, Entry * >::iterator i = def_us.begin(); i != def_us.end(); i++ ) {
+                // 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;
-                        std::list< Statement *> &from = (*i).second->get_uses();
-                        Label finalLabel = generator->newLabel();
-                        (*i).second->set_label( finalLabel );
+                        Entry * entry = (*i).second;
+                        std::list< BranchStmt *> &from = entry->get_uses();
 
+                        // no label definition found
                         if ( to == 0 ) {
-                                BranchStmt *first_use = dynamic_cast<BranchStmt *>(from.back());
-                                Label undef("");
-                                if ( first_use != 0 )
-                                        undef = first_use->get_target();
+                                Label undef = from.back()->get_target();
                                 throw SemanticError ( "'" + undef + "' label not defined");
                         }
+
+                        // generate a new label, and attach it to its defining statement
+                        // as the only label on that statement
+                        Label finalLabel = generator->newLabel();
+                        entry->set_label( finalLabel );
 
                         to->get_labels().clear();
                         to->get_labels().push_back( finalLabel );
 
-                        for ( std::list< Statement *>::iterator j = from.begin(); j != from.end(); j++ ) {
-                                BranchStmt *jumpTo = dynamic_cast< BranchStmt * > ( *j );
-                                assert( jumpTo != 0 );
-                                jumpTo->set_target( finalLabel );
+                        // redirect each of the source branch statements to the new target label
+                        for ( std::list< BranchStmt *>::iterator j = from.begin(); j != from.end(); ++j ) {
+                                BranchStmt *jump = *j;
+                                assert( jump != 0 );
+                                jump->set_target( finalLabel );
                         } // for
                 } // for
 
-                // reverse table
+                // create a table where each label maps to its defining statement
                 std::map< Label, Statement * > *ret = new std::map< Label, Statement * >();
-                for ( std::map< Statement *, Entry * >::iterator i = def_us.begin(); i != def_us.end(); i++ ) 
+                for ( std::map< Statement *, Entry * >::iterator i = def_us.begin(); i != def_us.end(); ++i ) {
                         (*ret)[ (*i).second->get_label() ] = (*i).first;
+                }
 
                 return ret;

src/ControlStruct/LabelFixer.h ¶

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Rob Schluntz
-// Last Modified On : Tue May 26 12:55:10 2015
-// Update Count     : 4
+// Last Modified On : Fri May 29 15:25:55 2015
+// Update Count     : 11
 //
 
@@ -55 +55 @@
 
                 Label setLabelsDef( std::list< Label > &, Statement *definition );
-                Label setLabelsUsg( Label, Statement *usage = 0 );
+                void setLabelsUsg( Label, BranchStmt *usage = 0 );
 
           private:
                 class Entry {
                   public:
-                        Entry( Statement *to = 0, Statement *from = 0 );
+                        Entry( Statement *to = 0, BranchStmt *from = 0 );
                         bool used() { return ( usage.empty() ); }
                         bool defined() { return ( definition != 0 ); }
@@ -71 +71 @@
                         void set_definition( Statement *def ) { definition = def; }
 
-                        std::list< Statement *> &get_uses() { return usage; }
-                        void add_use ( Statement *use ) { usage.push_back( use ); }
-                        void add_uses ( std::list<Statement *> uses ) { usage.insert( usage.end(), uses.begin(), uses.end() ); }
+                        std::list< BranchStmt *> &get_uses() { return usage; }
+                        void add_use ( BranchStmt *use ) { usage.push_back( use ); }
+                        void add_uses ( std::list<BranchStmt *> uses ) { usage.insert( usage.end(), uses.begin(), uses.end() ); }
                   private:
                         Label label;  
                         Statement *definition;
-                        std::list<Statement *> usage;
+                        std::list<BranchStmt *> usage;
                 };