OOMIR optimiser! (took a while, but finally ready) :)

Author: IntegralPilot

Cargo.lock

@@ -4,6 +4,7 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+bigdecimal = "0.4.8"
 half = "2.6.0"
 num-bigint = "0.4.6"
 num-traits = "0.2.19"

Cargo.toml

@@ -39,6 +39,7 @@ All examples live in `tests/binary` and are compiled to JVM bytecode & run/teste
 ## ✨ Features
 
 - **Minimal `no_std` & `no_core`** programs via `jvm-unknown-unknown`  
+- Optimisations including constant folding and propogation, dead code elimination, and more to generate efficient JVM bytecode
 - Basic `core` support on host target for JVM output  
 - Arithmetic (integers + floats, incl. checked ops)  
 - Comparisons, bitwise & logical ops  
@@ -60,12 +61,19 @@ All examples live in `tests/binary` and are compiled to JVM bytecode & run/teste
 2. **MIR → OOMIR**  
    Custom “Object‑Oriented MIR” simplifies MIR into OOP‑style constructs.  
    _(see `src/lower1.rs`)_  
-3. **OOMIR → JVM Classfile**  
+3. **OOMIR optimiser**
+   Optimises OOMIR using constant folding, dead code elimination, and more.  
+   _(see `src/optimise1.rs`)_  
+   - **Constant Folding**: Evaluates constant expressions at compile time.  
+   - **Constant Propagation**: Replaces variables with their constant values.  
+   - **Dead Code Elimination**: Removes unused code paths.  
+   - **Algebraic Simplification**: Simplifies expressions using algebraic identities.
+4. **OOMIR → JVM Classfile**  
    Translate to `.class` files using `ristretto_classfile`.  
    _(see `src/lower2.rs`)_  
-4. **Post‑Process Stack Map Frames**  
+5. **Post‑Process Stack Map Frames**  
    Kotlin `asm-processor` (ASM library) adds verification frames.  
-5. **Link & Package**  
+6. **Link & Package**  
    `java-linker` bundles `.class` files into a runnable `.jar` with `META-INF/MANIFEST.MF`.
 
 ---

Readme.md

@@ -109,6 +109,7 @@ def main():
     parser = argparse.ArgumentParser(description="Tester for Rustc's JVM Codegen Backend")
     parser.add_argument("--release", action="store_true", help="Run cargo in release mode")
     parser.add_argument("--only-run", type=str, help="Comma-separated list of specific test names to run")
+    parser.add_argument("--dont-run", type=str, help="Comma-separated list of specific test names to exclude")
     args = parser.parse_args()
 
     print("🧪 Tester for Rustc's JVM Codegen Backend started!")
@@ -131,6 +132,11 @@ def main():
         requested_tests = set([name.strip() for name in args.only_run.split(",")])
         binary_tests = [t for t in binary_tests if os.path.basename(t) in requested_tests]
 
+    # Exclude tests based on --dont-run
+    if args.dont_run:
+        excluded_tests = set([name.strip() for name in args.dont_run.split(",")])
+        binary_tests = [t for t in binary_tests if os.path.basename(t) not in excluded_tests]
+
     print(f"|- 📦 Running {len(binary_tests)} binary build test(s)...")
     for test_dir in binary_tests:
         if not process_test(test_dir, args.release):

Tester.py

@@ -37,6 +37,7 @@ use std::{any::Any, io::Write, path::Path};
 mod lower1;
 mod lower2;
 mod oomir;
+mod optimise1;
 
 /// An instance of our Java bytecode codegen backend.
 struct MyBackend;
@@ -100,6 +101,20 @@ impl CodegenBackend for MyBackend {
 
         println!("OOMIR module: {:?}", oomir_module);
 
+        println!(
+            "--- Starting OOMIR Optimisation for module: {} ---",
+            crate_name
+        );
+
+        let oomir_module = optimise1::optimise_module(oomir_module);
+
+        println!("Optimised OOMIR module: {:?}", oomir_module);
+
+        println!(
+            "--- Finished OOMIR Optimisation for module: {} ---",
+            crate_name
+        );
+
         println!(
             "--- Starting OOMIR to JVM Bytecode Lowering for module: {} ---",
             crate_name

src/lib.rs

@@ -17,7 +17,7 @@ use std::collections::HashMap;
 use types::ty_to_oomir_type;
 
 mod control_flow;
-mod operand;
+pub mod operand;
 mod place;
 mod types;
 

src/lower1.rs

@@ -100,7 +100,7 @@ pub fn convert_rvalue_to_operand<'a>(
                 for i in 0..array_size {
                     let index_operand = oomir::Operand::Constant(oomir::Constant::I32(i as i32));
                     instructions.push(oomir::Instruction::ArrayStore {
-                        array_var: temp_array_var.clone(), // Store into temp array
+                        array: temp_array_var.clone(),
                         index: index_operand,
                         value: oomir_elem_op.clone(),
                     });
@@ -135,7 +135,14 @@ pub fn convert_rvalue_to_operand<'a>(
             let source_name = place_to_string(source_place, tcx);
             instructions.push(oomir::Instruction::Length {
                 dest: temp_len_var.clone(),
-                array_var: source_name,
+                array: oomir::Operand::Variable {
+                    name: source_name,
+                    ty: ty_to_oomir_type(
+                        source_place.ty(&mir.local_decls, tcx).ty,
+                        tcx,
+                        data_types,
+                    ),
+                },
             });
             result_operand = oomir::Operand::Variable {
                 name: temp_len_var,
@@ -307,7 +314,7 @@ pub fn convert_rvalue_to_operand<'a>(
                     });
                     // Set fields on the *temporary* tuple
                     instructions.push(oomir::Instruction::SetField {
-                        object_var: temp_tuple_var.clone(),
+                        object: temp_tuple_var.clone(),
                         field_name: "field0".to_string(),
                         value: oomir::Operand::Variable {
                             name: tmp_result_var,
@@ -317,7 +324,7 @@ pub fn convert_rvalue_to_operand<'a>(
                         owner_class: tuple_class_name.clone(),
                     });
                     instructions.push(oomir::Instruction::SetField {
-                        object_var: temp_tuple_var.clone(),
+                        object: temp_tuple_var.clone(),
                         field_name: "field1".to_string(),
                         value: oomir::Operand::Variable {
                             name: tmp_overflow_var,
@@ -374,7 +381,7 @@ pub fn convert_rvalue_to_operand<'a>(
                     match oomir_src_operand {
                         oomir::Operand::Variable {
                             name: source_name,
-                            ty: _,
+                            ty: var_ty,
                         } => {
                             // Check if source is actually an array/slice/str type
                             let operand_place = match operand {
@@ -400,7 +407,10 @@ pub fn convert_rvalue_to_operand<'a>(
                                     println!("Info: Detected Length op via PtrMetadata.");
                                     instructions.push(oomir::Instruction::Length {
                                         dest: temp_unop_var.clone(),
-                                        array_var: source_name,
+                                        array: oomir::Operand::Variable {
+                                            name: source_name,
+                                            ty: var_ty,
+                                        },
                                     });
                                 } else {
                                     println!(
@@ -481,7 +491,7 @@ pub fn convert_rvalue_to_operand<'a>(
                         let value_operand =
                             convert_operand(mir_op, tcx, mir, data_types, &mut instructions);
                         instructions.push(oomir::Instruction::SetField {
-                            object_var: temp_aggregate_var.clone(),
+                            object: temp_aggregate_var.clone(),
                             field_name,
                             value: value_operand,
                             field_ty: element_oomir_type,
@@ -510,7 +520,7 @@ pub fn convert_rvalue_to_operand<'a>(
                         let index_operand =
                             oomir::Operand::Constant(oomir::Constant::I32(i as i32));
                         instructions.push(oomir::Instruction::ArrayStore {
-                            array_var: temp_aggregate_var.clone(),
+                            array: temp_aggregate_var.clone(),
                             index: index_operand,
                             value: value_operand,
                         });
@@ -544,7 +554,7 @@ pub fn convert_rvalue_to_operand<'a>(
                                 &mut instructions,
                             );
                             instructions.push(oomir::Instruction::SetField {
-                                object_var: temp_aggregate_var.clone(),
+                                object: temp_aggregate_var.clone(),
                                 field_name,
                                 value: value_operand,
                                 field_ty: field_oomir_type,
@@ -686,7 +696,7 @@ pub fn convert_rvalue_to_operand<'a>(
                                 &mut instructions,
                             );
                             instructions.push(oomir::Instruction::SetField {
-                                object_var: temp_aggregate_var.clone(),
+                                object: temp_aggregate_var.clone(),
                                 field_name,
                                 value: value_operand,
                                 field_ty: field_oomir_type,
@@ -768,34 +778,37 @@ pub fn convert_rvalue_to_operand<'a>(
             // 1. Generate instructions to get the actual value from the place
             let (actual_value_var_name, get_instructions, actual_value_oomir_type) =
                 emit_instructions_to_get_on_own(place, tcx, mir, data_types);
-        
+
             // Add the instructions needed to get the value (e.g., ArrayGet)
             instructions.extend(get_instructions);
-        
+
             // 2. Now operate on the variable holding the actual value
             let temp_discriminant_var = generate_temp_var_name(&base_temp_name);
-        
+
             let place_class_name = match actual_value_oomir_type.clone() {
                 oomir::Type::Class(name) => name.clone(),
                 // Handle potential references if get_on_own returns Ref(Class)
                 oomir::Type::Reference(inner) => {
-                     if let oomir::Type::Class(name) = inner.as_ref() {
+                    if let oomir::Type::Class(name) = inner.as_ref() {
                         name.clone()
-                     } else {
-                         panic!("Discriminant on Ref to non-class type: {:?}", inner)
-                     }
+                    } else {
+                        panic!("Discriminant on Ref to non-class type: {:?}", inner)
+                    }
                 }
-                _ => panic!("Discriminant on non-class type: {:?}", actual_value_oomir_type),
+                _ => panic!(
+                    "Discriminant on non-class type: {:?}",
+                    actual_value_oomir_type
+                ),
             };
-        
+
             let method_name = "getVariantIdx".to_string();
             let method_return_type = oomir::Type::I32;
-        
+
             let method_ty = oomir::Signature {
                 params: vec![],
                 ret: Box::new(method_return_type.clone()),
             };
-        
+
             // 3. Call InvokeVirtual on the CORRECT variable
             instructions.push(oomir::Instruction::InvokeVirtual {
                 class_name: place_class_name.clone(),
@@ -808,13 +821,13 @@ pub fn convert_rvalue_to_operand<'a>(
                     ty: actual_value_oomir_type,
                 },
             });
-        
+
             // 4. The result is the temporary variable holding the discriminant value
             result_operand = oomir::Operand::Variable {
                 name: temp_discriminant_var,
                 ty: method_return_type, // Should be I32
             };
-        }        
+        }
         // Handle other Rvalue variants by generating a placeholder
         _ => {
             println!(

src/lower1/control_flow/rvalue.rs

@@ -426,20 +426,30 @@ pub fn handle_const_value<'tcx>(
                                                 }
                                             } else {
                                                 /* Array element type is not Ref */
-                                                match read_constant_value_from_memory(tcx, allocation, pointer.into_parts().1, *inner_ty, data_types) {
+                                                match read_constant_value_from_memory(
+                                                    tcx,
+                                                    allocation,
+                                                    pointer.into_parts().1,
+                                                    *inner_ty,
+                                                    data_types,
+                                                ) {
                                                     Ok(oomir_const) => {
                                                         println!(
                                                             "Info: Successfully read constant value from memory: {:?}",
                                                             oomir_const
                                                         );
-                                                        return oomir::Operand::Constant(oomir_const);
+                                                        return oomir::Operand::Constant(
+                                                            oomir_const,
+                                                        );
                                                     }
                                                     Err(e) => {
                                                         println!(
                                                             "Warning: Failed to read constant value from memory for allocation {:?}. Error: {:?}",
                                                             alloc_id, e
                                                         );
-                                                        return oomir::Operand::Constant(oomir::Constant::I32(-1))
+                                                        return oomir::Operand::Constant(
+                                                            oomir::Constant::I32(-1),
+                                                        );
                                                     }
                                                 }
                                             }

src/lower1/operand.rs

@@ -1,6 +1,5 @@
 use num_bigint::BigUint;
 use num_traits::{One, ToPrimitive, Zero};
-use std::mem;
 
 /// Convert an `f128` (binary128) to a decimal `String` with up to 34 significant digits,
 /// rounding to nearest, ties-to-even.
@@ -35,7 +34,7 @@ pub fn f128_to_string(x: f128) -> String {
     const EXP_BIAS: i32 = 16383; // binary128 exponent bias
 
     // Transmute to raw bits
-    let bits: u128 = unsafe { mem::transmute(x) };
+    let bits: u128 = x.to_bits();
     let sign_bit = (bits >> 127) != 0;
     let exp_bits = ((bits >> 112) & 0x7fff) as i32;
     let frac_bits = bits & ((1u128 << 112) - 1);