Added timeout to locate issue

Author: CalebLItalien

common/src/constants.rs

@@ -8,3 +8,6 @@ pub const DEFAULT_BASIC_BLOCK_NAME: &str = "entry";
 
 /// Default name for modules.
 pub const DEFAULT_MODULE_NAME: &str = "main";
+
+/// Default timeout.
+pub const DEFAULT_TIMEOUT: u64 = 60;

common/src/pointer.rs

@@ -105,7 +105,7 @@ impl LLVMRef {
 
 /// Thread-safe pointer type for managing raw C pointers in a synchronized context.
 pub struct SafeLLVMPointer {
-    ptr: Arc<RwLock<NonNull<c_void>>>,
+    ptr: Arc<RwLock<*mut c_void>>,
     kind: LLVMRefType
 }
 
@@ -119,10 +119,14 @@ impl SafeLLVMPointer {
     /// An `Option` wrapped `SafeLLVMPointer` if the pointer is non-null, `None` otherwise.
     pub fn new(llvm_ref: LLVMRef, kind: LLVMRefType) -> Option<Self> {
         let raw_ptr = llvm_ref.to_raw();
-        NonNull::new(raw_ptr).map(|nn_ptr| SafeLLVMPointer {
-            ptr: Arc::new(RwLock::new(nn_ptr)),
-            kind,
-        })
+        if raw_ptr.is_null() {
+            None
+        } else {
+            Some(SafeLLVMPointer {
+                ptr: Arc::new(RwLock::new(raw_ptr)),
+                kind,
+            })
+        }
     }
 
     /// Provides read-only access to the pointed-to value.
@@ -147,7 +151,7 @@ impl SafeLLVMPointer {
         Closure: FnOnce(&LLVMRef) -> ReturnType,
     {
         let lock = self.ptr.read().expect("RwLock has been poisoned");
-        let ref_to_value = unsafe { LLVMRef::from_raw(lock.as_ptr(), kind) };
+        let ref_to_value = unsafe { LLVMRef::from_raw(*lock, kind) };
         closure(&ref_to_value)
     }
 
@@ -167,27 +171,10 @@ impl SafeLLVMPointer {
         Closure: FnOnce(&mut LLVMRef) -> ReturnType,
     {
         let lock = self.ptr.write().expect("RwLock has been poisoned");
-        let mut ref_to_mut_value = unsafe { LLVMRef::from_raw(lock.as_ptr(), kind) };
+        let mut ref_to_mut_value = unsafe { LLVMRef::from_raw(*lock, kind) };
         closure(&mut ref_to_mut_value)
     }
 }
 
-// impl Drop for SafeLLVMPointer {
-//     fn drop(&mut self) {
-//         let ptr = self.ptr.write().expect("Lock poisoned on drop.");
-//         let raw_ptr = ptr.as_ptr();  
-
-//         unsafe {
-//             match self.kind {
-//                 // LLVMRefType::Context => core::LLVMContextDispose(raw_ptr as LLVMContextRef),
-//                 // LLVMRefType::Module => core::LLVMDisposeModule(raw_ptr as LLVMModuleRef),
-//                 // LLVMRefType::Builder => core::LLVMDisposeBuilder(raw_ptr as LLVMBuilderRef),
-//                 LLVMRefType::ExecutionEngine => execution_engine::LLVMDisposeExecutionEngine(raw_ptr as LLVMExecutionEngineRef),
-//                 LLVMRefType::Value | 
-//                 LLVMRefType::BasicBlock |
-//                 LLVMRefType::Type => {},
-//                 _ => {},
-//             }
-//         }
-//     }
-// }
+unsafe impl Send for SafeLLVMPointer {}
+unsafe impl Sync for SafeLLVMPointer {}

jit/src/core.rs

@@ -2,7 +2,7 @@
 
 extern crate llvm_sys as llvm;
 use llvm::{core, execution_engine};
-use std::{any::Any, ffi::{c_char, CStr, CString}, sync::{Arc, RwLock}};
+use std::{any::Any, ffi::{c_char, CStr, CString}, sync::{mpsc, Arc, RwLock}, thread, time::Duration};
 use slog::Logger;
 use common::{pointer::{LLVMRef, LLVMRefType, SafeLLVMPointer}, target::{GeneralTargetConfigurator, TargetConfigurator}};
 
@@ -14,122 +14,196 @@ pub struct ExecutionEngine {
 }
 
 impl ExecutionEngine {
-    /// Constructs a new `ExecutionEngine`.
+    /// Constructs a new `ExecutionEngine` with a timeout.
     ///
     /// This method initializes a new LLVM context and module, configures the general target,
     /// and optionally sets up a logger for debugging information based on the `debug_info` parameter.
     ///
     /// # Parameters
     /// * `module` - A thread-safe `SafeLLVMPointer` containing an `LLVMModuleRef`.
     /// * `debug_info` - If true, initializes a logger to record debugging information.
+    /// * `timeout` - The maximum duration to wait for the initialization.
     ///
     /// # Returns
     /// A new instance of `ExecutionEngine`.
-    pub fn new(module: Arc<RwLock<SafeLLVMPointer>>, debug_info: bool) -> Self {
-        GeneralTargetConfigurator.configure();
-
-        let mut engine_ref: execution_engine::LLVMExecutionEngineRef = std::ptr::null_mut();
-        let mut out_error: *mut c_char = std::ptr::null_mut();
-        let engine_ptr = &mut engine_ref;
-
-        module.read().unwrap().read(LLVMRefType::Module, |module_ref| {
-            if let LLVMRef::Module(module_ptr) = module_ref {
-                unsafe {
-                    if execution_engine::LLVMCreateExecutionEngineForModule(engine_ptr, *module_ptr, &mut out_error) != 0 {
-                        if !out_error.is_null() {
-                            let error_str = CStr::from_ptr(out_error).to_str().unwrap_or("Unknown error");
-                            eprintln!("{}", error_str);
-                            core::LLVMDisposeMessage(out_error);
-                            panic!("Failed to create execution engine");
-                        } else {
-                            panic!("Failed to create execution engine with unknown error.");
+    pub fn new(module: Arc<RwLock<SafeLLVMPointer>>, debug_info: bool, timeout: Duration) -> Result<Self, String> {
+        let (sender, receiver) = mpsc::channel();
+        let logger = if debug_info {
+            Some(logging::core::init_logger())
+        } else {
+            None
+        };
+
+        let logger_clone = logger.clone(); 
+
+        thread::spawn(move || {
+            GeneralTargetConfigurator.configure();
+
+            let mut engine_ref: execution_engine::LLVMExecutionEngineRef = std::ptr::null_mut();
+            let mut out_error: *mut c_char = std::ptr::null_mut();
+            let engine_ptr = &mut engine_ref;
+
+            let result = module.read().unwrap().read(LLVMRefType::Module, |module_ref| {
+                if let LLVMRef::Module(module_ptr) = module_ref {
+                    unsafe {
+                        if execution_engine::LLVMCreateExecutionEngineForModule(engine_ptr, *module_ptr, &mut out_error) != 0 {
+                            if !out_error.is_null() {
+                                let error_str = CStr::from_ptr(out_error).to_str().unwrap_or("Unknown error");
+                                core::LLVMDisposeMessage(out_error);
+                                return Err(format!("Failed to create execution engine: {}", error_str));
+                            } else {
+                                return Err("Failed to create execution engine with unknown error.".to_string());
+                            }
                         }
                     }
+                    Ok(())
+                } else {
+                    Err("Module pointer is not correctly retrieved.".to_string())
                 }
-            } else {
-                panic!("Module pointer is not correctly retrieved.");
+            });
+
+            if let Err(e) = result {
+                if let Some(logger) = &logger_clone {
+                    logging::core::log_error(logger, &e);
+                }
+                sender.send(Err(e)).unwrap();
+                return;
             }
-        });
 
-        let engine_cptr = SafeLLVMPointer::new(LLVMRef::ExecutionEngine(engine_ref), LLVMRefType::ExecutionEngine).expect("Engine cannot be null");
+            let engine_cptr = SafeLLVMPointer::new(LLVMRef::ExecutionEngine(engine_ref), LLVMRefType::ExecutionEngine).expect("Engine cannot be null");
 
-        let logger = if debug_info {
-            Some(logging::core::init_logger())
-        } else {
-            None
-        };
+            sender.send(Ok(Self {
+                engine: Arc::new(RwLock::new(engine_cptr)),
+                logger: logger_clone,
+            })).unwrap();
+        });
 
-        Self {
-            engine: Arc::new(RwLock::new(engine_cptr)),
-            logger,
+        match receiver.recv_timeout(timeout) {
+            Ok(result) => result,
+            Err(_) => {
+                if let Some(logger) = &logger {
+                    logging::core::log_error(&logger, "Initialization timed out.");
+                }
+                Err("Initialization timed out.".to_string())
+            }
         }
     }
 
-    /// Configures the LLVM execution engine using a specified target configurator.
+    /// Configures the LLVM execution engine using a specified target configurator with a timeout.
     ///
     /// # Parameters
     /// * `target_configurator` - The target configurator to setup necessary LLVM targets.
+    /// * `timeout` - The maximum duration to wait for the configuration.
     ///
     /// # Returns
     /// Returns `Ok(())` on successful configuration and initialization, or `Err(String)` on failure,
     /// including detailed error messages.
-    pub fn initialize_target<T: TargetConfigurator>(&mut self, target_configurator: T) -> Result<(), String> {
-        target_configurator.configure();
-        if let Some(logger) = &self.logger {
-            logging::core::log_info(&logger, "Target configured.");
+    pub fn initialize_target<T>(&mut self, target_configurator: T, timeout: Duration) -> Result<(), String> 
+    where
+        T: TargetConfigurator + Send + 'static,
+    {
+        let (sender, receiver) = mpsc::channel();
+        let logger = self.logger.clone();
+
+        thread::spawn(move || {
+            target_configurator.configure();
+            if let Some(logger) = &logger {
+                logging::core::log_info(&logger, "Target configured.");
+            }
+            sender.send(Ok(())).unwrap();
+        });
+
+        match receiver.recv_timeout(timeout) {
+            Ok(result) => result,
+            Err(_) => {
+                if let Some(logger) = &self.logger {
+                    logging::core::log_error(logger, "Target configuration timed out.");
+                }
+                Err("Target configuration timed out.".to_string())
+            }
         }
-        Ok(())
     }
 
-    /// Executes a specified function within the module.
+    /// Executes a specified function within the module with a timeout.
     ///
     /// # Parameters
     /// * `function_name` - The name of the function to be executed.
+    /// * `args` - The arguments to be passed to the function.
+    /// * `timeout` - The maximum duration to wait for the function to execute.
     ///
     /// # Returns
     /// Returns `Ok(())` if the function is executed successfully, or `Err(String)` if an error occurs,
-    /// which could include the function not being found or an execution error.
-    /// Executes a specified function.
-    pub fn execute<ReturnType, ArgType>(&mut self, function_name: &str, args: ArgType) -> Result<ReturnType, String>
+    /// which could include the function not being found, an execution error, or a timeout.
+    pub fn execute<ReturnType, ArgType>(&mut self, function_name: &str, args: ArgType, timeout: Duration) -> Result<ReturnType, String>
     where
-        ReturnType: 'static, 
-        ArgType: Any + Send + Sync, 
+        ReturnType: 'static + Send, 
+        ArgType: Any + Send + Sync + 'static, 
     {
-        let engine_lock = self.engine.read().map_err(|e| format!("Failed to obtain read lock on engine: {}", e))?;
-        let result = engine_lock.read(LLVMRefType::ExecutionEngine, |engine_ref| {
-            if let LLVMRef::ExecutionEngine(engine_ptr) = engine_ref {
-                let function_name_c = CString::new(function_name).map_err(|_| "Failed to create CString for function name.")?;
-                let function_address = unsafe { execution_engine::LLVMGetFunctionAddress(*engine_ptr, function_name_c.as_ptr()) };
-                
-                if function_address == 0 {
-                    if let Some(logger) = &self.logger {
-                        logging::core::log_warning(&logger, &format!("Function \"{}\" not found.", function_name));
-                    }
-                    return Err("Function not found in given module.".to_string());
-                }
+        let (sender, receiver) = mpsc::channel();
+        let engine_lock = self.engine.clone();
+        let function_name = function_name.to_string();
 
-                unsafe {
-                    let func: extern "C" fn(ArgType) -> ReturnType = std::mem::transmute(function_address);
-                    Ok(func(args))
-                }
-            } else {
-                Err("Invalid engine pointer.".to_string())
-            }
+        thread::spawn(move || {
+            let result = engine_lock.read().map_err(|e| format!("Failed to obtain read lock on engine: {}", e))
+                .and_then(|engine| {
+                    engine.read(LLVMRefType::ExecutionEngine, |engine_ref| {
+                        if let LLVMRef::ExecutionEngine(engine_ptr) = engine_ref {
+                            let function_name_c = CString::new(function_name.clone()).map_err(|_| "Failed to create CString for function name.")?;
+                            let function_address = unsafe { execution_engine::LLVMGetFunctionAddress(*engine_ptr, function_name_c.as_ptr()) };
+
+                            if function_address == 0 {
+                                return Err("Function not found in given module.".to_string());
+                            }
+
+                            unsafe {
+                                let func: extern "C" fn(ArgType) -> ReturnType = std::mem::transmute(function_address);
+                                Ok(func(args))
+                            }
+                        } else {
+                            Err("Invalid engine pointer.".to_string())
+                        }
+                    })
+                });
+
+            sender.send(result).unwrap_or_else(|e| eprintln!("Failed to send result: {}", e));
         });
 
-        match result {
-            Ok(value) => {
-                if let Some(logger) = &self.logger {
-                    logging::core::log_info(&logger, &format!("Function '{}' executed successfully.", function_name));
+        match receiver.recv_timeout(timeout) {
+            Ok(result) => {
+                match result {
+                    Ok(value) => {
+                        if let Some(logger) = &self.logger {
+                            logging::core::log_info(logger, &format!("Function executed successfully."));
+                        }
+                        Ok(value)
+                    },
+                    Err(e) => Err(e),
                 }
-                Ok(value)
             },
-            Err(e) => {
+            Err(_) => {
                 if let Some(logger) = &self.logger {
-                    logging::core::log_error(&logger, &format!("Execution error: {}", e));
+                    logging::core::log_error(logger, &format!("Execution of function timed out."));
                 }
-                Err(e)
+                Err("Execution timed out.".to_string())
             }
         }
     }
-}
+}
+
+impl Drop for ExecutionEngine {
+    fn drop(&mut self) {
+        if let Ok(engine_lock) = self.engine.write() {
+            engine_lock.write(LLVMRefType::ExecutionEngine, |engine_ref| {
+                if let LLVMRef::ExecutionEngine(engine_ptr) = engine_ref {
+                    unsafe {
+                        execution_engine::LLVMDisposeExecutionEngine(*engine_ptr);
+                    }
+                }
+            });
+        }
+
+        if let Some(logger) = &self.logger {
+            logging::core::log_info(logger, "Execution engine disposed.");
+        }
+    }
+}