Argument Mutability Analysis - and its applications (#7368)

This PR also includes a major rewrite of the pass manager algorithm.

Author: vaivaswatha

sway-core/src/ir_generation/function.rs

@@ -1977,6 +1977,7 @@ impl<'a> FnCompiler<'a> {
                             block: merge_block,
                             idx: 0,
                             ty: ptr_ty,
+                            is_immutable: false,
                         },
                     );
                     merge_block.add_arg(context, merge_block_ptr);
@@ -1986,6 +1987,7 @@ impl<'a> FnCompiler<'a> {
                             block: merge_block,
                             idx: 1,
                             ty: Type::get_uint64(context),
+                            is_immutable: false,
                         },
                     );
                     merge_block.add_arg(context, merge_block_cap);

sway-core/src/lib.rs

@@ -58,9 +58,9 @@ use sway_error::warning::{CollectedTraitImpl, CompileInfo, CompileWarning, Info,
 use sway_features::ExperimentalFeatures;
 use sway_ir::{
     create_o1_pass_group, register_known_passes, Context, Kind, Module, PassGroup, PassManager,
-    PrintPassesOpts, ARG_DEMOTION_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,
+    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,
 };
 use sway_types::span::Source;
 use sway_types::{SourceEngine, SourceLocation, Span};
@@ -1256,6 +1256,7 @@ pub(crate) fn compile_ast_to_ir_to_asm(
         pass_group.append_pass(MISC_DEMOTION_NAME);
 
         // Convert loads and stores to mem_copies where possible.
+        pass_group.append_pass(ARG_POINTEE_MUTABILITY_TAGGER_NAME);
         pass_group.append_pass(MEMCPYOPT_NAME);
 
         // Run a DCE and simplify-cfg to clean up any obsolete instructions.

sway-ir/src/analysis.rs

@@ -4,5 +4,3 @@ pub mod dominator;
 pub use dominator::*;
 pub mod memory_utils;
 pub use memory_utils::*;
-pub mod arg_mutability;
-pub use arg_mutability::*;

sway-ir/src/analysis/arg_mutability.rs

@@ -391,13 +391,13 @@ impl AnalysisResultT for EscapedSymbols {}
 
 pub fn compute_escaped_symbols_pass(
     context: &Context,
-    _: &AnalysisResults,
+    _analyses: &AnalysisResults,
     function: Function,
 ) -> Result<AnalysisResult, IrError> {
     Ok(Box::new(compute_escaped_symbols(context, &function)))
 }
 
-pub fn compute_escaped_symbols(context: &Context, function: &Function) -> EscapedSymbols {
+fn compute_escaped_symbols(context: &Context, function: &Function) -> EscapedSymbols {
     let add_from_val = |result: &mut FxHashSet<Symbol>, val: &Value, is_complete: &mut bool| {
         let (complete, syms) = get_referred_symbols(context, *val).consume();
 
@@ -422,9 +422,14 @@ pub fn compute_escaped_symbols(context: &Context, function: &Function) -> Escape
             InstOp::BinaryOp { .. } => (),
             InstOp::BitCast(_, _) => (),
             InstOp::Branch(_) => (),
-            InstOp::Call(_, args) => args
+            InstOp::Call(callee, args) => args
                 .iter()
-                .for_each(|v| add_from_val(&mut result, v, &mut is_complete)),
+                .enumerate()
+                .filter(|(arg_idx, _arg)| {
+                    // Immutable arguments are not considered as escaping symbols.
+                    !callee.is_arg_immutable(context, *arg_idx)
+                })
+                .for_each(|(_, v)| add_from_val(&mut result, v, &mut is_complete)),
             InstOp::CastPtr(ptr, _) => add_from_val(&mut result, ptr, &mut is_complete),
             InstOp::Cmp(_, _, _) => (),
             InstOp::ConditionalBranch { .. } => (),

sway-ir/src/analysis/memory_utils.rs

@@ -55,6 +55,8 @@ pub struct BlockArgument {
     /// idx'th argument of the block.
     pub idx: usize,
     pub ty: Type,
+    /// Is this known to be immutable?
+    pub is_immutable: bool,
 }
 
 impl BlockArgument {
@@ -144,6 +146,7 @@ impl Block {
                 block: *self,
                 idx,
                 ty,
+                is_immutable: false,
             },
         );
         context.blocks[self.0].args.push(arg_val);
@@ -152,9 +155,12 @@ impl Block {
 
     pub fn set_arg(&self, context: &mut Context, arg: Value) {
         match context.values[arg.0].value {
-            ValueDatum::Argument(BlockArgument { block, idx, ty: _ })
-                if block == *self && idx < context.blocks[self.0].args.len() =>
-            {
+            ValueDatum::Argument(BlockArgument {
+                block,
+                idx,
+                ty: _,
+                is_immutable: _,
+            }) if block == *self && idx < context.blocks[self.0].args.len() => {
                 context.blocks[self.0].args[idx] = arg;
             }
             _ => panic!("Inconsistent block argument being set"),
@@ -164,9 +170,12 @@ impl Block {
     /// Add a block argument, asserts that `arg` is suitable here.
     pub fn add_arg(&self, context: &mut Context, arg: Value) {
         match context.values[arg.0].value {
-            ValueDatum::Argument(BlockArgument { block, idx, ty: _ })
-                if block == *self && idx == context.blocks[self.0].args.len() =>
-            {
+            ValueDatum::Argument(BlockArgument {
+                block,
+                idx,
+                ty: _,
+                is_immutable: _,
+            }) if block == *self && idx == context.blocks[self.0].args.len() => {
                 context.blocks[self.0].args.push(arg);
             }
             _ => panic!("Inconsistent block argument being added"),
@@ -518,6 +527,7 @@ impl Block {
                         block,
                         idx: _,
                         ty: _,
+                        is_immutable: _,
                     }) => {
                         // We modify the Value in place to be a BlockArgument for the new block.
                         *block = new_block;

sway-ir/src/block.rs

@@ -114,6 +114,7 @@ impl Function {
                             block: entry_block,
                             idx,
                             ty,
+                            is_immutable: false,
                         },
                     )
                     .add_metadatum(context, arg_metadata),
@@ -385,6 +386,16 @@ impl Function {
         context.functions[self.0].arguments.iter()
     }
 
+    /// Is argument `i` marked immutable?
+    pub fn is_arg_immutable(&self, context: &Context, i: usize) -> bool {
+        if let Some((_, val)) = context.functions[self.0].arguments.get(i) {
+            if let ValueDatum::Argument(arg) = &context.values[val.0].value {
+                return arg.is_immutable;
+            }
+        }
+        false
+    }
+
     /// Get a pointer to a local value by name, if found.
     pub fn get_local_var(&self, context: &Context, name: &str) -> Option<LocalVar> {
         context.functions[self.0].local_storage.get(name).copied()

sway-ir/src/function.rs

@@ -15,6 +15,8 @@
 
 pub mod arg_demotion;
 pub use arg_demotion::*;
+pub mod arg_mutability_tagger;
+pub use arg_mutability_tagger::*;
 pub mod const_demotion;
 pub use const_demotion::*;
 pub mod constants;