Add a new memcpy propagation pass

sway-core/src/lib.rs

@@ -60,7 +60,8 @@ use sway_ir::{
     create_o1_pass_group, register_known_passes, Context, Kind, Module, PassGroup, PassManager,
     PrintPassesOpts, ARG_DEMOTION_NAME, ARG_POINTEE_MUTABILITY_TAGGER_NAME, CONST_DEMOTION_NAME,
     DCE_NAME, FN_DEDUP_DEBUG_PROFILE_NAME, FN_INLINE_NAME, GLOBALS_DCE_NAME, MEM2REG_NAME,
-    MEMCPYOPT_NAME, MISC_DEMOTION_NAME, RET_DEMOTION_NAME, SIMPLIFY_CFG_NAME, SROA_NAME,
+    MEMCPYOPT_NAME, MEMCPYPROP_REVERSE_NAME, MISC_DEMOTION_NAME, RET_DEMOTION_NAME,
+    SIMPLIFY_CFG_NAME, SROA_NAME,
 };
 use sway_types::span::Source;
 use sway_types::{SourceEngine, SourceLocation, Span};
@@ -1265,6 +1266,7 @@ pub(crate) fn compile_ast_to_ir_to_asm(
 
         match build_config.optimization_level {
             OptLevel::Opt1 => {
+                pass_group.append_pass(MEMCPYPROP_REVERSE_NAME);
                 pass_group.append_pass(SROA_NAME);
                 pass_group.append_pass(MEM2REG_NAME);
                 pass_group.append_pass(DCE_NAME);

sway-ir/src/analysis/dominator.rs

@@ -1,6 +1,6 @@
 use crate::{
     block::Block, AnalysisResult, AnalysisResultT, AnalysisResults, BranchToWithArgs, Context,
-    Function, IrError, Pass, PassMutability, ScopedPass,
+    Function, IrError, Pass, PassMutability, ScopedPass, Value,
 };
 use indexmap::IndexSet;
 /// Dominator tree and related algorithms.
@@ -222,6 +222,34 @@ impl DomTree {
     pub fn child(&self, node: Block, i: usize) -> Option<Block> {
         self.0[&node].children.get(i).cloned()
     }
+
+    /// Does `dominator` `dominate` `dominatee`?
+    pub fn dominates_instr(&self, context: &Context, dominator: Value, dominatee: Value) -> bool {
+        let dominator_inst = dominator.get_instruction(context).unwrap();
+        let dominatee_inst = dominatee.get_instruction(context).unwrap();
+
+        if dominator == dominatee {
+            return true;
+        }
+        let dominator_block = dominator_inst.parent;
+        let dominatee_block = dominatee_inst.parent;
+        if dominator_block == dominatee_block {
+            // Same block, but different instructions.
+            // Check the order of instructions in the block.
+            let mut found_dominator = false;
+            for instr in dominator_block.instruction_iter(context) {
+                if instr == dominator {
+                    found_dominator = true;
+                }
+                if instr == dominatee {
+                    return found_dominator;
+                }
+            }
+            false
+        } else {
+            self.dominates(dominator_block, dominatee_block)
+        }
+    }
 }
 
 pub const DOM_FRONTS_NAME: &str = "dominance-frontiers";

sway-ir/src/block.rs

@@ -73,6 +73,11 @@ impl BlockArgument {
         }
         None
     }
+
+    /// Get that Value that this argument represents.
+    pub fn as_value(&self, context: &Context) -> Value {
+        self.block.get_arg(context, self.idx).unwrap()
+    }
 }
 
 /// Each block may be explicitly named.  A [`Label`] is a simple `String` synonym.

sway-ir/src/function.rs

@@ -208,6 +208,13 @@ impl Function {
         Ok(())
     }
 
+    /// Remove instructions from function that satisfy a given predicate.
+    pub fn remove_instructions<T: Fn(Value) -> bool>(&self, context: &mut Context, pred: T) {
+        for block in context.functions[self.0].blocks.clone() {
+            block.remove_instructions(context, &pred);
+        }
+    }
+
     /// Get a new unique block label.
     ///
     /// If `hint` is `None` then the label will be in the form `"blockN"` where N is an