refactor: move out32 into arch-specific exit module

Extract the out32 VM exit function from exit.rs into
arch/amd64/exit.rs. exit.rs now delegates to the arch module
via cfg_attr, keeping arch-independent code (outb, abort,
debug_print) in the shared file.

Signed-off-by: Ludvig Liljenberg <4257730+ludfjig@users.noreply.github.com>

Author: ludfjig

src/hyperlight_guest/src/arch/amd64/exit.rs

@@ -0,0 +1,60 @@
+/*
+Copyright 2025  The Hyperlight Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+ */
+
+use core::arch::asm;
+
+#[cfg(feature = "trace_guest")]
+use hyperlight_common::outb::OutBAction;
+
+/// OUT function for sending a 32-bit value to the host.
+/// `out32` can be called from an exception context, so we must be careful
+/// with the tracing state that might be locked at that time.
+/// The tracing state calls `try_lock` internally to avoid deadlocks.
+/// Furthermore, the instrument macro is not used here to avoid creating spans
+/// in exception contexts. Because if the trace state is already locked, trying to create a span
+/// would cause a panic, which is undesirable in exception handling.
+pub(crate) unsafe fn out32(port: u16, val: u32) {
+    #[cfg(feature = "trace_guest")]
+    {
+        if let Some((ptr, len)) = hyperlight_guest_tracing::serialized_data() {
+            // If tracing is enabled and there is data to send, send it along with the OUT action
+            unsafe {
+                asm!("out dx, eax",
+                    in("dx") port,
+                    in("eax") val,
+                    in("r8") OutBAction::TraceBatch as u64,
+                    in("r9") ptr,
+                    in("r10") len,
+                    options(preserves_flags, nomem, nostack)
+                )
+            };
+
+            // Reset the trace state after sending the batch
+            // This clears all existing spans/events ensuring a clean state for the next operations
+            // The trace state is expected to be flushed before this call
+            hyperlight_guest_tracing::reset();
+        } else {
+            // If tracing is not enabled, just send the value
+            unsafe {
+                asm!("out dx, eax", in("dx") port, in("eax") val, options(preserves_flags, nomem, nostack))
+            };
+        }
+    }
+    #[cfg(not(feature = "trace_guest"))]
+    unsafe {
+        asm!("out dx, eax", in("dx") port, in("eax") val, options(preserves_flags, nomem, nostack));
+    }
+}

src/hyperlight_guest/src/exit.rs

@@ -14,11 +14,16 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-use core::arch::asm;
 use core::ffi::{CStr, c_char};
 
 use hyperlight_common::outb::OutBAction;
 
+#[cfg_attr(target_arch = "x86_64", path = "arch/amd64/exit.rs")]
+#[cfg_attr(target_arch = "x86", path = "arch/amd64/exit.rs")]
+#[cfg_attr(target_arch = "aarch64", path = "arch/aarch64/exit.rs")]
+mod arch;
+pub(crate) use arch::out32;
+
 /// Exits the VM with an Abort OUT action and code 0.
 #[unsafe(no_mangle)]
 pub extern "C" fn abort() -> ! {
@@ -87,46 +92,6 @@ pub(crate) fn outb(port: u16, data: &[u8]) {
     }
 }
 
-/// OUT function for sending a 32-bit value to the host.
-/// `out32` can be called from an exception context, so we must be careful
-/// with the tracing state that might be locked at that time.
-/// The tracing state calls `try_lock` internally to avoid deadlocks.
-/// Furthermore, the instrument macro is not used here to avoid creating spans
-/// in exception contexts. Because if the trace state is already locked, trying to create a span
-/// would cause a panic, which is undesirable in exception handling.
-pub(crate) unsafe fn out32(port: u16, val: u32) {
-    #[cfg(all(feature = "trace_guest", target_arch = "x86_64"))]
-    {
-        if let Some((ptr, len)) = hyperlight_guest_tracing::serialized_data() {
-            // If tracing is enabled and there is data to send, send it along with the OUT action
-            unsafe {
-                asm!("out dx, eax",
-                    in("dx") port,
-                    in("eax") val,
-                    in("r8") OutBAction::TraceBatch as u64,
-                    in("r9") ptr,
-                    in("r10") len,
-                    options(preserves_flags, nomem, nostack)
-                )
-            };
-
-            // Reset the trace state after sending the batch
-            // This clears all existing spans/events ensuring a clean state for the next operations
-            // The trace state is expected to be flushed before this call
-            hyperlight_guest_tracing::reset();
-        } else {
-            // If tracing is not enabled, just send the value
-            unsafe {
-                asm!("out dx, eax", in("dx") port, in("eax") val, options(preserves_flags, nomem, nostack))
-            };
-        }
-    }
-    #[cfg(not(all(feature = "trace_guest", target_arch = "x86_64")))]
-    unsafe {
-        asm!("out dx, eax", in("dx") port, in("eax") val, options(preserves_flags, nomem, nostack));
-    }
-}
-
 /// Prints a message using `OutBAction::DebugPrint`. It transmits bytes of a message
 /// through several VMExists and, with such, it is slower than
 /// `print_output_with_host_print`.