feat: copy frameworks to Frameworks folder, detect linkers, custom target dirs (#4174)

* feat: copy frameworks to Frameworks folder

* add dylib linking to patching

* remove logging

* rename __aslr_offset

* fix android/linux

* support linker flavor

* support custom target dirs

* custom cargo target dir support

* whoops ios

* dlsym doesn't exist on windows

* look for the right main symbol per platform

* distinction between mains

* export main on windows

* enbable rlib caching

* add dx hash

* adjust linking warnings

* update tui with hotreload state

* implement symbol flags

* add flags

* only run ranlib on darwin

* enable lld

* paths

* add harness test for tls

* wip: revert launch mobile

* wip

* fix fullstack mobile

* fix a few bugs
- long paths?
- reverting back to original

* pass-thru fuse-ld args

* fix nan in render, fix empty archives

* consider existing dep files if archive exists

* fmt

* drop msrv

packages/subsecond/subsecond-tests/cross-tls-crate-dylib/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "cross-tls-crate-dylib"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[lib]
+# when testing, use a dylib
+# crate-type = ["dylib"]
+
+[dependencies]

packages/subsecond/subsecond-tests/cross-tls-crate-dylib/src/lib.rs

@@ -0,0 +1,25 @@
+pub use std::cell::Cell;
+use std::{cell::RefCell, thread::LocalKey};
+
+#[derive(Debug)]
+pub struct StoredItem {
+    pub name: String,
+    pub value: f32,
+    pub items: Vec<String>,
+}
+
+thread_local! {
+    pub static BAZ: RefCell<Option<StoredItem>> = const { RefCell::new(None) };
+}
+
+pub fn get_baz() -> &'static LocalKey<RefCell<Option<StoredItem>>> {
+    if BAZ.with(|f| f.borrow().is_none()) {
+        BAZ.set(Some(StoredItem {
+            name: "BAR".to_string(),
+            value: 0.0,
+            items: vec!["item1".to_string(), "item2".to_string()],
+        }));
+    }
+
+    &BAZ
+}

packages/subsecond/subsecond-tests/cross-tls-crate/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "cross-tls-crate"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[dependencies]

packages/subsecond/subsecond-tests/cross-tls-crate/src/lib.rs

@@ -0,0 +1,25 @@
+pub use std::cell::Cell;
+use std::{cell::RefCell, thread::LocalKey};
+
+#[derive(Debug)]
+pub struct StoredItem {
+    pub name: String,
+    pub value: f32,
+    pub items: Vec<String>,
+}
+
+thread_local! {
+    pub static BAR: RefCell<Option<StoredItem>> = const { RefCell::new(None) };
+}
+
+pub fn get_bar() -> &'static LocalKey<RefCell<Option<StoredItem>>> {
+    if BAR.with(|f| f.borrow().is_none()) {
+        BAR.set(Some(StoredItem {
+            name: "BAR".to_string(),
+            value: 0.0,
+            items: vec!["item1".to_string(), "item2".to_string()],
+        }));
+    }
+
+    &BAR
+}

packages/subsecond/subsecond-tests/cross-tls-test/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "subsecond-tls-harness"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[dependencies]
+dioxus-devtools = { workspace = true }
+cross-tls-crate = { path = "../cross-tls-crate" }
+cross-tls-crate-dylib = { path = "../cross-tls-crate-dylib" }

packages/subsecond/subsecond-tests/cross-tls-test/README.md

@@ -0,0 +1,13 @@
+harness for testing cross-crate TLS imports.
+
+TLS is the hardest to get right with binary patchinig since we need to rewrite initializers.
+
+this crate relies on two crates - one as a dylib and the other as an rlib
+
+the dylib should make it into our bundle and the rlib should just be linked.
+
+both shouldn't cause access errors or segfaults during hotpatch.
+
+```sh
+cargo run --package dioxus-cli -- serve --hotpatch
+```

packages/subsecond/subsecond-tests/cross-tls-test/src/main.rs

@@ -0,0 +1,33 @@
+use std::{cell::Cell, thread, time::Duration};
+
+use cross_tls_crate::get_bar;
+use cross_tls_crate_dylib::get_baz;
+
+fn main() {
+    dioxus_devtools::connect_subsecond();
+    loop {
+        dioxus_devtools::subsecond::call(|| {
+            use cross_tls_crate::BAR;
+            use cross_tls_crate_dylib::BAZ;
+
+            thread_local! {
+                pub static FOO: Cell<f32> = const { Cell::new(2.0) };
+            }
+
+            println!("Hello  123s123123s: {}", FOO.get());
+            get_bar().with(|f| println!("Bar: {:?}", f.borrow()));
+            thread::sleep(Duration::from_secs(1));
+
+            FOO.set(2.0);
+            get_bar().with(|f| f.borrow_mut().as_mut().unwrap().value = 3.0);
+            get_baz().with(|f| f.borrow_mut().as_mut().unwrap().value = 4.0);
+
+            BAR.with_borrow(|f| {
+                println!("Bar: {:?}", f);
+            });
+            BAZ.with_borrow(|f| {
+                println!("Baz: {:?}", f);
+            });
+        });
+    }
+}