Add a new memcpy propagation pass (#7443)

## Description

For the Sway code in #7344, the IR after #7381 and after this PR is
shown here:

<details>
<summary> After #7381, before this PR </summary>

```
   fn wrapper_1(__ret_value: __ptr { b256 }) -> (), !17 {
        local { u64, ( () | { b256 } ) } __matched_value_4
        local { u64, ( () | { b256 } ) } __ret_val
        local { u64, ( () | { b256 } ) } self_

        entry(__ret_value: __ptr { b256 }):
        v0 = get_local __ptr { u64, ( () | { b256 } ) }, __ret_val
        v1 = call return_option_5(v0)
        v2 = get_local __ptr { u64, ( () | { b256 } ) }, self_, !20
        mem_copy_val v2, v0
        v3 = get_local __ptr { u64, ( () | { b256 } ) }, self_, !23
        v4 = get_local __ptr { u64, ( () | { b256 } ) }, __matched_value_4, !25
        mem_copy_val v4, v3
        v5 = get_local __ptr { u64, ( () | { b256 } ) }, self_
        v6 = const u64 0
        v7 = get_elem_ptr v5, __ptr u64, v6
        v8 = load v7, !20
        v9 = const u64 1, !22
        v10 = cmp eq v8 v9, !28
        cbr v10, unwrap_2_block0(), unwrap_2_block1(), !29

        unwrap_2_block0():
        v11 = get_local __ptr { u64, ( () | { b256 } ) }, __matched_value_4, !30
        v12 = const u64 1
        v13 = const u64 1
        v14 = get_elem_ptr v11, __ptr { b256 }, v12, v13, !20
        mem_copy_val __ret_value, v14
        v15 = const unit ()
        ret () v15

        unwrap_2_block1():
        v16 = const u64 0, !31
        revert v16, !36
    }

    fn return_option_5(__ret_value: __ptr { u64, ( () | { b256 } ) }) -> (), !39 {
        local { u64, ( () | { b256 } ) } __anon_0

        entry(__ret_value: __ptr { u64, ( () | { b256 } ) }):
        v0 = get_local __ptr { u64, ( () | { b256 } ) }, __anon_0, !40
        v1 = const u64 0
        v2 = get_elem_ptr v0, __ptr u64, v1, !40
        v3 = const u64 0, !40
        store v3 to v2, !40
        mem_copy_val __ret_value, v0
        v4 = const unit ()
        ret () v4
    }
```
</details>

<details>
<summary> After this PR </summary>

```
       fn wrapper_1(__ret_value: __ptr { b256 }) -> (), !17 {
        local { u64, ( () | { b256 } ) } __matched_value_4

        entry(__ret_value: __ptr { b256 }):
        v0 = get_local __ptr { u64, ( () | { b256 } ) }, __matched_value_4
        v1 = call return_option_5(v0)
        v2 = get_local __ptr { u64, ( () | { b256 } ) }, __matched_value_4
        v3 = const u64 0
        v4 = get_elem_ptr v2, __ptr u64, v3
        v5 = load v4, !20
        v6 = const u64 1, !22
        v7 = cmp eq v5 v6, !25
        cbr v7, unwrap_2_block0(), unwrap_2_block1(), !26

        unwrap_2_block0():
        v8 = get_local __ptr { u64, ( () | { b256 } ) }, __matched_value_4, !27
        v9 = const u64 1
        v10 = const u64 1
        v11 = get_elem_ptr v8, __ptr { b256 }, v9, v10, !20
        mem_copy_val __ret_value, v11
        v12 = const unit ()
        ret () v12

        unwrap_2_block1():
        v13 = const u64 0, !28
        revert v13, !33
    }

    fn return_option_5(__ret_value: __ptr { u64, ( () | { b256 } ) }) -> (), !36 {
        entry(__ret_value: __ptr { u64, ( () | { b256 } ) }):
        v0 = const u64 0
        v1 = get_elem_ptr __ret_value, __ptr u64, v0, !37
        v2 = const u64 0, !37
        store v2 to v1, !37
        v3 = const unit ()
        ret () v3
    }
```
</details>

`wrapper_1`, which had 3 `memcpy`s now has 1, and `return_option_5`
which had one, now has none.

Closes #7344.

Author: vaivaswatha

sway-core/src/lib.rs

@@ -58,8 +58,8 @@ use sway_ir::{
     create_o1_pass_group, register_known_passes, Context, Kind, Module, PassGroup, PassManager,
     PrintPassesOpts, VerifyPassesOpts, 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,
+    MEM2REG_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};
@@ -1322,6 +1322,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 the [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

@@ -219,6 +219,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