feat(globals): add CompilerGlobals

Author: Qard

allowed_bindings.rs

@@ -26,6 +26,7 @@ bind! {
     _efree,
     _emalloc,
     _zend_executor_globals,
+    _zend_compiler_globals,
     _sapi_globals_struct,
     _sapi_module_struct,
     _zend_expected_type,
@@ -41,6 +42,7 @@ bind! {
     _zval_struct__bindgen_ty_2,
     _zend_known_string_id,
     // ext_php_rs_executor_globals,
+    // ext_php_rs_compiler_globals,
     // ext_php_rs_php_build_id,
     // ext_php_rs_zend_object_alloc,
     // ext_php_rs_zend_object_release,
@@ -252,6 +254,7 @@ bind! {
     zend_class_serialize_deny,
     zend_class_unserialize_deny,
     zend_executor_globals,
+    zend_compiler_globals,
     sapi_module_struct,
     zend_objects_store_del,
     zend_hash_move_forward_ex,
@@ -263,6 +266,7 @@ bind! {
     gc_possible_root,
     ZEND_ACC_NOT_SERIALIZABLE,
     executor_globals,
+    compiler_globals,
     php_core_globals,
     core_globals,
     sapi_globals_struct,
@@ -272,6 +276,7 @@ bind! {
     __zend_malloc,
     tsrm_get_ls_cache,
     executor_globals_offset,
+    compiler_globals_offset,
     core_globals_offset,
     sapi_globals_offset,
     php_file_globals,

src/ffi.rs

@@ -26,6 +26,7 @@ extern "C" {
     pub fn ext_php_rs_zend_object_alloc(obj_size: usize, ce: *mut zend_class_entry) -> *mut c_void;
     pub fn ext_php_rs_zend_object_release(obj: *mut zend_object);
     pub fn ext_php_rs_executor_globals() -> *mut zend_executor_globals;
+    pub fn ext_php_rs_compiler_globals() -> *mut zend_compiler_globals;
     pub fn ext_php_rs_process_globals() -> *mut php_core_globals;
     pub fn ext_php_rs_sapi_globals() -> *mut sapi_globals_struct;
     pub fn ext_php_rs_file_globals() -> *mut php_file_globals;

src/wrapper.c

@@ -40,6 +40,18 @@ zend_executor_globals *ext_php_rs_executor_globals() {
 #endif
 }
 
+zend_compiler_globals *ext_php_rs_compiler_globals() {
+#ifdef ZTS
+#ifdef ZEND_ENABLE_STATIC_TSRMLS_CACHE
+  return TSRMG_FAST_BULK_STATIC(compiler_globals_offset, zend_compiler_globals);
+#else
+  return TSRMG_FAST_BULK(compiler_globals_offset, zend_compiler_globals *);
+#endif
+#else
+  return &compiler_globals;
+#endif
+}
+
 php_core_globals *ext_php_rs_process_globals() {
 #ifdef ZTS
 #ifdef ZEND_ENABLE_STATIC_TSRMLS_CACHE

src/zend/globals.rs

@@ -13,7 +13,8 @@ use crate::exception::PhpResult;
 #[cfg(php82)]
 use crate::ffi::zend_atomic_bool_store;
 use crate::ffi::{
-    _sapi_module_struct, _zend_executor_globals, ext_php_rs_executor_globals,
+    _sapi_module_struct, _zend_executor_globals, _zend_compiler_globals,
+    ext_php_rs_executor_globals, ext_php_rs_compiler_globals,
     ext_php_rs_file_globals, ext_php_rs_process_globals, ext_php_rs_sapi_globals,
     ext_php_rs_sapi_module, php_core_globals, php_file_globals, sapi_globals_struct,
     sapi_header_struct, sapi_headers_struct, sapi_request_info, zend_ini_entry,
@@ -35,9 +36,6 @@ use super::linked_list::ZendLinkedListIterator;
 /// Stores global variables used in the PHP executor.
 pub type ExecutorGlobals = _zend_executor_globals;
 
-/// Stores the SAPI module used in the PHP executor.
-pub type SapiModule = _sapi_module_struct;
-
 impl ExecutorGlobals {
     /// Returns a reference to the PHP executor globals.
     ///
@@ -226,6 +224,69 @@ impl ExecutorGlobals {
     }
 }
 
+pub type CompilerGlobals = _zend_compiler_globals;
+
+impl CompilerGlobals {
+    /// Returns a reference to the PHP compiler globals.
+    ///
+    /// The compiler globals are guarded by a [`RwLock`]. There can be multiple
+    /// immutable references at one time but only ever one mutable reference.
+    /// Attempting to retrieve the globals while already holding the global
+    /// guard will lead to a deadlock. Dropping the globals guard will release
+    /// the lock.
+    ///
+    /// # Panics
+    ///
+    /// * If static executor globals are not set
+    pub fn get() -> GlobalReadGuard<Self> {
+        // SAFETY: PHP compiler globals are statically declared therefore should never
+        // return an invalid pointer.
+        let globals = unsafe { ext_php_rs_compiler_globals().as_ref() }
+            .expect("Static compiler globals were invalid");
+
+        cfg_if::cfg_if! {
+            if #[cfg(php_zts)] {
+                let guard = lock::GLOBALS_LOCK.with(|l| l.read_arc());
+            } else {
+                let guard = lock::GLOBALS_LOCK.read_arc();
+            }
+        }
+
+        GlobalReadGuard { globals, guard }
+    }
+
+    /// Returns a mutable reference to the PHP compiler globals.
+    ///
+    /// The compiler globals are guarded by a [`RwLock`]. There can be multiple
+    /// immutable references at one time but only ever one mutable reference.
+    /// Attempting to retrieve the globals while already holding the global
+    /// guard will lead to a deadlock. Dropping the globals guard will release
+    /// the lock.
+    ///
+    /// # Panics
+    ///
+    /// * If static compiler globals are not set
+    pub fn get_mut() -> GlobalWriteGuard<Self> {
+        // SAFETY: PHP compiler globals are statically declared therefore should never
+        // return an invalid pointer.
+        let globals = unsafe { ext_php_rs_compiler_globals().as_mut() }
+            .expect("Static compiler globals were invalid");
+
+        cfg_if::cfg_if! {
+            if #[cfg(php_zts)] {
+                let guard = lock::GLOBALS_LOCK.with(|l| l.write_arc());
+            } else {
+                let guard = lock::GLOBALS_LOCK.write_arc();
+            }
+        }
+
+        GlobalWriteGuard { globals, guard }
+    }
+}
+
+/// Stores the SAPI module used in the PHP executor.
+pub type SapiModule = _sapi_module_struct;
+
 impl SapiModule {
     /// Returns a reference to the PHP SAPI module.
     ///
@@ -835,3 +896,26 @@ impl<T> DerefMut for GlobalWriteGuard<T> {
         self.globals
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_executor_globals() {
+        let state = ExecutorGlobals::get().active;
+        ExecutorGlobals::get_mut().active = !state;
+        let changed = ExecutorGlobals::get().active;
+        ExecutorGlobals::get_mut().active = state;
+        assert_eq!(changed, !state);
+    }
+
+    #[test]
+    fn test_compiler_globals() {
+        let state = CompilerGlobals::get().in_compilation;
+        CompilerGlobals::get_mut().in_compilation = !state;
+        let changed = CompilerGlobals::get().in_compilation;
+        CompilerGlobals::get_mut().in_compilation = state;
+        assert_eq!(changed, !state);
+    }
+}