Changeset f674479 for src

Timestamp:

Apr 11, 2017, 4:20:51 PM (9 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

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

Children:

da1c772

Parents:

a0fc78a (diff), 32bcef7 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg2:software/cfa/cfa-cc

Location:

src

Files:

• ControlStruct/LabelGenerator.cc (modified) (2 diffs)
• ControlStruct/LabelGenerator.h (modified) (2 diffs)
• ControlStruct/MLEMutator.cc (modified) (6 diffs)
• ResolvExpr/AlternativeFinder.cc (modified) (5 diffs)
• ResolvExpr/AlternativeFinder.h (modified) (1 diff)
• SymTab/Autogen.cc (modified) (1 diff)
• SymTab/Validate.cc (modified) (3 diffs)
• SynTree/Expression.cc (modified) (1 diff)

src/ControlStruct/LabelGenerator.cc

@@ -20 +20 @@
 #include "SynTree/Label.h"
 #include "SynTree/Attribute.h"
+#include "SynTree/Statement.h"
 
 namespace ControlStruct {
@@ -31 +32 @@
         }
 
-        Label LabelGenerator::newLabel( std::string suffix ) {
+        Label LabelGenerator::newLabel( std::string suffix, Statement * stmt ) {
                 std::ostringstream os;
                 os << "__L" << current++ << "__" << suffix;
+                if ( stmt && ! stmt->get_labels().empty() ) {
+                        os << "_" << stmt->get_labels().front() << "__";
+                }
                 std::string ret = os.str();
                 Label l( ret );

src/ControlStruct/LabelGenerator.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// LabelGenerator.h -- 
+// LabelGenerator.h --
 //
 // Author           : Rodolfo G. Esteves
@@ -24 +24 @@
           public:
                 static LabelGenerator *getGenerator();
-                Label newLabel(std::string suffix = "");
+                Label newLabel(std::string suffix, Statement * stmt = nullptr);
                 void reset() { current = 0; }
                 void rewind() { current--; }

src/ControlStruct/MLEMutator.cc

@@ -56 +56 @@
                 bool labeledBlock = !(cmpndStmt->get_labels().empty());
                 if ( labeledBlock ) {
-                        Label brkLabel = generator->newLabel("blockBreak");
+                        Label brkLabel = generator->newLabel("blockBreak", cmpndStmt);
                         enclosingControlStructures.push_back( Entry( cmpndStmt, brkLabel ) );
                 } // if
@@ -80 +80 @@
                 // whether brkLabel and contLabel are used with branch statements and will recursively do the same to nested
                 // loops
-                Label brkLabel = generator->newLabel("loopBreak");
-                Label contLabel = generator->newLabel("loopContinue");
+                Label brkLabel = generator->newLabel("loopBreak", loopStmt);
+                Label contLabel = generator->newLabel("loopContinue", loopStmt);
                 enclosingControlStructures.push_back( Entry( loopStmt, brkLabel, contLabel ) );
                 loopStmt->set_body ( loopStmt->get_body()->acceptMutator( *this ) );
 
+                assert( ! enclosingControlStructures.empty() );
                 Entry &e = enclosingControlStructures.back();
                 // sanity check that the enclosing loops have been popped correctly
@@ -108 +109 @@
                 bool labeledBlock = !(ifStmt->get_labels().empty());
                 if ( labeledBlock ) {
-                        Label brkLabel = generator->newLabel("blockBreak");
+                        Label brkLabel = generator->newLabel("blockBreak", ifStmt);
                         enclosingControlStructures.push_back( Entry( ifStmt, brkLabel ) );
                 } // if
 
                 Parent::mutate( ifStmt );
-                
+
                 if ( labeledBlock ) {
                         if ( ! enclosingControlStructures.back().useBreakExit().empty() ) {
@@ -126 +127 @@
         Statement *MLEMutator::handleSwitchStmt( SwitchClass *switchStmt ) {
                 // generate a label for breaking out of a labeled switch
-                Label brkLabel = generator->newLabel("switchBreak");
+                Label brkLabel = generator->newLabel("switchBreak", switchStmt);
                 enclosingControlStructures.push_back( Entry(switchStmt, brkLabel) );
                 mutateAll( switchStmt->get_statements(), *this );
@@ -158 +159 @@
 
                 std::list< Entry >::reverse_iterator targetEntry;
-                if ( branchStmt->get_type() == BranchStmt::Goto ) {
-                        return branchStmt;
-                } else if ( branchStmt->get_type() == BranchStmt::Continue) {
-                        // continue target must be a loop
-                        if ( branchStmt->get_target() == "" ) {
-                                targetEntry = std::find_if( enclosingControlStructures.rbegin(), enclosingControlStructures.rend(), [](Entry &e) { return isLoop( e.get_controlStructure() ); } );
-                        } else {
-                                // labelled continue - lookup label in table ot find attached control structure
-                                targetEntry = std::find( enclosingControlStructures.rbegin(), enclosingControlStructures.rend(), (*targetTable)[branchStmt->get_target()] );
-                        } // if
-                        if ( targetEntry == enclosingControlStructures.rend() || ! isLoop( targetEntry->get_controlStructure() ) ) {
-                                throw SemanticError( "'continue' target must be an enclosing loop: " + originalTarget );
-                        } // if
-                } else if ( branchStmt->get_type() == BranchStmt::Break ) {
-                        if ( enclosingControlStructures.empty() ) throw SemanticError( "'break' outside a loop, switch, or labelled block" );
-                        targetEntry = enclosingControlStructures.rbegin();
-                } else {
-                        assert( false );
-                } // if
-
-                if ( branchStmt->get_target() != "" && targetTable->find( branchStmt->get_target() ) == targetTable->end() ) {
-                        throw SemanticError("The label defined in the exit loop statement does not exist: " + originalTarget );  // shouldn't happen (since that's already checked)
-                } // if
+                switch ( branchStmt->get_type() ) {
+                        case BranchStmt::Goto:
+                                return branchStmt;
+                        case BranchStmt::Continue:
+                        case BranchStmt::Break: {
+                                bool isContinue = branchStmt->get_type() == BranchStmt::Continue;
+                                // unlabeled break/continue
+                                if ( branchStmt->get_target() == "" ) {
+                                        if ( isContinue ) {
+                                                // continue target is outermost loop
+                                                targetEntry = std::find_if( enclosingControlStructures.rbegin(), enclosingControlStructures.rend(), [](Entry &e) { return isLoop( e.get_controlStructure() ); } );
+                                        } else {
+                                                // break target is outmost control structure
+                                                if ( enclosingControlStructures.empty() ) throw SemanticError( "'break' outside a loop, switch, or labelled block" );
+                                                targetEntry = enclosingControlStructures.rbegin();
+                                        } // if
+                                } else {
+                                        // labeled break/continue - lookup label in table to find attached control structure
+                                        targetEntry = std::find( enclosingControlStructures.rbegin(), enclosingControlStructures.rend(), (*targetTable)[branchStmt->get_target()] );
+                                } // if
+                                // ensure that selected target is valid
+                                if ( targetEntry == enclosingControlStructures.rend() || (isContinue && ! isLoop( targetEntry->get_controlStructure() ) ) ) {
+                                        throw SemanticError( toString( (isContinue ? "'continue'" : "'break'"), " target must be an enclosing ", (isContinue ? "loop: " : "control structure: "), originalTarget ) );
+                                } // if
+                                break;
+                        }
+                        default:
+                                assert( false );
+                } // switch
 
                 // branch error checks, get the appropriate label name and create a goto
@@ -197 +204 @@
                 } // switch
 
-                if ( branchStmt->get_target() == "" && branchStmt->get_type() != BranchStmt::Continue ) {
-                        // unlabelled break/continue - can keep branch as break/continue for extra semantic information, but add
-                        // exitLabel as its destination so that label passes can easily determine where the break/continue goes to
-                        branchStmt->set_target( exitLabel );
-                        return branchStmt;
-                } else {
-                        // labelled break/continue - can't easily emulate this with break and continue, so transform into a goto
-                        delete branchStmt;
-                        return new BranchStmt( std::list<Label>(), exitLabel, BranchStmt::Goto );
-                } // if
+                // transform break/continue statements into goto to simplify later handling of branches
+                delete branchStmt;
+                return new BranchStmt( std::list<Label>(), exitLabel, BranchStmt::Goto );
         }
 

src/ResolvExpr/AlternativeFinder.cc

@@ -211 +211 @@
         }
 
-        // std::unordered_map< Expression *, UniqueExpr * > ;
+        void AlternativeFinder::addAnonConversions( const Alternative & alt ) {
+                // adds anonymous member interpretations whenever an aggregate value type is seen.
+                Expression * expr = alt.expr->clone();
+                std::unique_ptr< Expression > manager( expr ); // RAII for expr
+                alt.env.apply( expr->get_result() );
+                if ( StructInstType *structInst = dynamic_cast< StructInstType* >( expr->get_result() ) ) {
+                        NameExpr nameExpr( "" );
+                        addAggMembers( structInst, expr, alt.cost+Cost( 0, 0, 1 ), alt.env, &nameExpr );
+                } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( expr->get_result() ) ) {
+                        NameExpr nameExpr( "" );
+                        addAggMembers( unionInst, expr, alt.cost+Cost( 0, 0, 1 ), alt.env, &nameExpr );
+                } // if
+        }
 
         template< typename StructOrUnionType >
@@ -220 +232 @@
                 std::list< Declaration* > members;
                 aggInst->lookup( name, members );
+
                 for ( std::list< Declaration* >::const_iterator i = members.begin(); i != members.end(); ++i ) {
                         if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType* >( *i ) ) {
                                 alternatives.push_back( Alternative( new MemberExpr( dwt, expr->clone() ), env, newCost ) );
                                 renameTypes( alternatives.back().expr );
+                                addAnonConversions( alternatives.back() ); // add anonymous member interpretations whenever an aggregate value type is seen as a member expression.
                         } else {
                                 assert( false );
@@ -730 +744 @@
                 if ( candidates.empty() && ! errors.isEmpty() ) { throw errors; }
 
+                // compute conversionsion costs
                 for ( AltList::iterator withFunc = candidates.begin(); withFunc != candidates.end(); ++withFunc ) {
                         Cost cvtCost = computeConversionCost( *withFunc, indexer );
@@ -751 +766 @@
                         } // if
                 } // for
+                // function may return struct or union value, in which case we need to add alternatives for implicit conversions to each of the anonymous members
+                for ( const Alternative & alt : alternatives ) {
+                        addAnonConversions( alt );
+                }
+
                 candidates.clear();
                 candidates.splice( candidates.end(), alternatives );
@@ -885 +905 @@
                         )
                         renameTypes( alternatives.back().expr );
-                        if ( StructInstType *structInst = dynamic_cast< StructInstType* >( (*i)->get_type() ) ) {
-                                NameExpr nameExpr( "" );
-                                addAggMembers( structInst, &newExpr, Cost( 0, 0, 1 ), env, &nameExpr );
-                        } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( (*i)->get_type() ) ) {
-                                NameExpr nameExpr( "" );
-                                addAggMembers( unionInst, &newExpr, Cost( 0, 0, 1 ), env, &nameExpr );
-                        } // if
+                        addAnonConversions( alternatives.back() ); // add anonymous member interpretations whenever an aggregate value type is seen as a name expression.
                 } // for
         }

src/ResolvExpr/AlternativeFinder.h

@@ -78 +78 @@
                 void findSubExprs( InputIterator begin, InputIterator end, OutputIterator out );
 
+                /// Adds alternatives for anonymous members
+                void addAnonConversions( const Alternative & alt );
                 /// Adds alternatives for member expressions, given the aggregate, conversion cost for that aggregate, and name of the member
                 template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member );

src/SymTab/Autogen.cc

@@ -498 +498 @@
                 makeUnionFieldsAssignment( srcParam, dstParam, back_inserter( funcDecl->get_statements()->get_kids() ) );
                 if ( returnVal ) {
-                        if ( isDynamicLayout ) makeUnionFieldsAssignment( srcParam, returnVal, back_inserter( funcDecl->get_statements()->get_kids() ) );
-                        else funcDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
+                        funcDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
                 }
         }

src/SymTab/Validate.cc

@@ -208 +208 @@
         };
 
+        class ArrayLength : public Visitor {
+        public:
+                /// for array types without an explicit length, compute the length and store it so that it
+                /// is known to the rest of the phases. For example,
+                ///   int x[] = { 1, 2, 3 };
+                ///   int y[][2] = { { 1, 2, 3 }, { 1, 2, 3 } };
+                /// here x and y are known at compile-time to have length 3, so change this into
+                ///   int x[3] = { 1, 2, 3 };
+                ///   int y[3][2] = { { 1, 2, 3 }, { 1, 2, 3 } };
+                static void computeLength( std::list< Declaration * > & translationUnit );
+
+                virtual void visit( ObjectDecl * objDecl );
+        };
+
         class CompoundLiteral final : public GenPoly::DeclMutator {
                 Type::StorageClasses storageClasses;
@@ -235 +249 @@
                 acceptAll( translationUnit, pass3 );
                 VerifyCtorDtorAssign::verify( translationUnit );
+                ArrayLength::computeLength( translationUnit );
         }
 
@@ -869 +884 @@
                 }
         }
+
+        void ArrayLength::computeLength( std::list< Declaration * > & translationUnit ) {
+                ArrayLength len;
+                acceptAll( translationUnit, len );
+        }
+
+        void ArrayLength::visit( ObjectDecl * objDecl ) {
+                if ( ArrayType * at = dynamic_cast< ArrayType * >( objDecl->get_type() ) ) {
+                        if ( at->get_dimension() != nullptr ) return;
+                        if ( ListInit * init = dynamic_cast< ListInit * >( objDecl->get_init() ) ) {
+                                at->set_dimension( new ConstantExpr( Constant::from_ulong( init->get_initializers().size() ) ) );
+                        }
+                }
+        }
 } // namespace SymTab
 

src/SynTree/Expression.cc

@@ -339 +339 @@
                         return TypeSubstitution( aggInst->get_baseParameters()->begin(), aggInst->get_baseParameters()->end(), aggInst->get_parameters().begin() );
                 } else {
-                        assertf( false, "makeSub expects struct or union type for aggregate" );
+                        assertf( false, "makeSub expects struct or union type for aggregate, but got: %s", toString( t ).c_str() );
                 }
         }