Merge pull request #148 from madsmtm/faster-build

Remove `objc2` build script

Author: madsmtm

objc-sys/Cargo.toml

@@ -1,6 +1,8 @@
 [package]
 name = "objc-sys"
-version = "0.2.0-alpha.1" # Remember to update html_root_url in lib.rs
+# Remember to update `html_root_url` in lib.rs, the `links` key, and the
+# exception function name.
+version = "0.2.0-alpha.1"
 authors = ["Mads Marquart <[email protected]>"]
 edition = "2021"
 
@@ -43,6 +45,12 @@ winobjc = ["gnustep-1-8"]
 # TODO
 objfw = []
 
+# Private/unstable features - must not be relied on!
+unstable-exception = ["cc"]
+
+[build-dependencies]
+cc = { version = "1", optional = true }
+
 [package.metadata.docs.rs]
 default-target = "x86_64-apple-darwin"
 no-default-features = true

objc-sys/build.rs

@@ -67,6 +67,7 @@ fn main() {
     // println!("cargo:rustc-cfg=libobjc2_strict_apple_compat");
 
     let target_os = env::var("CARGO_CFG_TARGET_OS").unwrap();
+    let target_arch = env::var("CARGO_CFG_TARGET_ARCH").unwrap();
 
     let mut apple = env::var_os("CARGO_FEATURE_APPLE").is_some();
     let mut gnustep = env::var_os("CARGO_FEATURE_GNUSTEP_1_7").is_some();
@@ -138,12 +139,21 @@ fn main() {
     };
     println!("cargo:rustc-cfg={}", runtime_cfg);
 
+    if let Apple(runtime) = &runtime {
+        // A few things are defined differently depending on the __OBJC2__
+        // variable, which is set for all platforms except 32-bit macOS.
+        if let (MacOS(_), "x86") = (runtime, &*target_arch) {
+            println!("cargo:rustc-cfg=apple_old");
+        } else {
+            println!("cargo:rustc-cfg=apple_new");
+        }
+    }
+
     let clang_runtime = match &runtime {
         Apple(runtime) => {
             // The fragile runtime is expected on i686-apple-darwin, see:
             // https://github.com/llvm/llvm-project/blob/release/13.x/clang/lib/Driver/ToolChains/Darwin.h#L228-L231
             // https://github.com/llvm/llvm-project/blob/release/13.x/clang/lib/Driver/ToolChains/Clang.cpp#L3639-L3640
-            let target_arch = env::var("CARGO_CFG_TARGET_ARCH").unwrap();
             let clang_runtime_str = match (runtime, &*target_arch) {
                 (MacOS(_), "x86") => "macosx-fragile",
                 (MacOS(_), _) => "macosx",
@@ -211,4 +221,25 @@ fn main() {
         // Link to libobjc
         println!("cargo:rustc-link-lib=dylib=objc");
     }
+
+    // We do this compilation step here instead of in `objc2` to cut down on
+    // the total number of build scripts required.
+    #[cfg(feature = "unstable-exception")]
+    {
+        if std::env::var("DOCS_RS").is_ok() {
+            // docs.rs doesn't have clang, so skip building this. The
+            // documentation will still work since it doesn't need to link.
+            return;
+        }
+        println!("cargo:rerun-if-changed=extern/exception.m");
+
+        let mut builder = cc::Build::new();
+        builder.file("extern/exception.m");
+
+        for flag in cc_args.split(' ') {
+            builder.flag(flag);
+        }
+
+        builder.compile("librust_objc_sys_0_2_try_catch_exception.a");
+    }
 }

objc2/extern/exception.m renamed to objc-sys/extern/exception.m

@@ -6,8 +6,10 @@
 /// See <https://clang.llvm.org/docs/AutomaticReferenceCounting.html#arc-runtime-objc-retain>.
 id objc_retain(id value);
 
-// We return `unsigned char`, since it is guaranteed to be an `u8` on all platforms
-unsigned char rust_objc_try_catch_exception(void (*f)(void *), void *context, id *error) {
+/// Unsure how C name resolution works, so we make sure to version this symbol.
+///
+/// Return `unsigned char` since it is guaranteed to be `u8` on all platforms.
+unsigned char rust_objc_sys_0_2_try_catch_exception(void (*f)(void *), void *context, id *error) {
     @try {
         f(context);
         if (error) {

objc-sys/src/exception-macos-x86.rs

@@ -2,27 +2,29 @@
 //! Apple: `objc-exception.h`
 //! GNUStep: `eh_personality.c`, which is a bit brittle to rely on, but I
 //!   think it's fine...
-#[cfg(not(objfw))]
+#[cfg(any(not(objfw), feature = "unstable-exception"))]
 use core::ffi::c_void;
-#[cfg(apple)]
+#[cfg(apple_new)]
 use std::os::raw::c_int;
+#[cfg(feature = "unstable-exception")]
+use std::os::raw::c_uchar;
 
-#[cfg(apple)]
+#[cfg(apple_new)]
 use crate::objc_class;
 use crate::objc_object;
 
 /// Remember that this is non-null!
-#[cfg(apple)]
+#[cfg(apple_new)]
 pub type objc_exception_matcher =
     unsafe extern "C" fn(catch_type: *mut objc_class, exception: *mut objc_object) -> c_int;
 
 /// Remember that this is non-null!
-#[cfg(apple)]
+#[cfg(apple_new)]
 pub type objc_exception_preprocessor =
     unsafe extern "C" fn(exception: *mut objc_object) -> *mut objc_object;
 
 /// Remember that this is non-null!
-#[cfg(apple)]
+#[cfg(apple_new)]
 pub type objc_uncaught_exception_handler = unsafe extern "C" fn(exception: *mut objc_object);
 
 #[cfg(objfw)]
@@ -32,45 +34,79 @@ pub type objc_uncaught_exception_handler =
 /// Only available on macOS.
 ///
 /// Remember that this is non-null!
-#[cfg(all(apple, target_os = "macos"))]
+#[cfg(all(apple_new, target_os = "macos"))]
 pub type objc_exception_handler =
     unsafe extern "C" fn(unused: *mut objc_object, context: *mut c_void);
 
 extern_c! {
-    #[cfg(not(objfw))]
+    #[cfg(any(gnustep, apple_new))]
     pub fn objc_begin_catch(exc_buf: *mut c_void) -> *mut objc_object;
-    #[cfg(not(objfw))]
+    #[cfg(any(gnustep, apple_new))]
     pub fn objc_end_catch();
     /// See [`objc-exception.h`].
     ///
     /// [`objc-exception.h`]: https://github.com/apple-oss-distributions/objc4/blob/objc4-818.2/runtime/objc-exception.h
     pub fn objc_exception_throw(exception: *mut objc_object) -> !;
-    #[cfg(apple)]
+    #[cfg(apple_new)]
     pub fn objc_exception_rethrow() -> !;
+
+    #[cfg(apple_old)]
+    pub fn objc_exception_try_enter(exception_data: *const c_void);
+
+    #[cfg(apple_old)]
+    pub fn objc_exception_try_exit(exception_data: *const c_void);
+
+    // objc_exception_extract
+    // objc_exception_match
+    // objc_exception_get_functions
+    // objc_exception_set_functions
+
     #[cfg(any(gnustep, winobjc))]
     pub fn objc_exception_rethrow(exc_buf: *mut c_void) -> !;
 
-    #[cfg(apple)]
+    #[cfg(apple_new)]
     pub fn objc_setExceptionMatcher(f: objc_exception_matcher) -> objc_exception_matcher;
-    #[cfg(apple)]
+    #[cfg(apple_new)]
     pub fn objc_setExceptionPreprocessor(
         f: objc_exception_preprocessor,
     ) -> objc_exception_preprocessor;
-    #[cfg(any(apple, objfw))]
+    #[cfg(any(apple_new, objfw))]
     pub fn objc_setUncaughtExceptionHandler(
         f: objc_uncaught_exception_handler,
     ) -> objc_uncaught_exception_handler;
 
     /// Only available on macOS.
-    #[cfg(all(apple, target_os = "macos"))]
+    #[cfg(all(apple_new, target_os = "macos"))]
     pub fn objc_addExceptionHandler(f: objc_exception_handler, context: *mut c_void) -> usize;
     /// Only available on macOS.
-    #[cfg(all(apple, target_os = "macos"))]
+    #[cfg(all(apple_new, target_os = "macos"))]
     pub fn objc_removeExceptionHandler(token: usize);
 
     // Only available when ENABLE_OBJCXX is set, and a useable C++ runtime is
     // present when building libobjc2.
     //
     // #[cfg(gnustep)]
     // pub fn objc_set_apple_compatible_objcxx_exceptions(newValue: c_int) -> c_int;
+
+    /// Call the given function inside an Objective-C `@try/@catch` block.
+    ///
+    /// Defined in `extern/exception.m` and compiled in `build.rs`.
+    ///
+    /// Alternatively, we could manually write assembly for this function like
+    /// [`objrs` does][manual-asm] does, that would cut down on a build stage
+    /// (and would probably give us a bit better performance), but it gets
+    /// unwieldy _very_ quickly, so I chose the much more stable option.
+    ///
+    /// Another thing to remember: While Rust's and Objective-C's unwinding
+    /// mechanisms are similar now, Rust's is explicitly unspecified, and they
+    /// may diverge significantly in the future; so handling this in pure Rust
+    /// (using mechanisms like core::intrinsics::r#try) is not an option!
+    ///
+    /// [manual-asm]: https://gitlab.com/objrs/objrs/-/blob/b4f6598696b3fa622e6fddce7aff281770b0a8c2/src/exception.rs
+    #[cfg(feature = "unstable-exception")]
+    pub fn rust_objc_sys_0_2_try_catch_exception(
+        f: extern "C" fn(*mut c_void),
+        context: *mut c_void,
+        error: *mut *mut objc_object,
+    ) -> c_uchar;
 }

objc-sys/src/exception.rs

@@ -93,12 +93,7 @@ macro_rules! extern_c {
 mod class;
 mod constants;
 
-#[cfg(not(all(apple, target_os = "macos", target_arch = "x86")))]
 mod exception;
-#[cfg(all(apple, target_os = "macos", target_arch = "x86"))]
-#[path = "exception-macos-x86.rs"]
-mod exception;
-
 mod message;
 mod method;
 mod object;

objc-sys/src/lib.rs

@@ -24,14 +24,14 @@ pub type IMP = Option<unsafe extern "C" fn()>;
 // /// Not available on macOS x86.
 // ///
 // /// Remember that this is non-null!
-// #[cfg(all(apple, not(all(target_os = "macos", target_arch = "x86"))))]
+// #[cfg(apple_new)]
 // pub type objc_hook_getClass =
 //     unsafe extern "C" fn(name: *const c_char, out_cls: *mut *const crate::objc_class) -> BOOL;
 //
 // /// Not available on macOS x86.
 // ///
 // /// Remember that this is non-null!
-// #[cfg(all(apple, not(all(target_os = "macos", target_arch = "x86"))))]
+// #[cfg(apple_new)]
 // pub type objc_hook_lazyClassNamer =
 //     unsafe extern "C" fn(cls: *const crate::objc_class) -> *const c_char;
 
@@ -94,7 +94,7 @@ extern_c! {
     // /// Not available on macOS x86.
     // ///
     // /// Remember that this is non-null!
-    // #[cfg(all(apple, not(all(target_os = "macos", target_arch = "x86"))))]
+    // #[cfg(apple_new)]
     // pub fn objc_setHook_getClass(
     //     new_value: objc_hook_getClass,
     //     out_old_value: *mut objc_hook_getClass,
@@ -103,7 +103,7 @@ extern_c! {
     // /// Not available on macOS x86.
     // ///
     // /// Remember that this is non-null!
-    // #[cfg(all(apple, not(all(target_os = "macos", target_arch = "x86"))))]
+    // #[cfg(apple_new)]
     // pub fn objc_setHook_lazyClassNamer(
     //     new_value: objc_hook_lazyClassNamer,
     //     out_old_value: *mut objc_hook_lazyClassNamer,

objc-sys/src/various.rs

@@ -16,15 +16,13 @@ repository = "https://github.com/madsmtm/objc2"
 documentation = "https://docs.rs/objc2/"
 license = "MIT"
 
-build = "build.rs"
-
 # NOTE: 'unstable' features are _not_ considered part of the SemVer contract,
 # and may be removed in a minor release.
 [features]
 default = ["apple"]
 
 # Enables `objc2::exception::throw` and `objc2::exception::catch`
-exception = ["cc"]
+exception = ["objc-sys/unstable-exception"]
 
 # Wrap every `objc2::msg_send` call in a `@try/@catch` block
 catch_all = ["exception"]
@@ -56,9 +54,6 @@ malloc_buf = { version = "1.0", optional = true }
 objc-sys = { path = "../objc-sys", version = "=0.2.0-alpha.1", default-features = false }
 objc2-encode = { path = "../objc2-encode", version = "=2.0.0-beta.2", default-features = false }
 
-[build-dependencies]
-cc = { version = "1", optional = true }
-
 [dev-dependencies]
 iai = { version = "0.1", git = "https://github.com/madsmtm/iai", branch = "callgrind" }
 

objc2/Cargo.toml

@@ -20,35 +20,11 @@
 use core::ffi::c_void;
 use core::mem;
 use core::ptr;
-use std::os::raw::c_uchar;
 
 use crate::ffi;
 use crate::rc::{Id, Shared};
 use crate::runtime::Object;
 
-extern "C" {
-    /// Call the given function inside an Objective-C `@try/@catch` block.
-    ///
-    /// Defined in `extern/exception.m` and compiled in `build.rs`.
-    ///
-    /// Alternatively, we could manually write assembly for this function like
-    /// [`objrs` does][manual-asm] does, that would cut down on a build stage
-    /// (and would probably give us a bit better performance), but it gets
-    /// unwieldy _very_ quickly, so I chose the much more stable option.
-    ///
-    /// Another thing to remember: While Rust's and Objective-C's unwinding
-    /// mechanisms are similar now, Rust's is explicitly unspecified, and they
-    /// may diverge significantly in the future; so handling this in pure Rust
-    /// (using mechanisms like core::intrinsics::r#try) is not an option!
-    ///
-    /// [manual-asm]: https://gitlab.com/objrs/objrs/-/blob/b4f6598696b3fa622e6fddce7aff281770b0a8c2/src/exception.rs
-    fn rust_objc_try_catch_exception(
-        f: extern "C" fn(*mut c_void),
-        context: *mut c_void,
-        error: *mut *mut ffi::objc_object,
-    ) -> c_uchar;
-}
-
 /// Throws an Objective-C exception.
 ///
 /// The argument must be a pointer to an Objective-C object.
@@ -87,7 +63,7 @@ unsafe fn try_no_ret<F: FnOnce()>(closure: F) -> Result<(), Option<Id<Object, Sh
     let context = &mut closure as *mut _ as *mut c_void;
 
     let mut exception = ptr::null_mut();
-    let success = unsafe { rust_objc_try_catch_exception(f, context, &mut exception) };
+    let success = unsafe { ffi::rust_objc_sys_0_2_try_catch_exception(f, context, &mut exception) };
 
     if success == 0 {
         Ok(())