Adding IR printing functionality to the PassManager

[lima-limon-inc]

Usage

This PR implements the IR printing functionality, which can enabled via the use of flags passed to the compiler. The flags it introduces are:
-Z print-ir-after-all, -Z print-ir-after-pass and -Z print-ir-after-modified.

• print-ir-after-all: This enables IR printing for every pass.
• print-ir-after-pass: This enables IR printing for a selected number passes.
  • Those passes have to be passed as a comma separated string after an equal sign, like so:
  • -Z print-ir-after-pass=canonicalizer,lift-control-flow
• print-if-after-modified: This will only allow a pass to print the IR if it modifies the IR it received as input.

Here's an example output of the usage of these flags, these CLI examples are using the fib.rs available in the Miden book. Do note that the output here is excluding all the non-Print output, in reality the compiler is way more verbose.

Print after every pass

print-ir-after-all will enable IR printing after every compiler pass.

Click here to see the CLI command

midenc compile  --emit masm=wasm_fib.masm,masp fib.wasm -Z print-ir-after-all


[TRACE midenc_hir::pass] Before the Pipeline Collection: [builtin.component] pass
[TRACE printer] builtin.world  {
      builtin.component root_ns:root@1.0.0 {
          builtin.module public @wasm_fib {
              public builtin.function @fib(v0: i32) -> i32 {
              ^block4(v0: i32):
                  v2 = arith.constant 0 : i32;
                  v3 = arith.constant 0 : i32;
                  v4 = arith.constant 1 : i32;
                  cf.br ^block6(v4, v0, v3);
              ^block5(v1: i32):
  
              ^block6(v6: i32, v7: i32, v10: i32):
                  v8 = arith.constant 0 : i32;
                  v9 = arith.neq v7, v8 : i1;
                  cf.cond_br v9 ^block8, ^block9;
              ^block7(v5: i32):
  
              ^block8:
                  v11 = arith.constant -1 : i32;
                  v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
                  v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
                  cf.br ^block6(v13, v12, v6);
              ^block9:
                  builtin.ret v10;
              };
  
              builtin.global_variable private @#__stack_pointer : i32 {
                  builtin.ret_imm 1048576;
              };
          };
      };
  };
[TRACE midenc_hir::pass] Before the Pipeline Collection: [builtin.module] pass
[TRACE printer] builtin.component root_ns:root@1.0.0 {
      builtin.module public @wasm_fib {
          public builtin.function @fib(v0: i32) -> i32 {
          ^block4(v0: i32):
              v2 = arith.constant 0 : i32;
              v3 = arith.constant 0 : i32;
              v4 = arith.constant 1 : i32;
              cf.br ^block6(v4, v0, v3);
          ^block5(v1: i32):
  
          ^block6(v6: i32, v7: i32, v10: i32):
              v8 = arith.constant 0 : i32;
              v9 = arith.neq v7, v8 : i1;
              cf.cond_br v9 ^block8, ^block9;
          ^block7(v5: i32):
  
          ^block8:
              v11 = arith.constant -1 : i32;
              v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
              v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
              cf.br ^block6(v13, v12, v6);
          ^block9:
              builtin.ret v10;
          };
  
          builtin.global_variable private @#__stack_pointer : i32 {
              builtin.ret_imm 1048576;
          };
      };
  };
[TRACE midenc_hir::pass] Before the Pipeline Collection: [builtin.function] pass
[TRACE printer] builtin.module public @wasm_fib {
      public builtin.function @fib(v0: i32) -> i32 {
      ^block4(v0: i32):
          v2 = arith.constant 0 : i32;
          v3 = arith.constant 0 : i32;
          v4 = arith.constant 1 : i32;
          cf.br ^block6(v4, v0, v3);
      ^block5(v1: i32):
  
      ^block6(v6: i32, v7: i32, v10: i32):
          v8 = arith.constant 0 : i32;
          v9 = arith.neq v7, v8 : i1;
          cf.cond_br v9 ^block8, ^block9;
      ^block7(v5: i32):
  
      ^block8:
          v11 = arith.constant -1 : i32;
          v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
          v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
          cf.br ^block6(v13, v12, v6);
      ^block9:
          builtin.ret v10;
      };
  
      builtin.global_variable private @#__stack_pointer : i32 {
          builtin.ret_imm 1048576;
      };
  };
[TRACE midenc_hir::pass] Before the canonicalizer pass
[TRACE printer] public builtin.function @fib(v0: i32) -> i32 {
  ^block4(v0: i32):
      v2 = arith.constant 0 : i32;
      v3 = arith.constant 0 : i32;
      v4 = arith.constant 1 : i32;
      cf.br ^block6(v4, v0, v3);
  ^block5(v1: i32):
  
  ^block6(v6: i32, v7: i32, v10: i32):
      v8 = arith.constant 0 : i32;
      v9 = arith.neq v7, v8 : i1;
      cf.cond_br v9 ^block8, ^block9;
  ^block7(v5: i32):
  
  ^block8:
      v11 = arith.constant -1 : i32;
      v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
      v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
      cf.br ^block6(v13, v12, v6);
  ^block9:
      builtin.ret v10;
  };
[TRACE midenc_hir::pass] After the canonicalizer pass
[TRACE printer] public builtin.function @fib(v0: i32) -> i32 {
  ^block4(v0: i32):
      v11 = arith.constant -1 : i32;
      v2 = arith.constant 0 : i32;
      v4 = arith.constant 1 : i32;
      cf.br ^block6(v4, v0, v2);
  ^block6(v6: i32, v7: i32, v10: i32):
      v9 = arith.neq v7, v2 : i1;
      cf.cond_br v9 ^block8, ^block9;
  ^block8:
      v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
      v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
      cf.br ^block6(v13, v12, v6);
  ^block9:
      builtin.ret v10;
  };
[TRACE midenc_hir::pass] Before the lift-control-flow pass
[TRACE printer] public builtin.function @fib(v0: i32) -> i32 {
  ^block4(v0: i32):
      v11 = arith.constant -1 : i32;
      v2 = arith.constant 0 : i32;
      v4 = arith.constant 1 : i32;
      cf.br ^block6(v4, v0, v2);
  ^block6(v6: i32, v7: i32, v10: i32):
      v9 = arith.neq v7, v2 : i1;
      cf.cond_br v9 ^block8, ^block9;
  ^block8:
      v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
      v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
      cf.br ^block6(v13, v12, v6);
  ^block9:
      builtin.ret v10;
  };
[TRACE midenc_hir::pass] After the lift-control-flow pass
[TRACE printer] public builtin.function @fib(v0: i32) -> i32 {
  ^block4(v0: i32):
      v22 = ub.poison i32 : i32;
      v21 = arith.constant 1 : u32;
      v15 = arith.constant 0 : u32;
      v11 = arith.constant -1 : i32;
      v2 = arith.constant 0 : i32;
      v4 = arith.constant 1 : i32;
      v32, v33, v34, v35 = scf.while v4, v0, v2, v22 : i32, i32, i32, i32 {
      ^block6(v6: i32, v7: i32, v10: i32, v27: i32):
          v9 = arith.neq v7, v2 : i1;
          v45, v46, v47, v48, v49 = scf.if v9 : i32, i32, i32, u32, u32 {
          ^block8:
              v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
              v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
              scf.yield v13, v12, v6, v15, v21;
          } else {
          ^block16:
              scf.yield v22, v22, v22, v21, v15;
          };
          v44 = arith.trunc v49 : i1;
          scf.condition v44, v45, v46, v47, v10;
      } do {
      ^block15(v40: i32, v41: i32, v42: i32, v43: i32):
          scf.yield v40, v41, v42, v43;
      };
      builtin.ret v35;
  };
[TRACE midenc_hir::pass] Before the canonicalizer pass
[TRACE printer] public builtin.function @fib(v0: i32) -> i32 {
  ^block4(v0: i32):
      v22 = ub.poison i32 : i32;
      v21 = arith.constant 1 : u32;
      v15 = arith.constant 0 : u32;
      v11 = arith.constant -1 : i32;
      v2 = arith.constant 0 : i32;
      v4 = arith.constant 1 : i32;
      v32, v33, v34, v35 = scf.while v4, v0, v2, v22 : i32, i32, i32, i32 {
      ^block6(v6: i32, v7: i32, v10: i32, v27: i32):
          v9 = arith.neq v7, v2 : i1;
          v45, v46, v47, v48, v49 = scf.if v9 : i32, i32, i32, u32, u32 {
          ^block8:
              v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
              v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
              scf.yield v13, v12, v6, v15, v21;
          } else {
          ^block16:
              scf.yield v22, v22, v22, v21, v15;
          };
          v44 = arith.trunc v49 : i1;
          scf.condition v44, v45, v46, v47, v10;
      } do {
      ^block15(v40: i32, v41: i32, v42: i32, v43: i32):
          scf.yield v40, v41, v42, v43;
      };
      builtin.ret v35;
  };
[TRACE midenc_hir::pass] After the canonicalizer pass
[TRACE printer] public builtin.function @fib(v0: i32) -> i32 {
  ^block4(v0: i32):
      v22 = ub.poison i32 : i32;
      v21 = arith.constant 1 : u32;
      v15 = arith.constant 0 : u32;
      v11 = arith.constant -1 : i32;
      v2 = arith.constant 0 : i32;
      v4 = arith.constant 1 : i32;
      v32, v33, v34, v35 = scf.while v4, v0, v2, v22 : i32, i32, i32, i32 {
      ^block6(v6: i32, v7: i32, v10: i32, v27: i32):
          v9 = arith.neq v7, v2 : i1;
          v45, v46, v47, v48, v49 = scf.if v9 : i32, i32, i32, u32, u32 {
          ^block8:
              v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
              v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
              scf.yield v13, v12, v6, v15, v21;
          } else {
          ^block16:
              scf.yield v22, v22, v22, v21, v15;
          };
          v44 = arith.trunc v49 : i1;
          scf.condition v44, v45, v46, v47, v10;
      } do {
      ^block15(v40: i32, v41: i32, v42: i32, v43: i32):
          scf.yield v40, v41, v42, v43;
      };
      builtin.ret v35;
  };
[TRACE midenc_hir::pass] Before the sink-operand-defs pass
[TRACE printer] public builtin.function @fib(v0: i32) -> i32 {
  ^block4(v0: i32):
      v22 = ub.poison i32 : i32;
      v21 = arith.constant 1 : u32;
      v15 = arith.constant 0 : u32;
      v11 = arith.constant -1 : i32;
      v2 = arith.constant 0 : i32;
      v4 = arith.constant 1 : i32;
      v32, v33, v34, v35 = scf.while v4, v0, v2, v22 : i32, i32, i32, i32 {
      ^block6(v6: i32, v7: i32, v10: i32, v27: i32):
          v9 = arith.neq v7, v2 : i1;
          v45, v46, v47, v48, v49 = scf.if v9 : i32, i32, i32, u32, u32 {
          ^block8:
              v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
              v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
              scf.yield v13, v12, v6, v15, v21;
          } else {
          ^block16:
              scf.yield v22, v22, v22, v21, v15;
          };
          v44 = arith.trunc v49 : i1;
          scf.condition v44, v45, v46, v47, v10;
      } do {
      ^block15(v40: i32, v41: i32, v42: i32, v43: i32):
          scf.yield v40, v41, v42, v43;
      };
      builtin.ret v35;
  };
[TRACE midenc_hir::pass] After the sink-operand-defs pass
[TRACE printer] public builtin.function @fib(v0: i32) -> i32 {
  ^block4(v0: i32):
      v22 = ub.poison i32 : i32;
      v2 = arith.constant 0 : i32;
      v4 = arith.constant 1 : i32;
      v32, v33, v34, v35 = scf.while v4, v0, v2, v22 : i32, i32, i32, i32 {
      ^block6(v6: i32, v7: i32, v10: i32, v27: i32):
          v53 = arith.constant 0 : i32;
          v9 = arith.neq v7, v53 : i1;
          v45, v46, v47, v48, v49 = scf.if v9 : i32, i32, i32, u32, u32 {
          ^block8:
              v21 = arith.constant 1 : u32;
              v15 = arith.constant 0 : u32;
              v11 = arith.constant -1 : i32;
              v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
              v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
              scf.yield v13, v12, v6, v15, v21;
          } else {
          ^block16:
              v50 = arith.constant 0 : u32;
              v51 = arith.constant 1 : u32;
              v52 = ub.poison i32 : i32;
              scf.yield v52, v52, v52, v51, v50;
          };
          v44 = arith.trunc v49 : i1;
          scf.condition v44, v45, v46, v47, v10;
      } do {
      ^block15(v40: i32, v41: i32, v42: i32, v43: i32):
          scf.yield v40, v41, v42, v43;
      };
      builtin.ret v35;
  };
[TRACE midenc_hir::pass] Before the control-flow-sink pass
[TRACE printer] public builtin.function @fib(v0: i32) -> i32 {
  ^block4(v0: i32):
      v22 = ub.poison i32 : i32;
      v2 = arith.constant 0 : i32;
      v4 = arith.constant 1 : i32;
      v32, v33, v34, v35 = scf.while v4, v0, v2, v22 : i32, i32, i32, i32 {
      ^block6(v6: i32, v7: i32, v10: i32, v27: i32):
          v53 = arith.constant 0 : i32;
          v9 = arith.neq v7, v53 : i1;
          v45, v46, v47, v48, v49 = scf.if v9 : i32, i32, i32, u32, u32 {
          ^block8:
              v21 = arith.constant 1 : u32;
              v15 = arith.constant 0 : u32;
              v11 = arith.constant -1 : i32;
              v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
              v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
              scf.yield v13, v12, v6, v15, v21;
          } else {
          ^block16:
              v50 = arith.constant 0 : u32;
              v51 = arith.constant 1 : u32;
              v52 = ub.poison i32 : i32;
              scf.yield v52, v52, v52, v51, v50;
          };
          v44 = arith.trunc v49 : i1;
          scf.condition v44, v45, v46, v47, v10;
      } do {
      ^block15(v40: i32, v41: i32, v42: i32, v43: i32):
          scf.yield v40, v41, v42, v43;
      };
      builtin.ret v35;
  };
[TRACE midenc_hir::pass] After the control-flow-sink pass
[TRACE printer] public builtin.function @fib(v0: i32) -> i32 {
  ^block4(v0: i32):
      v22 = ub.poison i32 : i32;
      v2 = arith.constant 0 : i32;
      v4 = arith.constant 1 : i32;
      v32, v33, v34, v35 = scf.while v4, v0, v2, v22 : i32, i32, i32, i32 {
      ^block6(v6: i32, v7: i32, v10: i32, v27: i32):
          v53 = arith.constant 0 : i32;
          v9 = arith.neq v7, v53 : i1;
          v45, v46, v47, v48, v49 = scf.if v9 : i32, i32, i32, u32, u32 {
          ^block8:
              v21 = arith.constant 1 : u32;
              v15 = arith.constant 0 : u32;
              v11 = arith.constant -1 : i32;
              v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
              v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
              scf.yield v13, v12, v6, v15, v21;
          } else {
          ^block16:
              v50 = arith.constant 0 : u32;
              v51 = arith.constant 1 : u32;
              v52 = ub.poison i32 : i32;
              scf.yield v52, v52, v52, v51, v50;
          };
          v44 = arith.trunc v49 : i1;
          scf.condition v44, v45, v46, v47, v10;
      } do {
      ^block15(v40: i32, v41: i32, v42: i32, v43: i32):
          scf.yield v40, v41, v42, v43;
      };
      builtin.ret v35;
  };
[TRACE midenc_hir::pass] Before the transform-spills pass
[TRACE printer] public builtin.function @fib(v0: i32) -> i32 {
  ^block4(v0: i32):
      v22 = ub.poison i32 : i32;
      v2 = arith.constant 0 : i32;
      v4 = arith.constant 1 : i32;
      v32, v33, v34, v35 = scf.while v4, v0, v2, v22 : i32, i32, i32, i32 {
      ^block6(v6: i32, v7: i32, v10: i32, v27: i32):
          v53 = arith.constant 0 : i32;
          v9 = arith.neq v7, v53 : i1;
          v45, v46, v47, v48, v49 = scf.if v9 : i32, i32, i32, u32, u32 {
          ^block8:
              v21 = arith.constant 1 : u32;
              v15 = arith.constant 0 : u32;
              v11 = arith.constant -1 : i32;
              v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
              v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
              scf.yield v13, v12, v6, v15, v21;
          } else {
          ^block16:
              v50 = arith.constant 0 : u32;
              v51 = arith.constant 1 : u32;
              v52 = ub.poison i32 : i32;
              scf.yield v52, v52, v52, v51, v50;
          };
          v44 = arith.trunc v49 : i1;
          scf.condition v44, v45, v46, v47, v10;
      } do {
      ^block15(v40: i32, v41: i32, v42: i32, v43: i32):
          scf.yield v40, v41, v42, v43;
      };
      builtin.ret v35;
  };
[TRACE midenc_hir::pass] After the transform-spills pass
[TRACE printer] public builtin.function @fib(v0: i32) -> i32 {
  ^block4(v0: i32):
      v22 = ub.poison i32 : i32;
      v2 = arith.constant 0 : i32;
      v4 = arith.constant 1 : i32;
      v32, v33, v34, v35 = scf.while v4, v0, v2, v22 : i32, i32, i32, i32 {
      ^block6(v6: i32, v7: i32, v10: i32, v27: i32):
          v53 = arith.constant 0 : i32;
          v9 = arith.neq v7, v53 : i1;
          v45, v46, v47, v48, v49 = scf.if v9 : i32, i32, i32, u32, u32 {
          ^block8:
              v21 = arith.constant 1 : u32;
              v15 = arith.constant 0 : u32;
              v11 = arith.constant -1 : i32;
              v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
              v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
              scf.yield v13, v12, v6, v15, v21;
          } else {
          ^block16:
              v50 = arith.constant 0 : u32;
              v51 = arith.constant 1 : u32;
              v52 = ub.poison i32 : i32;
              scf.yield v52, v52, v52, v51, v50;
          };
          v44 = arith.trunc v49 : i1;
          scf.condition v44, v45, v46, v47, v10;
      } do {
      ^block15(v40: i32, v41: i32, v42: i32, v43: i32):
          scf.yield v40, v41, v42, v43;
      };
      builtin.ret v35;
  };
[TRACE midenc_hir::pass] After the Pipeline Collection: [builtin.function] pass
[TRACE printer] builtin.module public @wasm_fib {
      public builtin.function @fib(v0: i32) -> i32 {
      ^block4(v0: i32):
          v22 = ub.poison i32 : i32;
          v2 = arith.constant 0 : i32;
          v4 = arith.constant 1 : i32;
          v32, v33, v34, v35 = scf.while v4, v0, v2, v22 : i32, i32, i32, i32 {
          ^block6(v6: i32, v7: i32, v10: i32, v27: i32):
              v53 = arith.constant 0 : i32;
              v9 = arith.neq v7, v53 : i1;
              v45, v46, v47, v48, v49 = scf.if v9 : i32, i32, i32, u32, u32 {
              ^block8:
                  v21 = arith.constant 1 : u32;
                  v15 = arith.constant 0 : u32;
                  v11 = arith.constant -1 : i32;
                  v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
                  v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
                  scf.yield v13, v12, v6, v15, v21;
              } else {
              ^block16:
                  v50 = arith.constant 0 : u32;
                  v51 = arith.constant 1 : u32;
                  v52 = ub.poison i32 : i32;
                  scf.yield v52, v52, v52, v51, v50;
              };
              v44 = arith.trunc v49 : i1;
              scf.condition v44, v45, v46, v47, v10;
          } do {
          ^block15(v40: i32, v41: i32, v42: i32, v43: i32):
              scf.yield v40, v41, v42, v43;
          };
          builtin.ret v35;
      };
  
      builtin.global_variable private @#__stack_pointer : i32 {
          builtin.ret_imm 1048576;
      };
  };
[TRACE midenc_hir::pass] After the Pipeline Collection: [builtin.module] pass
[TRACE printer] builtin.component root_ns:root@1.0.0 {
      builtin.module public @wasm_fib {
          public builtin.function @fib(v0: i32) -> i32 {
          ^block4(v0: i32):
              v22 = ub.poison i32 : i32;
              v2 = arith.constant 0 : i32;
              v4 = arith.constant 1 : i32;
              v32, v33, v34, v35 = scf.while v4, v0, v2, v22 : i32, i32, i32, i32 {
              ^block6(v6: i32, v7: i32, v10: i32, v27: i32):
                  v53 = arith.constant 0 : i32;
                  v9 = arith.neq v7, v53 : i1;
                  v45, v46, v47, v48, v49 = scf.if v9 : i32, i32, i32, u32, u32 {
                  ^block8:
                      v21 = arith.constant 1 : u32;
                      v15 = arith.constant 0 : u32;
                      v11 = arith.constant -1 : i32;
                      v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
                      v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
                      scf.yield v13, v12, v6, v15, v21;
                  } else {
                  ^block16:
                      v50 = arith.constant 0 : u32;
                      v51 = arith.constant 1 : u32;
                      v52 = ub.poison i32 : i32;
                      scf.yield v52, v52, v52, v51, v50;
                  };
                  v44 = arith.trunc v49 : i1;
                  scf.condition v44, v45, v46, v47, v10;
              } do {
              ^block15(v40: i32, v41: i32, v42: i32, v43: i32):
                  scf.yield v40, v41, v42, v43;
              };
              builtin.ret v35;
          };
  
          builtin.global_variable private @#__stack_pointer : i32 {
              builtin.ret_imm 1048576;
          };
      };
  };
[TRACE midenc_hir::pass] Before the Pipeline Collection: [builtin.function] pass
[TRACE printer] builtin.component root_ns:root@1.0.0 {
      builtin.module public @wasm_fib {
          public builtin.function @fib(v0: i32) -> i32 {
          ^block4(v0: i32):
              v22 = ub.poison i32 : i32;
              v2 = arith.constant 0 : i32;
              v4 = arith.constant 1 : i32;
              v32, v33, v34, v35 = scf.while v4, v0, v2, v22 : i32, i32, i32, i32 {
              ^block6(v6: i32, v7: i32, v10: i32, v27: i32):
                  v53 = arith.constant 0 : i32;
                  v9 = arith.neq v7, v53 : i1;
                  v45, v46, v47, v48, v49 = scf.if v9 : i32, i32, i32, u32, u32 {
                  ^block8:
                      v21 = arith.constant 1 : u32;
                      v15 = arith.constant 0 : u32;
                      v11 = arith.constant -1 : i32;
                      v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
                      v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
                      scf.yield v13, v12, v6, v15, v21;
                  } else {
                  ^block16:
                      v50 = arith.constant 0 : u32;
                      v51 = arith.constant 1 : u32;
                      v52 = ub.poison i32 : i32;
                      scf.yield v52, v52, v52, v51, v50;
                  };
                  v44 = arith.trunc v49 : i1;
                  scf.condition v44, v45, v46, v47, v10;
              } do {
              ^block15(v40: i32, v41: i32, v42: i32, v43: i32):
                  scf.yield v40, v41, v42, v43;
              };
              builtin.ret v35;
          };
  
          builtin.global_variable private @#__stack_pointer : i32 {
              builtin.ret_imm 1048576;
          };
      };
  };
[TRACE midenc_hir::pass] After the Pipeline Collection: [builtin.function] pass
[TRACE printer] builtin.component root_ns:root@1.0.0 {
      builtin.module public @wasm_fib {
          public builtin.function @fib(v0: i32) -> i32 {
          ^block4(v0: i32):
              v22 = ub.poison i32 : i32;
              v2 = arith.constant 0 : i32;
              v4 = arith.constant 1 : i32;
              v32, v33, v34, v35 = scf.while v4, v0, v2, v22 : i32, i32, i32, i32 {
              ^block6(v6: i32, v7: i32, v10: i32, v27: i32):
                  v53 = arith.constant 0 : i32;
                  v9 = arith.neq v7, v53 : i1;
                  v45, v46, v47, v48, v49 = scf.if v9 : i32, i32, i32, u32, u32 {
                  ^block8:
                      v21 = arith.constant 1 : u32;
                      v15 = arith.constant 0 : u32;
                      v11 = arith.constant -1 : i32;
                      v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
                      v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
                      scf.yield v13, v12, v6, v15, v21;
                  } else {
                  ^block16:
                      v50 = arith.constant 0 : u32;
                      v51 = arith.constant 1 : u32;
                      v52 = ub.poison i32 : i32;
                      scf.yield v52, v52, v52, v51, v50;
                  };
                  v44 = arith.trunc v49 : i1;
                  scf.condition v44, v45, v46, v47, v10;
              } do {
              ^block15(v40: i32, v41: i32, v42: i32, v43: i32):
                  scf.yield v40, v41, v42, v43;
              };
              builtin.ret v35;
          };
  
          builtin.global_variable private @#__stack_pointer : i32 {
              builtin.ret_imm 1048576;
          };
      };
  };
[TRACE midenc_hir::pass] After the Pipeline Collection: [builtin.component] pass
[TRACE printer] builtin.world  {
      builtin.component root_ns:root@1.0.0 {
          builtin.module public @wasm_fib {
              public builtin.function @fib(v0: i32) -> i32 {
              ^block4(v0: i32):
                  v22 = ub.poison i32 : i32;
                  v2 = arith.constant 0 : i32;
                  v4 = arith.constant 1 : i32;
                  v32, v33, v34, v35 = scf.while v4, v0, v2, v22 : i32, i32, i32, i32 {
                  ^block6(v6: i32, v7: i32, v10: i32, v27: i32):
                      v53 = arith.constant 0 : i32;
                      v9 = arith.neq v7, v53 : i1;
                      v45, v46, v47, v48, v49 = scf.if v9 : i32, i32, i32, u32, u32 {
                      ^block8:
                          v21 = arith.constant 1 : u32;
                          v15 = arith.constant 0 : u32;
                          v11 = arith.constant -1 : i32;
                          v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
                          v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
                          scf.yield v13, v12, v6, v15, v21;
                      } else {
                      ^block16:
                          v50 = arith.constant 0 : u32;
                          v51 = arith.constant 1 : u32;
                          v52 = ub.poison i32 : i32;
                          scf.yield v52, v52, v52, v51, v50;
                      };
                      v44 = arith.trunc v49 : i1;
                      scf.condition v44, v45, v46, v47, v10;
                  } do {
                  ^block15(v40: i32, v41: i32, v42: i32, v43: i32):
                      scf.yield v40, v41, v42, v43;
                  };
                  builtin.ret v35;
              };
  
              builtin.global_variable private @#__stack_pointer : i32 {
                  builtin.ret_imm 1048576;
              };
          };
      };
  };

This output, by itself, can be *quite* verbose, since every pass will print the IR *even if* no modification has been made.

In order to reduce noise, the -Z print-ir-after-modified can be used:

Click here to see the CLI command

midenc compile  --emit masm=wasm_fib.masm,masp fib.wasm -Z print-ir-after-all -Z print-ir-after-modified

[TRACE midenc_hir::pass] IR before the pass pipeline
[TRACE printer] builtin.world  {
      builtin.component root_ns:root@1.0.0 {
          builtin.module public @wasm_fib {
              public builtin.function @fib(v0: i32) -> i32 {
              ^block4(v0: i32):
                  v2 = arith.constant 0 : i32;
                  v3 = arith.constant 0 : i32;
                  v4 = arith.constant 1 : i32;
                  cf.br ^block6(v4, v0, v3);
              ^block5(v1: i32):
  
              ^block6(v6: i32, v7: i32, v10: i32):
                  v8 = arith.constant 0 : i32;
                  v9 = arith.neq v7, v8 : i1;
                  cf.cond_br v9 ^block8, ^block9;
              ^block7(v5: i32):
  
              ^block8:
                  v11 = arith.constant -1 : i32;
                  v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
                  v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
                  cf.br ^block6(v13, v12, v6);
              ^block9:
                  builtin.ret v10;
              };
  
              builtin.global_variable private @#__stack_pointer : i32 {
                  builtin.ret_imm 1048576;
              };
          };
      };
  };
[TRACE midenc_hir::pass] IR before the pass pipeline
[TRACE printer] builtin.component root_ns:root@1.0.0 {
      builtin.module public @wasm_fib {
          public builtin.function @fib(v0: i32) -> i32 {
          ^block4(v0: i32):
              v2 = arith.constant 0 : i32;
              v3 = arith.constant 0 : i32;
              v4 = arith.constant 1 : i32;
              cf.br ^block6(v4, v0, v3);
          ^block5(v1: i32):
  
          ^block6(v6: i32, v7: i32, v10: i32):
              v8 = arith.constant 0 : i32;
              v9 = arith.neq v7, v8 : i1;
              cf.cond_br v9 ^block8, ^block9;
          ^block7(v5: i32):
  
          ^block8:
              v11 = arith.constant -1 : i32;
              v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
              v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
              cf.br ^block6(v13, v12, v6);
          ^block9:
              builtin.ret v10;
          };
  
          builtin.global_variable private @#__stack_pointer : i32 {
              builtin.ret_imm 1048576;
          };
      };
  };
[TRACE midenc_hir::pass] IR before the pass pipeline
[TRACE printer] builtin.module public @wasm_fib {
      public builtin.function @fib(v0: i32) -> i32 {
      ^block4(v0: i32):
          v2 = arith.constant 0 : i32;
          v3 = arith.constant 0 : i32;
          v4 = arith.constant 1 : i32;
          cf.br ^block6(v4, v0, v3);
      ^block5(v1: i32):
  
      ^block6(v6: i32, v7: i32, v10: i32):
          v8 = arith.constant 0 : i32;
          v9 = arith.neq v7, v8 : i1;
          cf.cond_br v9 ^block8, ^block9;
      ^block7(v5: i32):
  
      ^block8:
          v11 = arith.constant -1 : i32;
          v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
          v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
          cf.br ^block6(v13, v12, v6);
      ^block9:
          builtin.ret v10;
      };
  
      builtin.global_variable private @#__stack_pointer : i32 {
          builtin.ret_imm 1048576;
      };
  };
[TRACE midenc_hir::pass] IR before the pass pipeline
[TRACE printer] public builtin.function @fib(v0: i32) -> i32 {
  ^block4(v0: i32):
      v2 = arith.constant 0 : i32;
      v3 = arith.constant 0 : i32;
      v4 = arith.constant 1 : i32;
      cf.br ^block6(v4, v0, v3);
  ^block5(v1: i32):
  
  ^block6(v6: i32, v7: i32, v10: i32):
      v8 = arith.constant 0 : i32;
      v9 = arith.neq v7, v8 : i1;
      cf.cond_br v9 ^block8, ^block9;
  ^block7(v5: i32):
  
  ^block8:
      v11 = arith.constant -1 : i32;
      v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
      v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
      cf.br ^block6(v13, v12, v6);
  ^block9:
      builtin.ret v10;
  };
[TRACE midenc_hir::pass] After the canonicalizer pass
[TRACE printer] public builtin.function @fib(v0: i32) -> i32 {
  ^block4(v0: i32):
      v11 = arith.constant -1 : i32;
      v2 = arith.constant 0 : i32;
      v4 = arith.constant 1 : i32;
      cf.br ^block6(v4, v0, v2);
  ^block6(v6: i32, v7: i32, v10: i32):
      v9 = arith.neq v7, v2 : i1;
      cf.cond_br v9 ^block8, ^block9;
  ^block8:
      v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
      v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
      cf.br ^block6(v13, v12, v6);
  ^block9:
      builtin.ret v10;
  };
[TRACE midenc_hir::pass] After the lift-control-flow pass
[TRACE printer] public builtin.function @fib(v0: i32) -> i32 {
  ^block4(v0: i32):
      v22 = ub.poison i32 : i32;
      v21 = arith.constant 1 : u32;
      v15 = arith.constant 0 : u32;
      v11 = arith.constant -1 : i32;
      v2 = arith.constant 0 : i32;
      v4 = arith.constant 1 : i32;
      v32, v33, v34, v35 = scf.while v4, v0, v2, v22 : i32, i32, i32, i32 {
      ^block6(v6: i32, v7: i32, v10: i32, v27: i32):
          v9 = arith.neq v7, v2 : i1;
          v45, v46, v47, v48, v49 = scf.if v9 : i32, i32, i32, u32, u32 {
          ^block8:
              v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
              v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
              scf.yield v13, v12, v6, v15, v21;
          } else {
          ^block16:
              scf.yield v22, v22, v22, v21, v15;
          };
          v44 = arith.trunc v49 : i1;
          scf.condition v44, v45, v46, v47, v10;
      } do {
      ^block15(v40: i32, v41: i32, v42: i32, v43: i32):
          scf.yield v40, v41, v42, v43;
      };
      builtin.ret v35;
  };
[TRACE midenc_hir::pass] After the sink-operand-defs pass
[TRACE printer] public builtin.function @fib(v0: i32) -> i32 {
  ^block4(v0: i32):
      v22 = ub.poison i32 : i32;
      v2 = arith.constant 0 : i32;
      v4 = arith.constant 1 : i32;
      v32, v33, v34, v35 = scf.while v4, v0, v2, v22 : i32, i32, i32, i32 {
      ^block6(v6: i32, v7: i32, v10: i32, v27: i32):
          v53 = arith.constant 0 : i32;
          v9 = arith.neq v7, v53 : i1;
          v45, v46, v47, v48, v49 = scf.if v9 : i32, i32, i32, u32, u32 {
          ^block8:
              v21 = arith.constant 1 : u32;
              v15 = arith.constant 0 : u32;
              v11 = arith.constant -1 : i32;
              v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
              v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
              scf.yield v13, v12, v6, v15, v21;
          } else {
          ^block16:
              v50 = arith.constant 0 : u32;
              v51 = arith.constant 1 : u32;
              v52 = ub.poison i32 : i32;
              scf.yield v52, v52, v52, v51, v50;
          };
          v44 = arith.trunc v49 : i1;
          scf.condition v44, v45, v46, v47, v10;
      } do {
      ^block15(v40: i32, v41: i32, v42: i32, v43: i32):
          scf.yield v40, v41, v42, v43;
      };
      builtin.ret v35;
  };

Now, only passes that modify the IR will actually print. In the case of fib.rs those pases are: canonicalizer, lift-control-flow and sink-operand-defs.

Print after a subset of passes

And let's say that one is only interested in a subset of passes. For this, the print-ir-after-pass is added.
The following will only print the IR after passes: control-flow-sink, canonicalizer and lift-control-flow-pass.

Click here to see the CLI command

midenc compile  --emit masm=wasm_fib.masm,masp fib.wasm -Z print-ir-after-pass=canonicalizer, lift-control-flow-pass, control-flow-sink

[TRACE midenc_hir::pass] Before the canonicalizer pass
[TRACE printer] public builtin.function @fib(v0: i32) -> i32 {
  ^block4(v0: i32):
      v2 = arith.constant 0 : i32;
      v3 = arith.constant 0 : i32;
      v4 = arith.constant 1 : i32;
      cf.br ^block6(v4, v0, v3);
  ^block5(v1: i32):
  
  ^block6(v6: i32, v7: i32, v10: i32):
      v8 = arith.constant 0 : i32;
      v9 = arith.neq v7, v8 : i1;
      cf.cond_br v9 ^block8, ^block9;
  ^block7(v5: i32):
  
  ^block8:
      v11 = arith.constant -1 : i32;
      v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
      v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
      cf.br ^block6(v13, v12, v6);
  ^block9:
      builtin.ret v10;
  };
[TRACE midenc_hir::pass] After the canonicalizer pass
[TRACE printer] public builtin.function @fib(v0: i32) -> i32 {
  ^block4(v0: i32):
      v11 = arith.constant -1 : i32;
      v2 = arith.constant 0 : i32;
      v4 = arith.constant 1 : i32;
      cf.br ^block6(v4, v0, v2);
  ^block6(v6: i32, v7: i32, v10: i32):
      v9 = arith.neq v7, v2 : i1;
      cf.cond_br v9 ^block8, ^block9;
  ^block8:
      v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
      v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
      cf.br ^block6(v13, v12, v6);
  ^block9:
      builtin.ret v10;
  };
[TRACE midenc_hir::pass] Before the lift-control-flow pass
[TRACE printer] public builtin.function @fib(v0: i32) -> i32 {
  ^block4(v0: i32):
      v11 = arith.constant -1 : i32;
      v2 = arith.constant 0 : i32;
      v4 = arith.constant 1 : i32;
      cf.br ^block6(v4, v0, v2);
  ^block6(v6: i32, v7: i32, v10: i32):
      v9 = arith.neq v7, v2 : i1;
      cf.cond_br v9 ^block8, ^block9;
  ^block8:
      v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
      v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
      cf.br ^block6(v13, v12, v6);
  ^block9:
      builtin.ret v10;
  };
[TRACE midenc_hir::pass] After the lift-control-flow pass
[TRACE printer] public builtin.function @fib(v0: i32) -> i32 {
  ^block4(v0: i32):
      v22 = ub.poison i32 : i32;
      v21 = arith.constant 1 : u32;
      v15 = arith.constant 0 : u32;
      v11 = arith.constant -1 : i32;
      v2 = arith.constant 0 : i32;
      v4 = arith.constant 1 : i32;
      v32, v33, v34, v35 = scf.while v4, v0, v2, v22 : i32, i32, i32, i32 {
      ^block6(v6: i32, v7: i32, v10: i32, v27: i32):
          v9 = arith.neq v7, v2 : i1;
          v45, v46, v47, v48, v49 = scf.if v9 : i32, i32, i32, u32, u32 {
          ^block8:
              v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
              v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
              scf.yield v13, v12, v6, v15, v21;
          } else {
          ^block16:
              scf.yield v22, v22, v22, v21, v15;
          };
          v44 = arith.trunc v49 : i1;
          scf.condition v44, v45, v46, v47, v10;
      } do {
      ^block15(v40: i32, v41: i32, v42: i32, v43: i32):
          scf.yield v40, v41, v42, v43;
      };
      builtin.ret v35;
  };
[TRACE midenc_hir::pass] Before the canonicalizer pass
[TRACE printer] public builtin.function @fib(v0: i32) -> i32 {
  ^block4(v0: i32):
      v22 = ub.poison i32 : i32;
      v21 = arith.constant 1 : u32;
      v15 = arith.constant 0 : u32;
      v11 = arith.constant -1 : i32;
      v2 = arith.constant 0 : i32;
      v4 = arith.constant 1 : i32;
      v32, v33, v34, v35 = scf.while v4, v0, v2, v22 : i32, i32, i32, i32 {
      ^block6(v6: i32, v7: i32, v10: i32, v27: i32):
          v9 = arith.neq v7, v2 : i1;
          v45, v46, v47, v48, v49 = scf.if v9 : i32, i32, i32, u32, u32 {
          ^block8:
              v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
              v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
              scf.yield v13, v12, v6, v15, v21;
          } else {
          ^block16:
              scf.yield v22, v22, v22, v21, v15;
          };
          v44 = arith.trunc v49 : i1;
          scf.condition v44, v45, v46, v47, v10;
      } do {
      ^block15(v40: i32, v41: i32, v42: i32, v43: i32):
          scf.yield v40, v41, v42, v43;
      };
      builtin.ret v35;
  };
[TRACE midenc_hir::pass] After the canonicalizer pass
[TRACE printer] public builtin.function @fib(v0: i32) -> i32 {
  ^block4(v0: i32):
      v22 = ub.poison i32 : i32;
      v21 = arith.constant 1 : u32;
      v15 = arith.constant 0 : u32;
      v11 = arith.constant -1 : i32;
      v2 = arith.constant 0 : i32;
      v4 = arith.constant 1 : i32;
      v32, v33, v34, v35 = scf.while v4, v0, v2, v22 : i32, i32, i32, i32 {
      ^block6(v6: i32, v7: i32, v10: i32, v27: i32):
          v9 = arith.neq v7, v2 : i1;
          v45, v46, v47, v48, v49 = scf.if v9 : i32, i32, i32, u32, u32 {
          ^block8:
              v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
              v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
              scf.yield v13, v12, v6, v15, v21;
          } else {
          ^block16:
              scf.yield v22, v22, v22, v21, v15;
          };
          v44 = arith.trunc v49 : i1;
          scf.condition v44, v45, v46, v47, v10;
      } do {
      ^block15(v40: i32, v41: i32, v42: i32, v43: i32):
          scf.yield v40, v41, v42, v43;
      };
      builtin.ret v35;
  };
[TRACE midenc_hir::pass] Before the control-flow-sink pass
[TRACE printer] public builtin.function @fib(v0: i32) -> i32 {
  ^block4(v0: i32):
      v22 = ub.poison i32 : i32;
      v2 = arith.constant 0 : i32;
      v4 = arith.constant 1 : i32;
      v32, v33, v34, v35 = scf.while v4, v0, v2, v22 : i32, i32, i32, i32 {
      ^block6(v6: i32, v7: i32, v10: i32, v27: i32):
          v53 = arith.constant 0 : i32;
          v9 = arith.neq v7, v53 : i1;
          v45, v46, v47, v48, v49 = scf.if v9 : i32, i32, i32, u32, u32 {
          ^block8:
              v21 = arith.constant 1 : u32;
              v15 = arith.constant 0 : u32;
              v11 = arith.constant -1 : i32;
              v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
              v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
              scf.yield v13, v12, v6, v15, v21;
          } else {
          ^block16:
              v50 = arith.constant 0 : u32;
              v51 = arith.constant 1 : u32;
              v52 = ub.poison i32 : i32;
              scf.yield v52, v52, v52, v51, v50;
          };
          v44 = arith.trunc v49 : i1;
          scf.condition v44, v45, v46, v47, v10;
      } do {
      ^block15(v40: i32, v41: i32, v42: i32, v43: i32):
          scf.yield v40, v41, v42, v43;
      };
      builtin.ret v35;
  };
[TRACE midenc_hir::pass] After the control-flow-sink pass
[TRACE printer] public builtin.function @fib(v0: i32) -> i32 {
  ^block4(v0: i32):
      v22 = ub.poison i32 : i32;
      v2 = arith.constant 0 : i32;
      v4 = arith.constant 1 : i32;
      v32, v33, v34, v35 = scf.while v4, v0, v2, v22 : i32, i32, i32, i32 {
      ^block6(v6: i32, v7: i32, v10: i32, v27: i32):
          v53 = arith.constant 0 : i32;
          v9 = arith.neq v7, v53 : i1;
          v45, v46, v47, v48, v49 = scf.if v9 : i32, i32, i32, u32, u32 {
          ^block8:
              v21 = arith.constant 1 : u32;
              v15 = arith.constant 0 : u32;
              v11 = arith.constant -1 : i32;
              v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
              v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
              scf.yield v13, v12, v6, v15, v21;
          } else {
          ^block16:
              v50 = arith.constant 0 : u32;
              v51 = arith.constant 1 : u32;
              v52 = ub.poison i32 : i32;
              scf.yield v52, v52, v52, v51, v50;
          };
          v44 = arith.trunc v49 : i1;
          scf.condition v44, v45, v46, v47, v10;
      } do {
      ^block15(v40: i32, v41: i32, v42: i32, v43: i32):
          scf.yield v40, v41, v42, v43;
      };
      builtin.ret v35;
  };

Furthermore, this last flag can also be combined with the print-ir-after-modified flag. This combination will only print IR if one of the selected passes modifies the IR.

Click here to see the CLI command

midenc compile  --emit masm=wasm_fib.masm,masp fib.wasm -Z print-ir-after-pass=canonicalizer,lift-control-flow,control-flow-sink -Z print-ir-after-modified

[TRACE midenc_hir::pass] IR before the pass pipeline
[TRACE printer] builtin.world  {
      builtin.component root_ns:root@1.0.0 {
          builtin.module public @wasm_fib {
              public builtin.function @fib(v0: i32) -> i32 {
              ^block4(v0: i32):
                  v2 = arith.constant 0 : i32;
                  v3 = arith.constant 0 : i32;
                  v4 = arith.constant 1 : i32;
                  cf.br ^block6(v4, v0, v3);
              ^block5(v1: i32):
  
              ^block6(v6: i32, v7: i32, v10: i32):
                  v8 = arith.constant 0 : i32;
                  v9 = arith.neq v7, v8 : i1;
                  cf.cond_br v9 ^block8, ^block9;
              ^block7(v5: i32):
  
              ^block8:
                  v11 = arith.constant -1 : i32;
                  v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
                  v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
                  cf.br ^block6(v13, v12, v6);
              ^block9:
                  builtin.ret v10;
              };
  
              builtin.global_variable private @#__stack_pointer : i32 {
                  builtin.ret_imm 1048576;
              };
          };
      };
  };
[TRACE midenc_hir::pass] IR before the pass pipeline
[TRACE printer] builtin.component root_ns:root@1.0.0 {
      builtin.module public @wasm_fib {
          public builtin.function @fib(v0: i32) -> i32 {
          ^block4(v0: i32):
              v2 = arith.constant 0 : i32;
              v3 = arith.constant 0 : i32;
              v4 = arith.constant 1 : i32;
              cf.br ^block6(v4, v0, v3);
          ^block5(v1: i32):
  
          ^block6(v6: i32, v7: i32, v10: i32):
              v8 = arith.constant 0 : i32;
              v9 = arith.neq v7, v8 : i1;
              cf.cond_br v9 ^block8, ^block9;
          ^block7(v5: i32):
  
          ^block8:
              v11 = arith.constant -1 : i32;
              v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
              v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
              cf.br ^block6(v13, v12, v6);
          ^block9:
              builtin.ret v10;
          };
  
          builtin.global_variable private @#__stack_pointer : i32 {
              builtin.ret_imm 1048576;
          };
      };
  };
[TRACE midenc_hir::pass] IR before the pass pipeline
[TRACE printer] builtin.module public @wasm_fib {
      public builtin.function @fib(v0: i32) -> i32 {
      ^block4(v0: i32):
          v2 = arith.constant 0 : i32;
          v3 = arith.constant 0 : i32;
          v4 = arith.constant 1 : i32;
          cf.br ^block6(v4, v0, v3);
      ^block5(v1: i32):
  
      ^block6(v6: i32, v7: i32, v10: i32):
          v8 = arith.constant 0 : i32;
          v9 = arith.neq v7, v8 : i1;
          cf.cond_br v9 ^block8, ^block9;
      ^block7(v5: i32):
  
      ^block8:
          v11 = arith.constant -1 : i32;
          v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
          v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
          cf.br ^block6(v13, v12, v6);
      ^block9:
          builtin.ret v10;
      };
  
      builtin.global_variable private @#__stack_pointer : i32 {
          builtin.ret_imm 1048576;
      };
  };
[TRACE midenc_hir::pass] IR before the pass pipeline
[TRACE printer] public builtin.function @fib(v0: i32) -> i32 {
  ^block4(v0: i32):
      v2 = arith.constant 0 : i32;
      v3 = arith.constant 0 : i32;
      v4 = arith.constant 1 : i32;
      cf.br ^block6(v4, v0, v3);
  ^block5(v1: i32):
  
  ^block6(v6: i32, v7: i32, v10: i32):
      v8 = arith.constant 0 : i32;
      v9 = arith.neq v7, v8 : i1;
      cf.cond_br v9 ^block8, ^block9;
  ^block7(v5: i32):
  
  ^block8:
      v11 = arith.constant -1 : i32;
      v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
      v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
      cf.br ^block6(v13, v12, v6);
  ^block9:
      builtin.ret v10;
  };
[TRACE midenc_hir::pass] After the canonicalizer pass
[TRACE printer] public builtin.function @fib(v0: i32) -> i32 {
  ^block4(v0: i32):
      v11 = arith.constant -1 : i32;
      v2 = arith.constant 0 : i32;
      v4 = arith.constant 1 : i32;
      cf.br ^block6(v4, v0, v2);
  ^block6(v6: i32, v7: i32, v10: i32):
      v9 = arith.neq v7, v2 : i1;
      cf.cond_br v9 ^block8, ^block9;
  ^block8:
      v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
      v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
      cf.br ^block6(v13, v12, v6);
  ^block9:
      builtin.ret v10;
  };
[TRACE midenc_hir::pass] After the lift-control-flow pass
[TRACE printer] public builtin.function @fib(v0: i32) -> i32 {
  ^block4(v0: i32):
      v22 = ub.poison i32 : i32;
      v21 = arith.constant 1 : u32;
      v15 = arith.constant 0 : u32;
      v11 = arith.constant -1 : i32;
      v2 = arith.constant 0 : i32;
      v4 = arith.constant 1 : i32;
      v32, v33, v34, v35 = scf.while v4, v0, v2, v22 : i32, i32, i32, i32 {
      ^block6(v6: i32, v7: i32, v10: i32, v27: i32):
          v9 = arith.neq v7, v2 : i1;
          v45, v46, v47, v48, v49 = scf.if v9 : i32, i32, i32, u32, u32 {
          ^block8:
              v12 = arith.add v7, v11 : i32 #[overflow = wrapping];
              v13 = arith.add v10, v6 : i32 #[overflow = wrapping];
              scf.yield v13, v12, v6, v15, v21;
          } else {
          ^block16:
              scf.yield v22, v22, v22, v21, v15;
          };
          v44 = arith.trunc v49 : i1;
          scf.condition v44, v45, v46, v47, v10;
      } do {
      ^block15(v40: i32, v41: i32, v42: i32, v43: i32):
          scf.yield v40, v41, v42, v43;
      };
      builtin.ret v35;
  };

Like we saw in the second example, control-flow-sink didn't modify the IR. So even though it is enabled, since -Z print-ir-after-modifed was passed, it does not print IR.

NOTE: The name of the flags is still subject to change.

Implementation

For this PR, I used the already existing Print struct. Originally, it implemented the Pass trait, which enabled Print to be added after each Pass, just as if it were any other compiler pass. Whilst this approach was straightforward to use on-demand after a specific pass, it required manual code intervention & was not accessible to users of the compiler.

So, Print got its functionality moved from Pass to PassInstrumentation. PassInstrumentation was an already present trait that allowed arbitray functions to be run before and/or after any pass. However, it was not implemented by any struct yet if I'm not mistaken. The Pass trait was actually removed from Print, since if left implemented, it could lead to cases where IR printing was triggered twice: Once for PassInstrumentation and another time for Pass.

With this trait now in place, Print's methods could be invoked arbitrarily after every passed. The one thing that the PassInstrumentation trait was missing was an OperationRef, which actually holds the Display trait implementation for each operation; hence I added it in these lines: https://github.com/lambdaclass/miden-compiler/pull/1/files#diff-537baa1178fde0adc5131faa9dda74d0fecbe4347403a71af509ffd401199001L11-R32

Another thing that the issue required was the option to only print the IR after passes which modified itsstructured. That logic came in the form of the PostPassStatus enum, which is now returned by every Pass::run_on_operation function to indicate whether the Pass modified the IR or not.

To actually enable IR printing, one has to pass the pass any one of the flags describe in the [#Usage] section. These will get stored in the UnstableOptions struct and will later get mapped to a Print struct in the new() method. If no Print struct is created, no print is enabled.

[lima-limon-inc]

So far, a Print pass has been added every time the OpPassManager::nest() is called. The Print pass presented a good starting point for this issue, since it had implemented the basic building blocks for IR printing.

What is currently missing is:

• Configuring the IRPrintingConfig struct. At the moment, the IRPrintingConfig This, in turn, means that regardless of if there have been modifications to the IR or not the IR is always printed. The issue states that this should be configurable. I assume that these configurations should come from the Session/Context struct (although I don't think there's a 1 to 1 correspondance). The configuration is now done via the CLI.
  • Related to this, making printing granular is also missing. At the moment, the Print Pass is applied irregardless of the type. The issue also states that it should be able to only print IR when a Pass modified the IR.. Now both pass filtering and "only when modified" filter are enabled and configured via the CLI.

[lima-limon-inc]

After exploring the codebase a bit further, I managed to find the PassInstrumentor vector, which holds a series of PassInstrumentations.
These PassInstrumentations apply passes before and after other passes. This structure, I think, fits the IR printing issue better.

So I'll move the logic to this trait.

[lima-limon-inc]

Now, the run_on_operation returns an enum named IRAfterPass which indicates whether the IR was changed (IRAfterPass::Changed) or not (IRAfterPass::Unchanged).

This value will later be used in the Print::run_after_pass function to leverage the potential use of the print_ir_after_modified flag.

[lima-limon-inc]

The Pass implementation of the Print struct was removed since now the printing of the IR is done entirely within the PassInstrumentation functionality.

If not removed, it could lead to a case where double printing occurs. For instance: if Print is nested as a Pass, then the print_ir function would be called both during the PassInstrumentation::run_after_pass and also during Pass::run_on_operation functions.

[lima-limon-inc]

Added a PassFilter to the PrintStruct that enables filtering based on passes.

These passes are received as a CLI argument from the print_ir_after_pass flag. Currently they are stored as string, but it will soon be changed into an enum.

They are now stored as enums, see: #1 (comment)

[tomyrd]

Left some comments, I'm not super knowledgeable on the codebase/compilers in general, so I mostly reviewed styling and overall logic/documentation.

[tomyrd]

nit: Given that in the example above the variants are named with the field used to filter. Should this variant be renamed to Identifier or Name?

[lima-limon-inc]

I think that this comment is related to this other comment.

The main issue is how much much do we stick to the original naming style.

[tomyrd]

I find it strange that new receives the config but we only use it for a check. We really use the config in enable_ir_printing, shouldn't this check be made there?

[lima-limon-inc]

Great point, I think having the logic separated could potentially lead to errors.

Here I moved all the logic to the new method, what do you think?

768acb8

[tomyrd]

Perhaps not for this PR, but should this logic be handled by PassFilter itself? It feels more at home there. The same for the check in print_ir that decides wether or not to print for each OpFilter.

[tomyrd]

Perhaps I'm not seeing something, but why did this change if Self::verify wasn't modified? Couldn't we just do result = Self::verify(&op, run_verifier_recursively); like before?

[lima-limon-inc]

Great question! The verify function only checks if the Operation follows its logical verification rules. It doesn't actually modify the structure.

Since the function doesn't modify the IR, its signature is Result<(), Report>: It only returns a Report if there's an issue with the modification.
That's why I used result = result.map_err instead of result = result

[tomyrd]

Same here, shouldn't we define result as Result<(), Err> and just return result?

[lima-limon-inc]

Similarly, we need to know if the passes have modified the IR to allow the possibility to filter the printing output.

That information however, is only used in the pass instrumentor which is called just above these lines, here:
https://github.com/lambdaclass/miden-compiler/blob/fabrizioorsi/print-ir-passmanager/hir/src/pass/manager.rs#L990-L991

But, after the pass is run, whether the IR has been modified or not is no longer used. The only thing that is used is if function returned a Err, hence the map.

[tomyrd]

Phrasing seems confusing, it is my understanding that if it isn't set it will print depending on print_ir_after_all. Maybe we should also mention how it behaves in relation to print_ir_after_all because they seem like they are related.

[tomyrd]

After talking with @lima-limon-inc I think I missunderstood the print_ir_after_all flag. It doesn't mean "Print after all passes" but "Enable all passes to print", then the print_ir_after_modified filters wich prints are shown.

Should we change the doc comments or flag names to reflect this?

[lima-limon-inc]

You brought up a great point, with the current naming style behavior is not only not obvious, but also a tad confusing.

I think the problem here is the same problem regarding the original naming convention in here: #1 (comment)

[lima-limon-inc]

NOTE: What should be the behavior when both -Z print-ir-after-all and -Z print-ir-after-pass are passed? Currently print-ir-after-pass simply takes precedence.

Should the compiler crash and inform of this problem?

[igamigo]

Let's rename this field to account for the enum name change

[lima-limon-inc]

Great point Ignacio! I actually thought the same thing but forgot to change it.
Changed here: 09aa5af

[igamigo]

This struct used to be more trivial but now we added 3 fields so it would be nice to briefly document how it works

[lima-limon-inc]

What do you think of this Ignacio: 3838fb6

Was something like that what you had in mind? Or were you thinking of a different approach?

[igamigo]

I think we can remove this for now

[lima-limon-inc]

Sure thing Ignacio! Done here: 21aa490

[lima-limon-inc]

The documentation was a bit too CLI centric, I changed it here: 6522bae

[lima-limon-inc]

What do you think of this addition: e0669e8

It basically checks if both the print_ir_after_all and the print_ir_after_pass have been passed and raises and error if so. If not check, it would be an undefined behavior which option is used.

The output looks like this:

midenc compile  (...) -Z print-ir-after-pass=canonicalizer -Z print-ir-after-all

(...)

Error:   x print_ir_after_all and print_ir_after_pass flags are mutually exclusivke