fix

Author: ciaranra

crates/pecos-llvm-utils/src/bin/pecos-llvm.rs

@@ -4,7 +4,9 @@
 //! Handles LLVM 14 detection, installation, and configuration for PECOS.
 
 use clap::{Parser, Subcommand};
-use pecos_llvm_utils::{find_llvm_14, get_repo_root_from_manifest, print_llvm_not_found_error};
+use pecos_llvm_utils::{
+    find_llvm_14, find_tool, get_repo_root_from_manifest, print_llvm_not_found_error,
+};
 use std::process;
 
 #[derive(Parser)]
@@ -57,6 +59,11 @@ enum Commands {
         /// Path to the LLVM installation to validate
         path: std::path::PathBuf,
     },
+    /// Find a specific LLVM tool (e.g., llvm-as, clang)
+    Tool {
+        /// Name of the tool to find (e.g., "llvm-as", "clang", "llvm-link")
+        name: String,
+    },
 }
 
 fn main() {
@@ -86,6 +93,7 @@ fn main() {
         Commands::Configure => cmd_configure(),
         Commands::Version => cmd_version(),
         Commands::Validate { path } => cmd_validate(&path),
+        Commands::Tool { name } => cmd_tool(&name),
     }
 }
 
@@ -245,3 +253,16 @@ fn cmd_validate(path: &std::path::Path) {
         }
     }
 }
+
+fn cmd_tool(tool_name: &str) {
+    if let Some(tool_path) = find_tool(tool_name) {
+        println!("{}", tool_path.display());
+        process::exit(0);
+    } else {
+        eprintln!("ERROR: Tool '{tool_name}' not found");
+        eprintln!();
+        eprintln!("Make sure LLVM 14 is installed:");
+        eprintln!("  cargo run -p pecos-llvm-utils --bin pecos-llvm -- check");
+        process::exit(1);
+    }
+}

crates/pecos-llvm-utils/src/lib.rs

@@ -360,6 +360,49 @@ pub fn find_cargo_project_root() -> Option<PathBuf> {
     }
 }
 
+/// Find a specific LLVM tool by name
+///
+/// This function locates a specific LLVM tool (e.g., `llvm-as`, `clang`) by:
+/// 1. Finding the LLVM 14 installation
+/// 2. Constructing the tool path with proper OS-specific naming (e.g., `.exe` on Windows)
+/// 3. Verifying the tool exists
+///
+/// # Arguments
+/// * `tool_name` - The name of the tool (e.g., "llvm-as", "clang", "llvm-link")
+///
+/// # Returns
+/// * `Some(PathBuf)` if the tool is found
+/// * `None` if LLVM 14 is not found or the tool doesn't exist
+///
+/// # Example
+/// ```no_run
+/// use pecos_llvm_utils::find_tool;
+///
+/// if let Some(llvm_as) = find_tool("llvm-as") {
+///     println!("Found llvm-as at: {}", llvm_as.display());
+/// }
+/// ```
+#[must_use]
+pub fn find_tool(tool_name: &str) -> Option<PathBuf> {
+    // Find LLVM installation
+    let repo_root = get_repo_root_from_manifest();
+    let llvm_path = find_llvm_14(repo_root)?;
+
+    // Construct tool path with OS-specific extension
+    let tool_path = if cfg!(windows) {
+        llvm_path.join("bin").join(format!("{tool_name}.exe"))
+    } else {
+        llvm_path.join("bin").join(tool_name)
+    };
+
+    // Verify the tool exists
+    if tool_path.exists() {
+        Some(tool_path)
+    } else {
+        None
+    }
+}
+
 /// Write or update .cargo/config.toml with LLVM configuration
 ///
 /// # Arguments

crates/pecos-qis-ffi-types/src/operations.rs

@@ -20,6 +20,12 @@ pub enum Operation {
     /// Release a qubit
     ReleaseQubit { id: usize },
 
+    /// Record output mapping from result ID to classical register name
+    RecordOutput {
+        result_id: usize,
+        register_name: String,
+    },
+
     /// Classical control flow marker
     Barrier,
 }

crates/pecos-qis-ffi/src/ffi.rs

@@ -678,27 +678,38 @@ pub unsafe extern "C" fn panic(code: i32, message: *const std::ffi::c_char) {
 /// This is typically used to record measurement results to classical registers
 ///
 /// # Safety
-/// This function is safe to call from C/LLVM code. The `result_id` parameter must be a valid
-/// non-negative result ID that fits in usize. The `register_name` pointer may be null or must
-/// point to a valid null-terminated C string. Invalid IDs or pointers will cause undefined behavior.
+/// This function is safe to call from C/LLVM code. The `result_ptr` parameter is an i8* pointer
+/// that represents a result ID (typically from inttoptr i64 conversion in LLVM IR).
+/// The `register_name` pointer may be null or must point to a valid null-terminated C string.
+/// Invalid pointers will cause undefined behavior.
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn __quantum__rt__result_record_output(
-    result_id: i64,
+    result_ptr: *const std::ffi::c_void,
     register_name: *const std::ffi::c_char,
 ) {
-    // For now, this is a no-op since we're collecting operations rather than executing them
-    // In a real implementation, this would record the measurement result to the specified register
-    // The actual measurement results are handled by the runtime during execution
-
-    // We could potentially add this as metadata to the interface if needed
-    // For debugging, we can at least validate the inputs
-    let _result_id = i64_to_usize(result_id);
-
-    if !register_name.is_null() {
-        // Mark the unsafe operation explicitly
-        let _register = unsafe { std::ffi::CStr::from_ptr(register_name) }.to_string_lossy();
-        // In the future, we might want to record this information
-    }
+    // Extract the result ID from the pointer
+    // HUGR generates: %result_ptr = inttoptr i64 %result_id to i8*
+    let result_id = result_ptr as usize;
+
+    // Convert the C string to a Rust String
+    let register_name_str = if register_name.is_null() {
+        "unknown".to_string()
+    } else {
+        let c_str = unsafe { std::ffi::CStr::from_ptr(register_name) };
+        c_str.to_str().unwrap_or("unknown").to_string()
+    };
+
+    log::trace!(
+        "Recording output mapping: result_id={result_id} -> register_name='{register_name_str}'"
+    );
+
+    // Queue the operation to record this output mapping
+    with_interface(|interface| {
+        interface.queue_operation(Operation::RecordOutput {
+            result_id,
+            register_name: register_name_str,
+        });
+    });
 }
 
 // =============================================================================

crates/pecos-qis-selene/src/selene_runtime.rs

@@ -148,6 +148,17 @@ impl SeleneRuntime {
                     let _ = id; // Just track it
                     self.current_op_index += 1;
                 }
+                Operation::RecordOutput {
+                    result_id,
+                    register_name,
+                } => {
+                    trace!(
+                        "Recording output: result_id={result_id}, register_name={register_name}"
+                    );
+                    // Metadata operation - just advance the index
+                    // The actual result mapping is handled by the runtime's results collection
+                    self.current_op_index += 1;
+                }
                 Operation::Barrier => {
                     trace!("Barrier encountered");
                     // Barriers don't produce quantum ops but can break batches

python/quantum-pecos/tests/guppy/test_hugr_compilation.py

@@ -126,20 +126,38 @@ def test_llvm_ir_format_validation(self) -> None:
             llvm_file = Path(f.name)
 
         try:
-            # Find llvm-as - check PATH first, then LLVM_SYS_140_PREFIX
+            # Find llvm-as - check PATH first, then use pecos-llvm-utils
             llvm_as_path = shutil.which("llvm-as")
 
             if not llvm_as_path:
-                # Not in PATH, try LLVM_SYS_140_PREFIX environment variable
-                llvm_prefix = os.environ.get("LLVM_SYS_140_PREFIX")
-                if llvm_prefix:
-                    potential_path = (
-                        Path(llvm_prefix) / "bin" / "llvm-as.exe"
-                        if os.name == "nt"
-                        else Path(llvm_prefix) / "bin" / "llvm-as"
-                    )
-                    if potential_path.exists():
-                        llvm_as_path = str(potential_path)
+                # Use pecos-llvm-utils to find the tool
+                cargo_path = shutil.which("cargo")
+                if cargo_path:
+                    try:
+                        result = subprocess.run(
+                            [
+                                cargo_path,
+                                "run",
+                                "-q",
+                                "--release",
+                                "-p",
+                                "pecos-llvm-utils",
+                                "--bin",
+                                "pecos-llvm",
+                                "--",
+                                "tool",
+                                "llvm-as",
+                            ],
+                            capture_output=True,
+                            text=True,
+                            check=False,
+                            timeout=30,
+                        )
+                        if result.returncode == 0 and result.stdout.strip():
+                            llvm_as_path = result.stdout.strip()
+                    except (subprocess.TimeoutExpired, Exception):  # noqa: S110
+                        # Silently fall through to failure case - error will be reported below
+                        pass
 
             if llvm_as_path:
                 # Validate with llvm-as

python/quantum-pecos/tests/pecos/test_sim_api_integration.py

@@ -141,33 +141,44 @@ class TestLLVMSimulation:
 
     def test_sim_api_with_llvm_simple(self) -> None:
         """Test sim API with simple LLVM IR program."""
-        # Proper QIR-compliant LLVM IR
+        # QIS format LLVM IR - uses i64 for qubit indices and qmain entry point
+        # This matches the format that PECOS HUGR compiler generates
         llvm_ir = """
         ; ModuleID = 'quantum_test'
+        source_filename = "quantum_test"
 
-        %Qubit = type opaque
-        %Result = type opaque
+        @str_c = constant [2 x i8] c"c\\00"
 
-        declare void @__quantum__qis__h__body(%Qubit*)
-        declare %Result* @__quantum__qis__mz__body(%Qubit*)
-        declare %Qubit* @__quantum__rt__qubit_allocate()
-        declare void @__quantum__rt__qubit_release(%Qubit*)
-        declare void @__quantum__rt__result_record_output(%Result*, i8*)
+        ; Entry point using qmain(i64)->i64 protocol
+        define i64 @qmain(i64 %0) #0 {
+        entry:
+            ; Allocate qubit (returns i64)
+            %qubit = call i64 @__quantum__rt__qubit_allocate()
 
-        @0 = internal constant [2 x i8] c"c\\00"
+            ; Apply H gate (takes i64 qubit index)
+            call void @__quantum__qis__h__body(i64 %qubit)
 
-        define void @main() #0 {
-        entry:
-            %qubit = call %Qubit* @__quantum__rt__qubit_allocate()
-            call void @__quantum__qis__h__body(%Qubit* %qubit)
-            %result = call %Result* @__quantum__qis__mz__body(%Qubit* %qubit)
-            call void @__quantum__rt__result_record_output(%Result* %result,
-                i8* getelementptr inbounds ([2 x i8], [2 x i8]* @0, i32 0, i32 0))
-            call void @__quantum__rt__qubit_release(%Qubit* %qubit)
-            ret void
+            ; Allocate result handle
+            %result_id = call i64 @__quantum__rt__result_allocate()
+
+            ; Measure qubit (returns i32 measurement)
+            %measurement = call i32 @__quantum__qis__m__body(i64 %qubit, i64 %result_id)
+
+            ; Record output (convert i64 to i8* pointer for register name)
+            %result_ptr = inttoptr i64 %result_id to i8*
+            call void @__quantum__rt__result_record_output(i8* %result_ptr,
+                i8* getelementptr inbounds ([2 x i8], [2 x i8]* @str_c, i32 0, i32 0))
+
+            ret i64 0
         }
 
-        attributes #0 = { "EntryPoint" "requiredQubits"="1" }
+        declare i64 @__quantum__rt__qubit_allocate()
+        declare void @__quantum__qis__h__body(i64)
+        declare i64 @__quantum__rt__result_allocate()
+        declare i32 @__quantum__qis__m__body(i64, i64)
+        declare void @__quantum__rt__result_record_output(i8*, i8*)
+
+        attributes #0 = { "EntryPoint" }
         """
 
         try:
@@ -207,45 +218,53 @@ def test_sim_api_with_llvm_simple(self) -> None:
 
     def test_sim_api_with_llvm_bell_state(self) -> None:
         """Test sim API with Bell state in LLVM IR."""
-        # Bell state in QIS format - uses i64 qubit indices (not QIR opaque pointers)
-        # This is the format PECOS actually supports (from HUGR compilation)
+        # QIS format LLVM IR - uses i64 for qubit indices and qmain entry point
+        # This matches the format that PECOS HUGR compiler generates
         llvm_ir = """
         ; ModuleID = 'bell_state'
+        source_filename = "bell_state"
 
-        declare void @__quantum__qis__h__body(i64)
-        declare void @__quantum__qis__cnot__body(i64, i64)
-        declare i1 @__quantum__qis__mz__body(i64)
-        declare void @__quantum__rt__result_record_output(i64, i8*)
-
-        @0 = internal constant [3 x i8] c"c0\\00"
-        @1 = internal constant [3 x i8] c"c1\\00"
+        @str_c0 = constant [3 x i8] c"c0\\00"
+        @str_c1 = constant [3 x i8] c"c1\\00"
 
-        define void @main() #0 {
+        ; Entry point using qmain(i64)->i64 protocol
+        define i64 @qmain(i64 %0) #0 {
         entry:
-            ; Apply H to qubit 0
-            call void @__quantum__qis__h__body(i64 0)
-
-            ; Apply CNOT(0, 1)
-            call void @__quantum__qis__cnot__body(i64 0, i64 1)
-
-            ; Measure both qubits
-            %m0 = call i1 @__quantum__qis__mz__body(i64 0)
-            %m1 = call i1 @__quantum__qis__mz__body(i64 1)
-
-            ; Convert i1 to i64 for result recording
-            %r0 = zext i1 %m0 to i64
-            %r1 = zext i1 %m1 to i64
+            ; Allocate qubits (returns i64)
+            %q0 = call i64 @__quantum__rt__qubit_allocate()
+            %q1 = call i64 @__quantum__rt__qubit_allocate()
 
-            ; Record results
-            call void @__quantum__rt__result_record_output(i64 %r0,
-                i8* getelementptr inbounds ([3 x i8], [3 x i8]* @0, i32 0, i32 0))
-            call void @__quantum__rt__result_record_output(i64 %r1,
-                i8* getelementptr inbounds ([3 x i8], [3 x i8]* @1, i32 0, i32 0))
-
-            ret void
+            ; Apply H to qubit 0
+            call void @__quantum__qis__h__body(i64 %q0)
+
+            ; Apply CX(q0, q1)
+            call void @__quantum__qis__cx__body(i64 %q0, i64 %q1)
+
+            ; Measure qubit 0
+            %result_id0 = call i64 @__quantum__rt__result_allocate()
+            %measurement0 = call i32 @__quantum__qis__m__body(i64 %q0, i64 %result_id0)
+            %result_ptr0 = inttoptr i64 %result_id0 to i8*
+            call void @__quantum__rt__result_record_output(i8* %result_ptr0,
+                i8* getelementptr inbounds ([3 x i8], [3 x i8]* @str_c0, i32 0, i32 0))
+
+            ; Measure qubit 1
+            %result_id1 = call i64 @__quantum__rt__result_allocate()
+            %measurement1 = call i32 @__quantum__qis__m__body(i64 %q1, i64 %result_id1)
+            %result_ptr1 = inttoptr i64 %result_id1 to i8*
+            call void @__quantum__rt__result_record_output(i8* %result_ptr1,
+                i8* getelementptr inbounds ([3 x i8], [3 x i8]* @str_c1, i32 0, i32 0))
+
+            ret i64 0
         }
 
-        attributes #0 = { "EntryPoint" "requiredQubits"="2" }
+        declare i64 @__quantum__rt__qubit_allocate()
+        declare void @__quantum__qis__h__body(i64)
+        declare void @__quantum__qis__cx__body(i64, i64)
+        declare i64 @__quantum__rt__result_allocate()
+        declare i32 @__quantum__qis__m__body(i64, i64)
+        declare void @__quantum__rt__result_record_output(i8*, i8*)
+
+        attributes #0 = { "EntryPoint" }
         """
 
         try: