Merge pull request #12262 from ethereum/functionGrouper

Keep canonical form of Yul during optimization.

Author: chriseth

docs/internals/optimizer.rst

@@ -972,15 +972,19 @@ BlockFlattener
 ^^^^^^^^^^^^^^
 
 This stage eliminates nested blocks by inserting the statement in the
-inner block at the appropriate place in the outer block:
+inner block at the appropriate place in the outer block. It depends on the
+FunctionGrouper and does not flatten the outermost block to keep the form
+produced by the FunctionGrouper.
 
 .. code-block:: yul
 
     {
-        let x := 2
         {
-            let y := 3
-            mstore(x, y)
+            let x := 2
+            {
+                let y := 3
+                mstore(x, y)
+            }
         }
     }
 
@@ -989,9 +993,11 @@ is transformed to
 .. code-block:: yul
 
     {
-        let x := 2
-        let y := 3
-        mstore(x, y)
+        {
+            let x := 2
+            let y := 3
+            mstore(x, y)
+        }
     }
 
 As long as the code is disambiguated, this does not cause a problem because

libyul/optimiser/BlockFlattener.cpp

@@ -43,3 +43,15 @@ void BlockFlattener::operator()(Block& _block)
 		}
 	);
 }
+
+void BlockFlattener::run(OptimiserStepContext&, Block& _ast)
+{
+	BlockFlattener flattener;
+	for (auto& statement: _ast.statements)
+		if (auto* block = get_if<Block>(&statement))
+			flattener(*block);
+		else if (auto* function = get_if<FunctionDefinition>(&statement))
+			flattener(function->body);
+		else
+			yulAssert(false, "BlockFlattener requires the FunctionGrouper.");
+}

libyul/optimiser/BlockFlattener.h

@@ -27,7 +27,7 @@ class BlockFlattener: public ASTModifier
 {
 public:
 	static constexpr char const* name{"BlockFlattener"};
-	static void run(OptimiserStepContext&, Block& _ast) { BlockFlattener{}(_ast); }
+	static void run(OptimiserStepContext&, Block& _ast);
 
 	using ASTModifier::operator();
 	void operator()(Block& _block) override;

libyul/optimiser/CircularReferencesPruner.cpp

@@ -18,6 +18,7 @@
 #include <libyul/optimiser/CircularReferencesPruner.h>
 
 #include <libyul/optimiser/CallGraphGenerator.h>
+#include <libyul/optimiser/FunctionGrouper.h>
 #include <libyul/optimiser/OptimizerUtilities.h>
 #include <libyul/AST.h>
 
@@ -29,6 +30,7 @@ using namespace solidity::yul;
 void CircularReferencesPruner::run(OptimiserStepContext& _context, Block& _ast)
 {
 	CircularReferencesPruner{_context.reservedIdentifiers}(_ast);
+	FunctionGrouper::run(_context, _ast);
 }
 
 void CircularReferencesPruner::operator()(Block& _block)

libyul/optimiser/ExpressionJoiner.cpp

@@ -22,6 +22,7 @@
 
 #include <libyul/optimiser/ExpressionJoiner.h>
 
+#include <libyul/optimiser/FunctionGrouper.h>
 #include <libyul/optimiser/NameCollector.h>
 #include <libyul/optimiser/OptimizerUtilities.h>
 #include <libyul/Exceptions.h>
@@ -37,9 +38,10 @@ using namespace std;
 using namespace solidity;
 using namespace solidity::yul;
 
-void ExpressionJoiner::run(OptimiserStepContext&, Block& _ast)
+void ExpressionJoiner::run(OptimiserStepContext& _context, Block& _ast)
 {
 	ExpressionJoiner{_ast}(_ast);
+	FunctionGrouper::run(_context, _ast);
 }
 
 

libyul/optimiser/FunctionGrouper.h

@@ -34,7 +34,7 @@ struct OptimiserStepContext;
  * all function definitions.
  *
  * After this step, a block is of the form
- * { { I...} F... }
+ * { { I... } F... }
  * Where I are (non-function-definition) instructions and F are function definitions.
  */
 class FunctionGrouper

libyul/optimiser/OptimizerUtilities.h

@@ -37,6 +37,8 @@ namespace solidity::yul
 {
 
 /// Removes statements that are just empty blocks (non-recursive).
+/// If this is run on the outermost block, the FunctionGrouper should be run afterwards to keep
+/// the canonical form.
 void removeEmptyBlocks(Block& _block);
 
 /// Returns true if a given literal can not be used as an identifier.

libyul/optimiser/Suite.cpp

@@ -118,7 +118,7 @@ void OptimiserSuite::run(
 
 	// Some steps depend on properties ensured by FunctionHoister, BlockFlattener, FunctionGrouper and
 	// ForLoopInitRewriter. Run them first to be able to run arbitrary sequences safely.
-	suite.runSequence("hfgo", ast);
+	suite.runSequence("hgfo", ast);
 
 	NameSimplifier::run(suite.m_context, ast);
 	// Now the user-supplied part

libyul/optimiser/UnusedPruner.cpp

@@ -21,6 +21,7 @@
 #include <libyul/optimiser/UnusedPruner.h>
 
 #include <libyul/optimiser/CallGraphGenerator.h>
+#include <libyul/optimiser/FunctionGrouper.h>
 #include <libyul/optimiser/NameCollector.h>
 #include <libyul/optimiser/Semantics.h>
 #include <libyul/optimiser/OptimizerUtilities.h>
@@ -33,6 +34,12 @@ using namespace std;
 using namespace solidity;
 using namespace solidity::yul;
 
+void UnusedPruner::run(OptimiserStepContext& _context, Block& _ast)
+{
+	UnusedPruner::runUntilStabilisedOnFullAST(_context.dialect, _ast, _context.reservedIdentifiers);
+	FunctionGrouper::run(_context, _ast);
+}
+
 UnusedPruner::UnusedPruner(
 	Dialect const& _dialect,
 	Block& _ast,

libyul/optimiser/UnusedPruner.h

@@ -50,9 +50,7 @@ class UnusedPruner: public ASTModifier
 {
 public:
 	static constexpr char const* name{"UnusedPruner"};
-	static void run(OptimiserStepContext& _context, Block& _ast) {
-		UnusedPruner::runUntilStabilisedOnFullAST(_context.dialect, _ast, _context.reservedIdentifiers);
-	}
+	static void run(OptimiserStepContext& _context, Block& _ast);
 
 
 	using ASTModifier::operator();