Adding the constant collapse pass to the pipeline.

Author: lvella

TODO-optimizations.txt

@@ -7,11 +7,6 @@ This files describes all the optimizations ideas we left out for now.
   But there shouldn't be any already, if the WASM is from an optimizing
   compiler.
 
-- [dag]: if the final ISA supports instructions that
-  operate on constants, like `addi $result, $input, 42`, then the DAG
-  could be optimized to take advantage of this by folding constant
-  values into the instructions that can use them.
-
 - [locals_data_flow]: track locals permutation. If some locals are read into
   a block, but in the end they are just output unmodified (either on stack
   or on some local), this can be resolved statically when building the DAG,

src/loader/dag/const_collapse.rs

@@ -128,7 +128,7 @@ impl ConstantInputFinder {
         inputs: &[NodeInput],
         nodes: &mut [dag::Node],
         const_block_inputs: HashMap<u32, WasmValue>,
-    ) -> (bool, &'a mut [MaybeConstant]) {
+    ) -> (bool, &'a [MaybeConstant]) {
         let mut has_constant = false;
 
         // Check if any of the inputs are constants.
@@ -160,6 +160,6 @@ impl ConstantInputFinder {
             })
         }));
 
-        (has_constant, &mut self.buffer)
+        (has_constant, &self.buffer)
     }
 }

src/loader/mod.rs

@@ -413,6 +413,7 @@ pub enum FunctionProcessingStage<'a, S: Settings<'a>> {
         tree: LiftedBlockTree<'a>,
     },
     PlainDag(Dag<'a>),
+    ConstCollapsedDag(Dag<'a>),
     ConstDedupDag(Dag<'a>),
     DanglingOptDag(Dag<'a>),
     BlocklessDag(BlocklessDag<'a>),
@@ -455,6 +456,15 @@ impl<'a, S: Settings<'a>> FunctionProcessingStage<'a, S> {
                 FunctionProcessingStage::PlainDag(dag)
             }
             FunctionProcessingStage::PlainDag(mut dag) => {
+                // Optimization pass: collapse constants into instructions that use them, if possible.
+                let constants_collapsed =
+                    dag::const_collapse::constant_collapse(settings, &mut dag);
+                if let Some(stats) = stats {
+                    stats.constants_deduplicated += constants_collapsed;
+                }
+                FunctionProcessingStage::ConstCollapsedDag(dag)
+            }
+            FunctionProcessingStage::ConstCollapsedDag(mut dag) => {
                 // Optimization pass: deduplicate const definitions in the DAG.
                 let constants_deduplicated = dag::const_dedup::deduplicate_constants(&mut dag);
                 if let Some(stats) = stats {
@@ -692,6 +702,8 @@ fn pack_bytes_into_words(bytes: &[u8], mut alignment: u32) -> Vec<MemoryEntry> {
 pub struct Statistics {
     /// Number of register copies saved by the "smart" register allocation.
     pub register_copies_saved: usize,
+    /// Number of constants collapsed into instructions.
+    pub constants_collapsed: usize,
     /// Number of constants deduplicated in the DAG.
     pub constants_deduplicated: usize,
     /// Number of dangling nodes removed from the DAG.
@@ -706,8 +718,9 @@ impl Display for Statistics {
     fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
         write!(
             f,
-            "Optimization statistics:\n - {} register copies saved\n - {} constants deduplicated\n - {} dangling nodes removed\n - {} block outputs removed\n - {} useless jumps removed",
+            "Optimization statistics:\n - {} register copies saved\n - {} constants collapsed\n - {} constants deduplicated\n - {} dangling nodes removed\n - {} block outputs removed\n - {} useless jumps removed",
             self.register_copies_saved,
+            self.constants_collapsed,
             self.constants_deduplicated,
             self.dangling_nodes_removed,
             self.block_outputs_removed,