Merge pull request #22 from TheBlueMatt/main

Redo wasm bindings

diff --git a/genbindings.sh b/genbindings.sh
index 2a5e985e99355b71010484d3d3f11c246f8824da..739699977e58319c4c12188761f35e5a11c951a5 100755 (executable)
--- a/genbindings.sh
+++ b/genbindings.sh
@@ -294,39 +294,43 @@ cargo clean --release
 CARGO_PROFILE_RELEASE_LTO=true cargo rustc -v --release -- -C lto
 clang++ $LOCAL_CFLAGS -std=c++11 -flto -O2 demo.cpp target/release/libldk.a -ldl
 
+strip ./a.out
+echo "C++ Bin size and runtime with only RL (LTO) optimized:"
+ls -lha a.out
+time ./a.out > /dev/null
+
 if [ "$HOST_PLATFORM" != "host: x86_64-apple-darwin" -a "$CLANGPP" != "" ]; then
        # If we can use cross-language LTO, use it for building C dependencies (i.e. libsecp256k1) as well
        export CC="$CLANG"
-       export CFLAGS_wasm32_wasi="-target wasm32 -flto"
+       # The cc-rs crate tries to force -fdata-sections and -ffunction-sections on, which
+       # breaks -fembed-bitcode, so we turn off cc-rs' default flags and specify exactly
+       # what we want here.
+       export CFLAGS="$CFLAGS -fPIC -fembed-bitcode"
+       export CRATE_CC_NO_DEFAULTS=true
 fi
 
 if [ "$2" = "false" -a "$(rustc --print target-list | grep wasm32-wasi)" != "" ]; then
        # Test to see if clang supports wasm32 as a target (which is needed to build rust-secp256k1)
        echo "int main() {}" > genbindings_wasm_test_file.c
-       clang -nostdlib -o /dev/null --target=wasm32-wasi -Wl,--no-entry genbindings_wasm_test_file.c > /dev/null 2>&1 &&
-       # And if it does, build a WASM binary without capturing errors
-       cargo rustc -v --target=wasm32-wasi -- -C embed-bitcode=yes &&
-       CARGO_PROFILE_RELEASE_LTO=true cargo rustc -v --release --target=wasm32-wasi -- -C opt-level=s -C linker-plugin-lto -C lto ||
-       echo "Cannot build WASM lib as clang does not seem to support the wasm32-wasi target"
+       if clang -nostdlib -o /dev/null --target=wasm32-wasi -Wl,--no-entry genbindings_wasm_test_file.c > /dev/null 2>&1; then
+               # And if it does, build a WASM binary without capturing errors
+               export CFLAGS_wasm32_wasi="-target wasm32"
+               cargo rustc -v --target=wasm32-wasi
+               export CFLAGS_wasm32_wasi="-target wasm32 -Os"
+               CARGO_PROFILE_RELEASE_LTO=true cargo rustc -v --release --target=wasm32-wasi -- -C embed-bitcode=yes -C opt-level=s -C linker-plugin-lto -C lto
+       else
+               echo "Cannot build WASM lib as clang does not seem to support the wasm32-wasi target"
+       fi
        rm genbindings_wasm_test_file.c
 fi
 
-strip ./a.out
-echo "C++ Bin size and runtime with only RL (LTO) optimized:"
-ls -lha a.out
-time ./a.out > /dev/null
-
 if [ "$HOST_PLATFORM" != "host: x86_64-apple-darwin" -a "$CLANGPP" != "" ]; then
        # Finally, test cross-language LTO. Note that this will fail if rustc and clang++
        # build against different versions of LLVM (eg when rustc is installed via rustup
        # or Ubuntu packages). This should work fine on Distros which do more involved
        # packaging than simply shipping the rustup binaries (eg Debian should Just Work
        # here).
-       # The cc-rs crate tries to force -fdata-sections and -ffunction-sections on, which
-       # breaks -fembed-bitcode, so we turn off cc-rs' default flags and specify exactly
-       # what we want here.
-       export CFLAGS="$CFLAGS -O3 -fPIC -fembed-bitcode"
-       export CRATE_CC_NO_DEFAULTS=true
+       export CFLAGS="$CFLAGS -O3"
        # Rust doesn't recognize CFLAGS changes, so we need to clean build artifacts
        cargo clean --release
        CARGO_PROFILE_RELEASE_LTO=true cargo rustc -v --release -- -C linker-plugin-lto -C lto -C link-arg=-fuse-ld=lld

diff --git a/lightning-c-bindings/src/c_types/mod.rs b/lightning-c-bindings/src/c_types/mod.rs
index 3d45802e8063850cc2f71983e47daeefce11a304..6267b80bc2dd007ba9476f76d01127d2b9a74937 100644 (file)
--- a/lightning-c-bindings/src/c_types/mod.rs
+++ b/lightning-c-bindings/src/c_types/mod.rs
@@ -387,13 +387,15 @@ impl Str {
                if self.len == 0 { return ""; }
                std::str::from_utf8(unsafe { std::slice::from_raw_parts(self.chars, self.len) }).unwrap()
        }
-       pub(crate) fn into_string(self) -> String {
+       pub(crate) fn into_string(mut self) -> String {
                let bytes = if self.len == 0 {
                        Vec::new()
                } else if self.chars_is_owned {
-                       unsafe {
+                       let ret = unsafe {
                                Box::from_raw(std::slice::from_raw_parts_mut(unsafe { self.chars as *mut u8 }, self.len))
-                       }.into()
+                       }.into();
+                       self.chars_is_owned = false;
+                       ret
                } else {
                        let mut ret = Vec::with_capacity(self.len);
                        ret.extend_from_slice(unsafe { std::slice::from_raw_parts(self.chars, self.len) });