Centralise checked arithmetic into intrinsics for faster compilation and maintainability.

Author: IntegralPilot

Cargo.lock

@@ -10,6 +10,7 @@ libc = "0.2.172"
 md5 = "0.7.0"
 num-bigint = "0.4.6"
 num-traits = "0.2.19"
+once_cell = "1.20.2"
 regex = "1.11.1"
 ristretto_classfile = "0.18.1"
 serde = { version = "1.0.219", features = ["derive"] }

Cargo.toml

@@ -114,8 +114,8 @@ def stash_based(tests, binary_dir):
     """Compares working dir vs. stashed state, measures JAR sizes and per-test build times."""
     # Phase 1A: build main project WITH changes
     print("|--- 🛠️ Building main project WITH unstaged changes…")
-    run_command(["make", "clean"], check=True)
-    run_command(["make", "all"],   check=True)
+    run_command(["./build.py", "clean"], check=True)
+    run_command(["./build.py", "all"],   check=True)
 
     # Phase 1B: build each test and time it
     times_with = {}
@@ -125,7 +125,7 @@ def stash_based(tests, binary_dir):
         print(f"|---- Building test: {name}")
         t0 = time.time()
         # Note: The original script didn't specify --release or --target here.
-        # The actual JAR location might depend on how 'make all' configures things.
+        # The actual JAR location might depend on how './build.py all' configures things.
         run_command(["cargo", "clean"], cwd=t, check=True)
         run_command(["cargo", "build"], cwd=t, check=True)
         elapsed = time.time() - t0
@@ -155,8 +155,8 @@ def stash_based(tests, binary_dir):
 
     # Phase 2A: build main project at HEAD
     print("\n|--- 🛠️ Building main project at HEAD (no changes)…")
-    run_command(["make", "clean"], check=True)
-    run_command(["make", "all"],   check=True)
+    run_command(["./build.py", "clean"], check=True)
+    run_command(["./build.py", "all"],   check=True)
 
     # Phase 2B: build each test at HEAD and time it
     times_without = {}
@@ -250,8 +250,8 @@ def commit_based(tests, binary_dir, n):
 
     # Phase 1A: build main project at HEAD
     print(f"\n|--- 🛠️ Building main project at HEAD ({orig_head[:10]})…")
-    run_command(["make", "clean"], check=True)
-    run_command(["make", "all"],   check=True)
+    run_command(["./build.py", "clean"], check=True)
+    run_command(["./build.py", "all"],   check=True)
 
     # Phase 1B: build & time each test at HEAD
     times_head = {}
@@ -282,8 +282,8 @@ def commit_based(tests, binary_dir, n):
 
     # Phase 2A: build main project at HEAD~N
     print(f"\n|--- 🛠️ Building main project at HEAD~{n}…")
-    run_command(["make", "clean"], check=True)
-    run_command(["make", "all"],   check=True)
+    run_command(["./build.py", "clean"], check=True)
+    run_command(["./build.py", "all"],   check=True)
 
     # Phase 2B: build & time each test at HEAD~N
     times_old = {}

CompareSize.py

@@ -37,14 +37,59 @@ def build_rust_code(test_dir: str, release_mode: bool) -> tuple[bool, str]:
         build_cmd.extend(["--target", "../../../jvm-unknown-unknown.json"])
 
     proc = run_command(build_cmd, cwd=test_dir)
+    target_dir = "release" if release_mode else "debug"
+    
     if proc.returncode != 0:
         fail_path = os.path.join(test_dir, "cargo-build-fail.generated")
         output = f"STDOUT:\n{proc.stdout}\n\nSTDERR:\n{proc.stderr}"
         write_to_file(fail_path, output)
         print(f"|---- ❌ cargo build exited with code {proc.returncode}")
+        
+        # Check if this is an R8 linking error (indicates invalid JVM bytecode)
+        error_output = proc.stdout + proc.stderr
+        if "R8" in error_output:
+            print("|---- 🔍 Detected R8 error - attempting to run with -noverify for better diagnostics...")
+            test_name = os.path.basename(test_dir)
+            
+            # Try to run the main class with -noverify to get actual JVM error
+            deps_dir = os.path.join(test_dir, "target", target_dir, "deps")
+            if os.path.exists(deps_dir):
+                # Check if the main class file exists
+                main_class = os.path.join(deps_dir, f"{test_name}.class")
+                if os.path.exists(main_class):
+                    # Build classpath: runtime libraries + deps directory
+                    java_cp = f"{RUNTIME_CLASSPATH_BASE}{os.pathsep}{deps_dir}"
+                    verify_proc = run_command(
+                        ["java", "-noverify", "-cp", java_cp, test_name]
+                    )
+                    
+                    # Always write output if we got any
+                    verify_output = f"\n\n--- JVM OUTPUT WITH -noverify ---\n"
+                    verify_output += f"Command: java -noverify -cp {java_cp} {test_name}\n"
+                    verify_output += f"STDOUT:\n{verify_proc.stdout}\n\nSTDERR:\n{verify_proc.stderr}\n"
+                    verify_output += f"Return code: {verify_proc.returncode}\n"
+                    
+                    # Append to the fail file
+                    full_output = output + verify_output
+                    write_to_file(fail_path, full_output)
+                    print("|---- 📝 JVM diagnostics written to cargo-build-fail.generated")
+                    
+                    # Show relevant error info
+                    if verify_proc.stderr:
+                        # Filter out the deprecation warning about -noverify
+                        error_lines = [line for line in verify_proc.stderr.split('\n') 
+                                     if '-noverify' not in line and '-Xverify:none' not in line and line.strip()]
+                        if error_lines:
+                            print(f"|---- JVM error: {error_lines[0][:200]}")
+                    elif verify_proc.returncode != 0:
+                        print(f"|---- JVM exited with code {verify_proc.returncode}")
+                else:
+                    print(f"|---- ⚠️ Main class file not found: {main_class}")
+            else:
+                print(f"|---- ⚠️ Deps directory not found: {deps_dir}")
+        
         return False, ""
 
-    target_dir = "release" if release_mode else "debug"
     return True, target_dir
 
 def find_and_prepare_jar(test_dir: str, test_name: str, target_dir: str) -> tuple[bool, str]:

Tester.py

@@ -682,6 +682,7 @@ impl CodegenBackend for MyBackend {
                                 entry: "bb0".into(),
                                 basic_blocks: bbs,
                             },
+                            is_static: false,
                         },
                     );
 
@@ -867,6 +868,7 @@ impl CodegenBackend for MyBackend {
                             entry: "bb0".into(),
                             basic_blocks: bbs,
                         },
+                        is_static: false,
                     };
 
                     new_functions.insert(format!("dyn_{}_{}", ident, name), function);
@@ -932,6 +934,24 @@ impl CodegenBackend for MyBackend {
             format!("OOMIR module: {:?}", oomir_module)
         );
 
+        // Emit checked arithmetic intrinsics for all needed operations
+        breadcrumbs::log!(
+            breadcrumbs::LogLevel::Info,
+            "intrinsics",
+            "Emitting checked arithmetic intrinsics..."
+        );
+        let needed_intrinsics = lower1::control_flow::take_needed_intrinsics();
+        if !needed_intrinsics.is_empty() {
+            breadcrumbs::log!(
+                breadcrumbs::LogLevel::Info,
+                "intrinsics",
+                format!("Emitting {} intrinsics: {:?}", needed_intrinsics.len(), needed_intrinsics)
+            );
+            let intrinsic_class = 
+                lower1::control_flow::checked_intrinsics::emit_all_needed_intrinsics(&needed_intrinsics);
+            oomir_module.data_types.insert("RustcCodegenJVMIntrinsics".to_string(), intrinsic_class);
+        }
+
         breadcrumbs::log!(
             breadcrumbs::LogLevel::Info,
             "optimisation",
@@ -1074,7 +1094,7 @@ impl CodegenBackend for MyBackend {
 
 struct RustcCodegenJvmLogListener;
 
-const LISTENING_CHANNELS: &[&str] = &[];
+const LISTENING_CHANNELS: &[&str] = &["backend"];
 
 impl breadcrumbs::LogListener for RustcCodegenJvmLogListener {
     fn on_log(&mut self, log: breadcrumbs::Log) {

src/lib.rs

@@ -17,7 +17,7 @@ use std::collections::HashMap;
 use types::ty_to_oomir_type;
 
 mod closures;
-mod control_flow;
+pub mod control_flow;
 pub mod naming;
 pub mod operand;
 pub mod place;
@@ -204,6 +204,7 @@ pub fn mir_to_oomir<'tcx>(
             name: fn_name,
             signature,
             body: codeblock,
+            is_static: false,
         },
         data_types.clone(),
     )

src/lower1.rs

@@ -18,8 +18,12 @@ use rustc_middle::{
 use std::collections::HashMap;
 
 mod checked_ops;
+mod checked_intrinsic_registry;
+pub mod checked_intrinsics;
 mod rvalue;
 
+pub use checked_intrinsic_registry::take_needed_intrinsics;
+
 /// Convert a single MIR basic block into an OOMIR basic block.
 pub fn convert_basic_block<'tcx>(
     bb: BasicBlock,

src/lower1/control_flow.rs

@@ -0,0 +1,32 @@
+// checked_intrinsic_registry.rs
+// Global registry to track which checked arithmetic intrinsics are needed
+
+use std::collections::HashSet;
+use std::sync::Mutex;
+use once_cell::sync::Lazy;
+
+/// Global registry of needed checked arithmetic intrinsics
+/// Format: (operation, type) e.g., ("add", "i32")
+static NEEDED_INTRINSICS: Lazy<Mutex<HashSet<(String, String)>>> = Lazy::new(|| {
+    Mutex::new(HashSet::new())
+});
+
+/// Register that a checked arithmetic intrinsic is needed
+pub fn register_intrinsic(operation: &str, ty: &str) {
+    let mut registry = NEEDED_INTRINSICS.lock().unwrap();
+    registry.insert((operation.to_string(), ty.to_string()));
+}
+
+/// Get all registered intrinsics and clear the registry
+pub fn take_needed_intrinsics() -> Vec<(String, String)> {
+    let mut registry = NEEDED_INTRINSICS.lock().unwrap();
+    let intrinsics: Vec<_> = registry.iter().cloned().collect();
+    registry.clear();
+    intrinsics
+}
+
+/// Check if an intrinsic has been registered
+pub fn is_registered(operation: &str, ty: &str) -> bool {
+    let registry = NEEDED_INTRINSICS.lock().unwrap();
+    registry.contains(&(operation.to_string(), ty.to_string()))
+}