Support acting as startup code of a dynamic linker (#108)

* Support acting as startup code of a dynamic linker

* Fix confusion in computing relocation offset

* Move computation of _DYNAMIC from _entry to a function called by relocate

* Disable the option to act as dynamic linker on x86 for now

Author: bjorn3

example-crates/origin-start-dynamic-linker/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "origin-start"
+version = "0.0.0"
+edition = "2021"
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+# Origin can be depended on just like any other crate. For no_std, disable
+# the default features, and the desired features.
+origin = { path = "../..", default-features = false, features = ["origin-thread", "origin-start", "thread", "alloc", "experimental-relocate"] }
+
+# Crates to help writing no_std code.
+atomic-dbg = { version = "0.1.8", default-features = false }
+rustix-dlmalloc = { version = "0.1.0", features = ["global"] }
+compiler_builtins = { version = "0.1.101", features = ["mem"] }
+
+# This is just an example crate, and not part of the origin workspace.
+[workspace]

example-crates/origin-start-dynamic-linker/README.md

@@ -0,0 +1,5 @@
+This crate demonstrates the use of origin as a plain library API using
+`#![no_std]` and `#![no_main]`.
+
+This version uses `-nostartfiles` and origin is in control from the very
+beginning. This uses origin in an "origin-start" configuration.

example-crates/origin-start-dynamic-linker/build.rs

@@ -0,0 +1,11 @@
+fn main() {
+    // Pass -nostartfiles to the linker. In the future this could be obviated
+    // by a `no_entry` feature: <https://github.com/rust-lang/rfcs/pull/2735>
+    println!("cargo:rustc-link-arg=-nostartfiles");
+    // Set entry point for the dynamic library, making it capable of being
+    // executed like an executable and being used as dynamic linker.
+    println!("cargo:rustc-link-arg=-Wl,-e,_start");
+    // Prevent non R_RELATIVE relocations by forcing all references to global
+    // symbols to be resolved locally.
+    println!("cargo:rustc-link-arg=-Wl,-Bsymbolic");
+}

example-crates/origin-start-dynamic-linker/src/lib.rs

@@ -0,0 +1,57 @@
+//! A simple example acting as dynamic linker using `no_std` and `no_main` and origin's start.
+
+#![no_std]
+#![no_main]
+#![allow(internal_features)]
+#![feature(lang_items)]
+#![feature(core_intrinsics)]
+
+extern crate alloc;
+extern crate compiler_builtins;
+
+use alloc::boxed::Box;
+use atomic_dbg::{dbg, eprintln};
+use origin::{program, thread};
+
+#[panic_handler]
+fn panic(panic: &core::panic::PanicInfo<'_>) -> ! {
+    dbg!(panic);
+    core::intrinsics::abort();
+}
+
+#[lang = "eh_personality"]
+extern "C" fn eh_personality() {}
+
+#[global_allocator]
+static GLOBAL_ALLOCATOR: rustix_dlmalloc::GlobalDlmalloc = rustix_dlmalloc::GlobalDlmalloc;
+
+#[no_mangle]
+unsafe fn origin_main(_argc: usize, _argv: *mut *mut u8, _envp: *mut *mut u8) -> i32 {
+    eprintln!("Hello from main thread");
+
+    program::at_exit(Box::new(|| {
+        eprintln!("Hello from an `program::at_exit` handler")
+    }));
+    thread::at_exit(Box::new(|| {
+        eprintln!("Hello from a main-thread `thread::at_exit` handler")
+    }));
+
+    let thread = thread::create(
+        |_args| {
+            eprintln!("Hello from child thread");
+            thread::at_exit(Box::new(|| {
+                eprintln!("Hello from child thread's `thread::at_exit` handler")
+            }));
+            None
+        },
+        &[],
+        thread::default_stack_size(),
+        thread::default_guard_size(),
+    )
+    .unwrap();
+
+    thread::join(thread);
+
+    eprintln!("Goodbye from main");
+    program::exit(0);
+}

src/arch/aarch64.rs

@@ -1,6 +1,9 @@
 //! Architecture-specific assembly code.
 
 use core::arch::asm;
+#[cfg(all(feature = "experimental-relocate", feature = "origin-start"))]
+#[cfg(relocation_model = "pic")]
+use linux_raw_sys::elf::Elf_Dyn;
 #[cfg(feature = "origin-signal")]
 use linux_raw_sys::general::__NR_rt_sigreturn;
 #[cfg(all(feature = "experimental-relocate", feature = "origin-start"))]
@@ -37,6 +40,23 @@ pub(super) unsafe extern "C" fn _start() -> ! {
     )
 }
 
+/// Compute the dynamic address of `_DYNAMIC`.
+#[cfg(all(feature = "experimental-relocate", feature = "origin-start"))]
+#[cfg(relocation_model = "pic")]
+pub(super) fn dynamic_table_addr() -> *const Elf_Dyn {
+    let addr;
+    unsafe {
+        asm!(
+            ".weak _DYNAMIC",
+            ".hidden _DYNAMIC",
+            "adrp x0, _DYNAMIC",
+            "add x0, x0, #:lo12:_DYNAMIC",
+            out("x0") addr,
+        );
+    }
+    addr
+}
+
 /// Perform a single load operation, outside the Rust memory model.
 ///
 /// This function conceptually casts `ptr` to a `*const *mut c_void` and loads

src/arch/arm.rs

@@ -3,6 +3,9 @@
 use core::arch::asm;
 #[cfg(all(feature = "experimental-relocate", feature = "origin-start"))]
 #[cfg(relocation_model = "pic")]
+use linux_raw_sys::elf::Elf_Dyn;
+#[cfg(all(feature = "experimental-relocate", feature = "origin-start"))]
+#[cfg(relocation_model = "pic")]
 use linux_raw_sys::general::{__NR_mprotect, PROT_READ};
 #[cfg(feature = "origin-signal")]
 use linux_raw_sys::general::{__NR_rt_sigreturn, __NR_sigreturn};
@@ -37,6 +40,27 @@ pub(super) unsafe extern "C" fn _start() -> ! {
     )
 }
 
+/// Compute the dynamic address of `_DYNAMIC`.
+#[cfg(all(feature = "experimental-relocate", feature = "origin-start"))]
+#[cfg(relocation_model = "pic")]
+pub(super) fn dynamic_table_addr() -> *const Elf_Dyn {
+    let addr;
+    unsafe {
+        asm!(
+            ".weak _DYNAMIC",
+            ".hidden _DYNAMIC",
+            "ldr r0, 2f",
+            "1: add r0, pc, r0",
+            "b 3f",
+            ".align 2",
+            "2: .word _DYNAMIC-(1b+8)",
+            "3:",
+            out("r0") addr,
+        );
+    }
+    addr
+}
+
 /// Perform a single load operation, outside the Rust memory model.
 ///
 /// This function conceptually casts `ptr` to a `*const *mut c_void` and loads

src/arch/riscv64.rs

@@ -7,6 +7,9 @@
 use core::arch::asm;
 #[cfg(all(feature = "experimental-relocate", feature = "origin-start"))]
 #[cfg(relocation_model = "pic")]
+use linux_raw_sys::elf::Elf_Dyn;
+#[cfg(all(feature = "experimental-relocate", feature = "origin-start"))]
+#[cfg(relocation_model = "pic")]
 use linux_raw_sys::general::{__NR_mprotect, PROT_READ};
 #[cfg(all(feature = "origin-thread", feature = "thread"))]
 use {
@@ -40,6 +43,22 @@ pub(super) unsafe extern "C" fn _start() -> ! {
     )
 }
 
+/// Compute the dynamic address of `_DYNAMIC`.
+#[cfg(all(feature = "experimental-relocate", feature = "origin-start"))]
+#[cfg(relocation_model = "pic")]
+pub(super) fn dynamic_table_addr() -> *const Elf_Dyn {
+    let addr;
+    unsafe {
+        asm!(
+            ".weak _DYNAMIC",
+            ".hidden _DYNAMIC",
+            "lla a0, _DYNAMIC",
+            out("a0") addr,
+        );
+    }
+    addr
+}
+
 /// Perform a single load operation, outside the Rust memory model.
 ///
 /// This function conceptually casts `ptr` to a `*const *mut c_void` and loads

src/arch/x86.rs

@@ -3,6 +3,9 @@
 use core::arch::asm;
 #[cfg(all(feature = "experimental-relocate", feature = "origin-start"))]
 #[cfg(relocation_model = "pic")]
+use linux_raw_sys::elf::Elf_Dyn;
+#[cfg(all(feature = "experimental-relocate", feature = "origin-start"))]
+#[cfg(relocation_model = "pic")]
 use linux_raw_sys::general::{__NR_mprotect, PROT_READ};
 #[cfg(feature = "origin-signal")]
 use linux_raw_sys::general::{__NR_rt_sigreturn, __NR_sigreturn};
@@ -42,6 +45,29 @@ pub(super) unsafe extern "C" fn _start() -> ! {
     )
 }
 
+/// Compute the dynamic address of `_DYNAMIC`.
+#[cfg(all(feature = "experimental-relocate", feature = "origin-start"))]
+#[cfg(relocation_model = "pic")]
+pub(super) fn dynamic_table_addr() -> *const Elf_Dyn {
+    panic!("acting as dynamic linker not yet supported on 32-bit x86");
+    // FIXME somehow get LLVM to accept `add dword ptr [esp], _DYNAMIC-1b` or
+    // some other way to emit an `R_386_PC32` relocation against `_DYNAMIC`.
+    /*
+    let addr;
+    unsafe {
+        asm!(
+            ".weak _DYNAMIC",
+            ".hidden _DYNAMIC",
+            "call 1f",
+            "1: add dword ptr [esp], _DYNAMIC-1b",
+            "pop eax",
+            out("eax") addr,
+        );
+    }
+    addr
+    */
+}
+
 /// Perform a single load operation, outside the Rust memory model.
 ///
 /// This function conceptually casts `ptr` to a `*const *mut c_void` and loads

src/arch/x86_64.rs

@@ -1,6 +1,9 @@
 //! Architecture-specific assembly code.
 
 use core::arch::asm;
+#[cfg(all(feature = "experimental-relocate", feature = "origin-start"))]
+#[cfg(relocation_model = "pic")]
+use linux_raw_sys::elf::Elf_Dyn;
 #[cfg(feature = "origin-signal")]
 use linux_raw_sys::general::__NR_rt_sigreturn;
 #[cfg(all(feature = "experimental-relocate", feature = "origin-start"))]
@@ -37,6 +40,22 @@ pub(super) unsafe extern "C" fn _start() -> ! {
     )
 }
 
+/// Compute the dynamic address of `_DYNAMIC`.
+#[cfg(all(feature = "experimental-relocate", feature = "origin-start"))]
+#[cfg(relocation_model = "pic")]
+pub(super) fn dynamic_table_addr() -> *const Elf_Dyn {
+    let addr;
+    unsafe {
+        asm!(
+            ".weak _DYNAMIC",
+            ".hidden _DYNAMIC",
+            "lea rax, [rip + _DYNAMIC]",
+            out("rax") addr,
+        );
+    }
+    addr
+}
+
 /// Perform a single load operation, outside the Rust memory model.
 ///
 /// This function conceptually casts `ptr` to a `*const *mut c_void` and loads