Set up infrastructure for MidenVM compilation mode (FuelLabs#4173)

## Description
Hello! I am beginning work on the MidenVM backend.

This PR closes: FuelLabs#3697 FuelLabs#3696 FuelLabs#3695 and FuelLabs#3694.

I have created a new trivial test under `should_pass/midenvm`. Ideally,
eventually we will be able to run the relevant section of the main test
suite via `supported_targets`. I will seek to do that after more
compilation is built out. For now, this is a POC test that directly
addresses FuelLabs#3696.

Note that the Miden VM ASM builder will be modified heavily going
forward, and is not in a final state. I am submitting this in the spirit
of early feedback, and look forward to the reviews, but note that this
code path should not be considered "production ready" (note the `todo`
panics).

## Checklist

- [x] I have linked to any relevant issues.
- [ ] I have commented my code, particularly in hard-to-understand
areas.
- [ ] I have updated the documentation where relevant (API docs, the
reference, and the Sway book).
- [x] I have added tests that prove my fix is effective or that my
feature works.
- [ ] I have added (or requested a maintainer to add) the necessary
`Breaking*` or `New Feature` labels where relevant.
- [x] I have done my best to ensure that my PR adheres to [the Fuel Labs
Code Review
Standards](https://github.com/FuelLabs/rfcs/blob/master/text/code-standards/external-contributors.md).
- [ ] I have requested a review from the relevant team or maintainers.

---------

Co-authored-by: Alex Hansen <[email protected]>
Co-authored-by: João Matos <[email protected]>
Co-authored-by: Joshua Batty <[email protected]>

.github/workflows/ci.yml

@@ -253,6 +253,18 @@ jobs:
       - name: Cargo Run E2E Tests (EVM)
         run: cargo run --locked --release --bin test -- --target evm --locked
 
+  cargo-run-e2e-test-midenvm:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Install toolchain
+        uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: ${{ env.RUST_VERSION }}
+      - uses: Swatinem/rust-cache@v2
+      - name: Cargo Run E2E Tests (EVM)
+        run: cargo run --locked --release --bin test -- --target midenvm --locked
+
   # TODO: Remove this upon merging std tests with the rest of the E2E tests.
   cargo-test-lib-std:
     runs-on: ubuntu-latest

forc-pkg/src/pkg.rs

@@ -432,6 +432,8 @@ impl BuiltPackage {
                     res?
                 }
             }
+            // TODO?
+            ProgramABI::MidenVM(_) => (),
         }
 
         info!("      Bytecode size: {} bytes", self.bytecode.len());
@@ -1727,6 +1729,8 @@ pub fn compile(
 
             ProgramABI::Evm(ops)
         }
+
+        BuildTarget::MidenVM => ProgramABI::MidenVM(()),
     };
 
     let entries = asm_res

sway-core/Cargo.toml

@@ -24,6 +24,7 @@ hex = { version = "0.4", optional = true }
 im = "15.0"
 itertools = "0.10"
 lazy_static = "1.4"
+miden-core = "0.3.0"
 pest = "2.1.3"
 pest_derive = "2.1"
 petgraph = "0.6"

sway-core/src/asm_generation/abi.rs

@@ -4,4 +4,5 @@ use super::EvmAbiResult;
 pub enum ProgramABI {
     Fuel(fuel_abi_types::program_abi::ProgramABI),
     Evm(EvmAbiResult),
+    MidenVM(()),
 }

sway-core/src/asm_generation/asm_builder.rs

@@ -2,11 +2,15 @@ use sway_ir::Function;
 
 use crate::{asm_lang::Label, CompileResult};
 
-use super::{evm::EvmAsmBuilderResult, fuel::fuel_asm_builder::FuelAsmBuilderResult};
+use super::{
+    evm::EvmAsmBuilderResult, fuel::fuel_asm_builder::FuelAsmBuilderResult,
+    miden_vm::MidenVMAsmBuilderResult,
+};
 
 pub enum AsmBuilderResult {
     Fuel(FuelAsmBuilderResult),
     Evm(EvmAsmBuilderResult),
+    MidenVM(MidenVMAsmBuilderResult),
 }
 
 pub trait AsmBuilder {

sway-core/src/asm_generation/finalized_asm.rs

@@ -1,4 +1,5 @@
 use super::instruction_set::InstructionSet;
+use super::ToMidenBytecode;
 use super::{
     fuel::{checks, data_section::DataSection},
     ProgramABI, ProgramKind,
@@ -73,6 +74,14 @@ impl FinalizedAsm {
                     )
                 }
             }
+            InstructionSet::MidenVM { ops } => ok(
+                CompiledBytecode {
+                    bytecode: ops.to_bytecode().into(),
+                    config_const_offsets: Default::default(),
+                },
+                vec![],
+                vec![],
+            ),
         }
     }
 }
@@ -192,5 +201,6 @@ pub fn check_invalid_opcodes(asm: &FinalizedAsm) -> CompileResult<()> {
             ProgramKind::Predicate => checks::check_predicate_opcodes(&ops[..]),
         },
         InstructionSet::Evm { ops: _ } => ok((), vec![], vec![]),
+        InstructionSet::MidenVM { ops: _ } => ok((), vec![], vec![]),
     }
 }

sway-core/src/asm_generation/from_ir.rs

@@ -8,6 +8,7 @@ use super::{
         register_sequencer::RegisterSequencer,
     },
     programs::{AbstractEntry, AbstractProgram, FinalProgram, ProgramKind},
+    MidenVMAsmBuilder,
 };
 
 use crate::{err, ok, BuildConfig, BuildTarget, CompileResult, CompileWarning};
@@ -82,6 +83,7 @@ fn compile_module_to_asm(
             context,
         )),
         BuildTarget::EVM => Box::new(EvmAsmBuilder::new(kind, context)),
+        BuildTarget::MidenVM => Box::new(MidenVMAsmBuilder::new(kind, context)),
     };
 
     // Pre-create labels for all functions before we generate other code, so we can call them
@@ -159,6 +161,7 @@ fn compile_module_to_asm(
             ops: result.ops,
             abi: result.abi,
         },
+        AsmBuilderResult::MidenVM(result) => FinalProgram::MidenVM { ops: result.ops },
     };
 
     ok(final_program, warnings, errors)

sway-core/src/asm_generation/fuel/fuel_asm_builder.rs

@@ -2072,8 +2072,8 @@ impl<'ir> FuelAsmBuilder<'ir> {
             })
     }
 
-    // Same as `opt_value_to_register` but returns a new register if no register is found or if
-    // `value` is not a constant.
+    /// Same as [`opt_value_to_register`] but returns a new register if no register is found or if
+    /// `value` is not a constant.
     pub(super) fn value_to_register(&mut self, value: &Value) -> VirtualRegister {
         match self.opt_value_to_register(value) {
             Some(reg) => reg,