Hackily implement raw_dylib_macho using LLVM's TextAPI

Author: madsmtm

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -386,7 +386,8 @@ fn link_rlib<'a>(
 
     // On Windows, we add the raw-dylib import libraries to the rlibs already.
     // But on ELF, this is not possible, as a shared object cannot be a member of a static library.
-    // Instead, we add all raw-dylibs to the final link on ELF.
+    // Similarly on Mach-O, `.tbd` files cannot be members of static libraries.
+    // Instead, we add all raw-dylibs to the final link on ELF/Mach-O.
     if sess.target.is_like_windows {
         for output_path in raw_dylib::create_raw_dylib_dll_import_libs(
             sess,
@@ -2357,6 +2358,14 @@ fn linker_with_args(
         ) {
             cmd.add_object(&output_path);
         }
+    } else if sess.target.is_like_darwin {
+        for link_path in raw_dylib::create_raw_dylib_macho_tapi(
+            sess,
+            codegen_results.crate_info.used_libraries.iter(),
+            tmpdir,
+        ) {
+            cmd.link_dylib_by_path(&link_path, true);
+        }
     } else {
         for link_path in raw_dylib::create_raw_dylib_elf_stub_shared_objects(
             sess,
@@ -2404,6 +2413,12 @@ fn linker_with_args(
         ) {
             cmd.add_object(&output_path);
         }
+    } else if sess.target.is_like_darwin {
+        for link_path in
+            raw_dylib::create_raw_dylib_macho_tapi(sess, native_libraries_from_nonstatics, tmpdir)
+        {
+            cmd.link_dylib_by_path(&link_path, true);
+        }
     } else {
         for link_path in raw_dylib::create_raw_dylib_elf_stub_shared_objects(
             sess,

compiler/rustc_codegen_ssa/src/back/link/raw_dylib.rs

@@ -1,5 +1,7 @@
+use std::ffi::CString;
 use std::fs;
 use std::io::{BufWriter, Write};
+use std::mem::ManuallyDrop;
 use std::path::{Path, PathBuf};
 
 use rustc_abi::Endian;
@@ -11,6 +13,7 @@ use rustc_hir::attrs::NativeLibKind;
 use rustc_session::Session;
 use rustc_session::cstore::DllImport;
 use rustc_span::Symbol;
+use rustc_target::spec::apple::OSVersion;
 
 use crate::back::archive::ImportLibraryItem;
 use crate::back::link::ArchiveBuilderBuilder;
@@ -126,6 +129,129 @@ pub(super) fn create_raw_dylib_dll_import_libs<'a>(
         .collect()
 }
 
+/// Mach-O linkers support the TAPI/TBD (TextAPI / Text-based Stubs) format as an alternative to
+/// a full dynamic library.
+///
+/// TODO.
+pub(super) fn create_raw_dylib_macho_tapi<'a>(
+    sess: &Session,
+    used_libraries: impl IntoIterator<Item = &'a NativeLib>,
+    tmpdir: &Path,
+) -> impl Iterator<Item = PathBuf> {
+    collate_raw_dylibs(sess, used_libraries).into_iter().map(|(install_name, raw_dylib_imports)| {
+        // TODO: Do this properly
+        let path = tmpdir.join(Path::new(&install_name).file_stem().unwrap()).with_extension("tbd");
+
+        let exports: Vec<_> = raw_dylib_imports
+            .iter()
+            .map(|import| {
+                let name = if let Some(name) = import.name.as_str().strip_prefix("\x01") {
+                    name.to_string()
+                } else {
+                    format!("_{}", import.name.as_str())
+                };
+                LLVMRustMachOTbdExport {
+                    // TODO
+                    name: ManuallyDrop::new(CString::new(name).unwrap()).as_ptr(),
+                    flags: if import.is_fn { SymbolFlags::Text } else { SymbolFlags::Data },
+                    kind: EncodeKind::GlobalSymbol,
+                }
+            })
+            .collect();
+
+        unsafe {
+            macho_tbd_write(
+                &path,
+                &sess.target.llvm_target,
+                &install_name,
+                OSVersion::new(1, 0, 0),
+                OSVersion::new(1, 0, 0),
+                &exports,
+            )
+            .unwrap()
+        };
+
+        path
+    })
+}
+
+bitflags::bitflags! {
+    #[repr(transparent)]
+    #[derive(Copy, Clone)]
+    pub(crate) struct SymbolFlags: u8 {
+        const None = 0;
+        const ThreadLocalValue = 1 << 0;
+        const WeakDefined = 1 << 1;
+        const WeakReferenced = 1 << 2;
+        const Undefined = 1 << 3;
+        const Rexported = 1 << 4;
+        const Data = 1 << 5;
+        const Text = 1 << 6;
+    }
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+#[repr(u8)]
+#[allow(unused)]
+pub(crate) enum EncodeKind {
+    GlobalSymbol = 0,
+    ObjectiveCClass = 1,
+    ObjectiveCClassEHType = 2,
+    ObjectiveCInstanceVariable = 3,
+}
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub(crate) struct LLVMRustMachOTbdExport {
+    pub(crate) name: *const std::ffi::c_char,
+    pub(crate) flags: SymbolFlags,
+    pub(crate) kind: EncodeKind,
+}
+
+unsafe extern "C" {
+    pub(crate) fn LLVMRustMachoTbdWrite(
+        path: *const std::ffi::c_char,
+        llvm_target_name: *const std::ffi::c_char,
+        install_name: *const std::ffi::c_char,
+        current_version: u32,
+        compatibility_version: u32,
+        exports: *const LLVMRustMachOTbdExport,
+        num_exports: libc::size_t,
+    ) -> u8;
+}
+
+unsafe fn macho_tbd_write(
+    path: &Path,
+    llvm_target_name: &str,
+    install_name: &str,
+    current_version: OSVersion,
+    compatibility_version: OSVersion,
+    exports: &[LLVMRustMachOTbdExport],
+) -> Result<(), ()> {
+    let path = CString::new(path.to_str().unwrap()).unwrap();
+    let llvm_target_name = CString::new(llvm_target_name).unwrap();
+    let install_name = CString::new(install_name).unwrap();
+
+    fn pack_version(OSVersion { major, minor, patch }: OSVersion) -> u32 {
+        let (major, minor, patch) = (major as u32, minor as u32, patch as u32);
+        (major << 16) | (minor << 8) | patch
+    }
+
+    let result = unsafe {
+        LLVMRustMachoTbdWrite(
+            path.as_ptr(),
+            llvm_target_name.as_ptr(),
+            install_name.as_ptr(),
+            pack_version(current_version),
+            pack_version(compatibility_version),
+            exports.as_ptr(),
+            exports.len(),
+        )
+    };
+
+    if result == 0 { Ok(()) } else { Err(()) }
+}
+
 pub(super) fn create_raw_dylib_elf_stub_shared_objects<'a>(
     sess: &Session,
     used_libraries: impl IntoIterator<Item = &'a NativeLib>,

compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp

@@ -35,6 +35,10 @@
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/ToolOutputFile.h"
+#include "llvm/TextAPI/Architecture.h"
+#include "llvm/TextAPI/InterfaceFile.h"
+#include "llvm/TextAPI/Platform.h"
+#include "llvm/TextAPI/TextAPIWriter.h"
 #include <iostream>
 
 // for raw `write` in the bad-alloc handler
@@ -1945,3 +1949,52 @@ extern "C" void LLVMRustSetNoSanitizeHWAddress(LLVMValueRef Global) {
   MD.NoHWAddress = true;
   GV.setSanitizerMetadata(MD);
 }
+
+struct LLVMRustMachOTbdExport {
+  char *name;
+  MachO::SymbolFlags flags;
+  MachO::EncodeKind kind;
+};
+
+extern "C" uint8_t LLVMRustMachoTbdWrite(
+    const char *Path,
+    const char *LLVMTargetName,
+    const char *InstallName,
+    uint32_t CurrentVersion,
+    uint32_t CompatibilityVersion,
+    const LLVMRustMachOTbdExport *Exports,
+    size_t NumExports) {
+  MachO::InterfaceFile File;
+  File.setFileType(MachO::FileType::TBD_V1); // TODO
+
+  File.setInstallName(StringRef(InstallName));
+  File.setCurrentVersion(MachO::PackedVersion(CurrentVersion));
+  File.setCompatibilityVersion(MachO::PackedVersion(CompatibilityVersion));
+  // File.setTwoLevelNamespace();
+
+  // auto Arch = MachO::getArchitectureFromName(Arch);
+  // auto Platform = MachO::getPlatformFromName(PlatPlatform);
+  MachO::Target Target{Triple(LLVMTargetName)};
+  File.addTarget(Target);
+
+  for (size_t i = 0; i < NumExports; i++) {
+    File.addSymbol(Exports[i].kind, StringRef(Exports[i].name), Target, Exports[i].flags);
+  }
+
+  std::string ErrorInfo;
+  std::error_code EC;
+  raw_fd_ostream OS(Path, EC, sys::fs::CD_CreateAlways);
+  if (EC)
+    ErrorInfo = EC.message();
+  if (ErrorInfo != "") {
+    LLVMRustSetLastError(ErrorInfo.c_str());
+    return -1;
+  }
+
+  if (Error Err = MachO::TextAPIWriter::writeToStream(OS, File)) {
+      LLVMRustSetLastError(toString(std::move(Err)).c_str());
+      return -1;
+  }
+
+  return 0;
+}

src/doc/unstable-book/src/language-features/raw-dylib-macho.md

@@ -0,0 +1,74 @@
+# `raw_dylib_macho`
+
+The tracking issue for this feature is: [#146356]
+
+[#146356]: https://github.com/rust-lang/rust/issues/146356
+
+------------------------
+
+The `raw_dylib_macho` feature enables support for Mach-O/Darwin/Apple platforms
+when using the `raw-dylib` linkage kind.
+
+The `+verbatim` modifier currently must be set (though this restriction may be
+lifted in the future).
+
+```rust
+//! Link to CoreFoundation without having to have the linker stubs available.
+#![feature(raw_dylib_macho)]
+#![cfg(target_vendor = "apple")]
+
+#[link(
+    name = "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation",
+    kind = "raw-dylib",
+    modifiers = "+verbatim",
+)]
+unsafe extern "C" {
+    // Example function.
+    safe fn CFRunLoopGetTypeID() -> core::ffi::c_ulong;
+}
+
+fn main() {
+    let _ = CFRunLoopGetTypeID();
+}
+```
+
+```rust
+//! Weakly link to a symbol in libSystem.dylib that has been introduced
+//! later than macOS 10.12 (which might mean that host tooling will have
+//! trouble linking if it doesn't have the newer linker stubs available).
+#![feature(raw_dylib_macho)]
+#![feature(linkage)]
+#![cfg(target_vendor = "apple")]
+
+use std::ffi::{c_int, c_void};
+
+#[link(name = "/usr/lib/libSystem.B.dylib", kind = "raw-dylib", modifiers = "+verbatim")]
+unsafe extern "C" {
+    #[linkage = "extern_weak"]
+    safe static os_sync_wait_on_address: Option<unsafe extern "C" fn(*mut c_void, u64, usize, u32) -> c_int>;
+}
+
+fn main() {
+    if let Some(_wait_on_address) = os_sync_wait_on_address {
+        // Use new symbol
+    } else {
+        // Fallback implementation
+    }
+}
+```
+
+```rust,no_run
+//! Link to a library relative to where the current binary will be installed,
+//! without having that library available.
+#![feature(raw_dylib_macho)]
+#![cfg(target_vendor = "apple")]
+
+#[link(name = "@executable_path/libfoo.dylib", kind = "raw-dylib", modifiers = "+verbatim")]
+unsafe extern "C" {
+    safe fn foo();
+}
+
+fn main() {
+    foo();
+}
+```

tests/ui/linkage-attr/raw-dylib/macho/Empty.sdk/.gitkeep

@@ -0,0 +1,21 @@
+//! Link to CoreFoundation without having to have the linker stubs available.
+
+//@ only-apple
+//@ run-pass
+
+#![allow(incomplete_features)]
+#![feature(raw_dylib_macho)]
+
+#[link(
+    name = "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation",
+    kind = "raw-dylib",
+    modifiers = "+verbatim"
+)]
+unsafe extern "C" {
+    // Example function.
+    safe fn CFRunLoopGetTypeID() -> core::ffi::c_ulong;
+}
+
+fn main() {
+    let _ = CFRunLoopGetTypeID();
+}

tests/ui/linkage-attr/raw-dylib/macho/cf.rs

@@ -0,0 +1,49 @@
+//! Check that we can link and run a `no_std` binary without.
+
+//@ only-apple
+//@ run-pass
+//@ compile-flags: -Cpanic=abort
+//@ compile-flags: -Clinker=ld -Clink-arg=-syslibroot -Clink-arg=./Empty.sdk
+
+#![allow(incomplete_features)]
+#![feature(raw_dylib_macho)]
+#![feature(lang_items)]
+#![no_std]
+#![no_main]
+
+use core::ffi::{c_char, c_int};
+use core::panic::PanicInfo;
+
+#[link(
+    name = "/usr/lib/libSystem.B.dylib",
+    kind = "raw-dylib",
+    modifiers = "+verbatim",
+    // current_version: 1351,
+    // compatibility_version: 1,
+)]
+#[allow(unused)]
+unsafe extern "C" {
+    #[link_name = "\x01dyld_stub_binder"]
+    unsafe fn dyld_stub_binder();
+}
+
+#[panic_handler]
+fn panic_handler(_info: &PanicInfo<'_>) -> ! {
+    loop {}
+}
+
+#[lang = "eh_personality"]
+extern "C" fn rust_eh_personality(
+    _version: i32,
+    _actions: i32,
+    _exception_class: u64,
+    _exception_object: *mut (),
+    _context: *mut (),
+) -> i32 {
+    loop {}
+}
+
+#[no_mangle]
+extern "C" fn main(_argc: c_int, _argv: *const *const c_char) -> c_int {
+    0
+}