Changeset a181494

Timestamp:

Feb 21, 2018, 4:07:10 PM (6 years ago)

Author:

Rob Schluntz <rschlunt@…>

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:

5a806be4

Parents:

599fbb6

git-author:

Rob Schluntz <rschlunt@…> (02/21/18 15:52:43)

git-committer:

Rob Schluntz <rschlunt@…> (02/21/18 16:07:10)

Message:

Adding cost for reference-to-rvalue conversions

Location:

src

Files:

• ResolvExpr/AlternativeFinder.cc (modified) (12 diffs)
• ResolvExpr/Resolver.cc (modified) (1 diff)
• ResolvExpr/typeops.h (modified) (1 diff)
• SymTab/Indexer.cc (modified) (2 diffs)
• SymTab/Indexer.h (modified) (2 diffs)

src/ResolvExpr/AlternativeFinder.cc

@@ -204 +204 @@
         } // namespace
 
-        void referenceToRvalueConversion( Expression *& expr ) {
+        void referenceToRvalueConversion( Expression *& expr, Cost & cost ) {
                 if ( dynamic_cast< ReferenceType * >( expr->get_result() ) ) {
                         // cast away reference from expr
                         expr = new CastExpr( expr, expr->get_result()->stripReferences()->clone() );
+                        cost.incReference();
                 }
         }
@@ -435 +436 @@
                                         PRINT( std::cerr << "end of formals with varargs function: inc unsafe: " << convCost << std::endl; ; )
                                         // convert reference-typed expressions to value-typed expressions
-                                        referenceToRvalueConversion( *actualExpr );
+                                        referenceToRvalueConversion( *actualExpr, convCost );
                                         continue;
                                 } else {
@@ -565 +566 @@
                                 // DOESN'T WORK: grandchild nodes conflict with their cousins
                                 //if ( newNeedParents[ curDecl->get_uniqueId() ][ candDecl->get_uniqueId() ]++ > recursionParentLimit ) continue;
-                                Expression *varExpr = data.combine();
+
+                                Expression *varExpr = data.combine( newerAlt.cost );
                                 delete varExpr->get_result();
                                 varExpr->set_result( adjType->clone() );
@@ -1121 +1123 @@
                                         if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
                                                 Alternative newFunc( *func );
-                                                referenceToRvalueConversion( newFunc.expr );
+                                                referenceToRvalueConversion( newFunc.expr, newFunc.cost );
                                                 makeFunctionAlternatives( newFunc, function, argExpansions,
                                                         std::back_inserter( candidates ) );
@@ -1130 +1132 @@
                                                 if ( FunctionType *function = dynamic_cast< FunctionType* >( eqvClass.type ) ) {
                                                         Alternative newFunc( *func );
-                                                        referenceToRvalueConversion( newFunc.expr );
+                                                        referenceToRvalueConversion( newFunc.expr, newFunc.cost );
                                                         makeFunctionAlternatives( newFunc, function, argExpansions,
                                                                 std::back_inserter( candidates ) );
@@ -1160 +1162 @@
                                                                 dynamic_cast<FunctionType*>( pointer->get_base() ) ) {
                                                         Alternative newFunc( *funcOp );
-                                                        referenceToRvalueConversion( newFunc.expr );
+                                                        referenceToRvalueConversion( newFunc.expr, newFunc.cost );
                                                         makeFunctionAlternatives( newFunc, function, argExpansions,
                                                                 std::back_inserter( candidates ) );
@@ -1344 +1346 @@
                 for ( AltList::const_iterator agg = funcFinder.alternatives.begin(); agg != funcFinder.alternatives.end(); ++agg ) {
                         // it's okay for the aggregate expression to have reference type -- cast it to the base type to treat the aggregate as the referenced value
-                        std::unique_ptr<Expression> aggrExpr( agg->expr->clone() );
-                        Type * aggrType = aggrExpr->get_result();
-                        if ( dynamic_cast< ReferenceType * >( aggrType ) ) {
-                                aggrType = aggrType->stripReferences();
-                                aggrExpr.reset( new CastExpr( aggrExpr.release(), aggrType->clone() ) );
-                        }
+                        Cost cost = agg->cost;
+                        Expression * aggrExpr = agg->expr->clone();
+                        referenceToRvalueConversion( aggrExpr, cost );
+                        std::unique_ptr<Expression> guard( aggrExpr );
+
                         // find member of the given type
                         if ( StructInstType *structInst = dynamic_cast< StructInstType* >( aggrExpr->get_result() ) ) {
-                                addAggMembers( structInst, aggrExpr.get(), agg->cost, agg->env, memberExpr->get_member() );
+                                addAggMembers( structInst, aggrExpr, cost, agg->env, memberExpr->get_member() );
                         } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( aggrExpr->get_result() ) ) {
-                                addAggMembers( unionInst, aggrExpr.get(), agg->cost, agg->env, memberExpr->get_member() );
+                                addAggMembers( unionInst, aggrExpr, cost, agg->env, memberExpr->get_member() );
                         } else if ( TupleType * tupleType = dynamic_cast< TupleType * >( aggrExpr->get_result() ) ) {
-                                addTupleMembers( tupleType, aggrExpr.get(), agg->cost, agg->env, memberExpr->get_member() );
+                                addTupleMembers( tupleType, aggrExpr, cost, agg->env, memberExpr->get_member() );
                         } // if
                 } // for
@@ -1370 +1371 @@
                 PRINT( std::cerr << "nameExpr is " << nameExpr->name << std::endl; )
                 for ( auto & data : declList ) {
-                        Expression * newExpr = data.combine();
-                        // xxx - add in extra cost for with-statement exprs?
-                        alternatives.push_back( Alternative( newExpr, env, Cost::zero ) );
+                        Cost cost = Cost::zero;
+                        Expression * newExpr = data.combine( cost );
+                        alternatives.push_back( Alternative( newExpr, env, Cost::zero ) ); // xxx
                         PRINT(
                                 std::cerr << "decl is ";
@@ -1412 +1413 @@
                         // return the lowest cost alternative for the argument
                         Alternative &choice = winners.front();
-                        referenceToRvalueConversion( choice.expr );
+                        referenceToRvalueConversion( choice.expr, choice.cost );
                         alternatives.push_back( Alternative( new SizeofExpr( choice.expr->clone() ), choice.env, Cost::zero ) );
                 } // if
@@ -1433 +1434 @@
                         // return the lowest cost alternative for the argument
                         Alternative &choice = winners.front();
-                        referenceToRvalueConversion( choice.expr );
+                        referenceToRvalueConversion( choice.expr, choice.cost );
                         alternatives.push_back( Alternative( new AlignofExpr( choice.expr->clone() ), choice.env, Cost::zero ) );
                 } // if
@@ -1485 +1486 @@
                         AltList & alternatives = finder.get_alternatives();
                         if ( typesCompatibleIgnoreQualifiers( argType, function->get_parameters().front()->get_type(), indexer, env ) ) {
-                                alternatives.push_back( Alternative( new AttrExpr( data.combine(), argType->clone() ), env, Cost::zero ) );
+                                Cost cost = Cost::zero;
+                                Expression * newExpr = data.combine( cost );
+                                alternatives.push_back( Alternative( new AttrExpr( newExpr, argType->clone() ), env, cost ) );
                                 for ( DeclarationWithType * retVal : function->returnVals ) {
                                         alternatives.back().expr->result = retVal->get_type()->clone();
@@ -1522 +1525 @@
                 } else {
                         for ( auto & data : attrList ) {
-                                alternatives.push_back( Alternative( data.combine(), env, Cost::zero ) );
+                                Cost cost = Cost::zero;
+                                Expression * newExpr = data.combine( cost );
+                                alternatives.push_back( Alternative( newExpr, env, cost ) );
                                 renameTypes( alternatives.back().expr );
                         } // for

src/ResolvExpr/Resolver.cc

@@ -526 +526 @@
                                         Alternative newFunc( func );
                                         // Strip reference from function
-                                        referenceToRvalueConversion( newFunc.expr );
+                                        referenceToRvalueConversion( newFunc.expr, newFunc.cost );
 
                                         // For all the set of arguments we have try to match it with the parameter of the current function alternative

src/ResolvExpr/typeops.h

@@ -106 +106 @@
 
         // in AlternativeFinder.cc
-        void referenceToRvalueConversion( Expression *& expr );
+        void referenceToRvalueConversion( Expression *& expr, Cost & cost );
 
         // flatten tuple type into list of types

src/SymTab/Indexer.cc

@@ -603 +603 @@
                                         if ( dynamic_cast< StructInstType * >( t ) || dynamic_cast< UnionInstType * >( t ) ) {
                                                 Expression * base = expr->clone();
-                                                ResolvExpr::referenceToRvalueConversion( base );
+                                                ResolvExpr::Cost cost = ResolvExpr::Cost::zero; // xxx - carry this cost into the indexer as a base cost?
+                                                ResolvExpr::referenceToRvalueConversion( base, cost );
                                                 addMembers( t->getAggr(), new MemberExpr( dwt, base ), handleConflicts );
                                         }
@@ -705 +706 @@
         }
 
-        Expression * Indexer::IdData::combine() const {
+        Expression * Indexer::IdData::combine( ResolvExpr::Cost & cost ) const {
                 Expression * ret = nullptr;
                 if ( baseExpr ) {
                         Expression * base = baseExpr->clone();
-                        ResolvExpr::referenceToRvalueConversion( base );
+                        ResolvExpr::referenceToRvalueConversion( base, cost );
                         ret = new MemberExpr( id, base );
                         // xxx - this introduces hidden environments, for now remove them.

src/SymTab/Indexer.h

@@ -23 +23 @@
 #include "SynTree/Visitor.h"  // for Visitor
 #include "SynTree/SynTree.h"  // for AST nodes
+
+namespace ResolvExpr {
+class Cost;
+}
 
 namespace SymTab {
@@ -51 +55 @@
                         IdData( DeclarationWithType * id, Expression * baseExpr, BaseSyntaxNode * deleteStmt ) : id( id ), baseExpr( baseExpr ), deleteStmt( deleteStmt ) {}
 
-                        Expression * combine() const;
+                        Expression * combine( ResolvExpr::Cost & cost ) const;
                 };