update

Author: cezarbbb

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -11,7 +11,7 @@ use std::{env, fmt, fs, io, mem, str};
 
 use cc::windows_registry;
 use itertools::Itertools;
-use object::{Object, ObjectSection};
+use object::{Object, ObjectSection, ObjectSymbol};
 use regex::Regex;
 use rustc_arena::TypedArena;
 use rustc_ast::CRATE_NODE_ID;
@@ -2172,42 +2172,80 @@ fn add_rpath_args(
     }
 }
 
-fn add_c_staticlib_symbols(sess: &Session, name: &str, out: &mut Vec<(String, SymbolExportKind)>) {
+fn add_c_staticlib_symbols(
+    sess: &Session,
+    name: &str,
+    out: &mut Vec<(String, SymbolExportKind)>,
+) -> io::Result<()> {
     for search_path in sess.target_filesearch().search_paths(PathKind::Native) {
         let file_path = search_path.dir.join(name);
-        if file_path.exists() {
-            let archive_data = unsafe {
-                Mmap::map(File::open(file_path).expect("couldn't open c staticlib"))
-                    .expect("couldn't map c staticlib")
-            };
-            let archive = object::read::archive::ArchiveFile::parse(&*archive_data)
-                .expect("wanted an c staticlib");
-            for member in archive.members() {
-                let member = member.unwrap();
-                let data = member.data(&*archive_data).unwrap();
-
-                // clang LTO: raw LLVM bitcode
-                if data.len() >= 4 && &data[0..4] == b"BC\xc0\xde" {
-                    return;
-                }
+        if !file_path.exists() {
+            continue;
+        }
 
-                // gcc / clang ELF LTO
-                let object = object::File::parse(&*data).unwrap();
-                if object.sections().into_iter().any(|s| {
-                    s.name().unwrap().starts_with(".gnu.lto_") || s.name().unwrap() == ".llvm.lto"
-                }) {
-                    return;
-                }
+        let archive_map = unsafe { Mmap::map(File::open(&file_path)?)? };
+
+        let archive = object::read::archive::ArchiveFile::parse(&*archive_map)
+            .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
+
+        for member in archive.members() {
+            let member = member.map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
+
+            let data = member
+                .data(&*archive_map)
+                .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
+
+            // clang LTO: raw LLVM bitcode
+            if data.starts_with(b"BC\xc0\xde") {
+                return Err(io::Error::new(
+                    io::ErrorKind::InvalidData,
+                    "LLVM bitcode object in C static library (LTO not supported)",
+                ));
             }
-            for symbol in archive.symbols().unwrap().unwrap() {
-                let symbol = symbol.unwrap();
-                out.push((
-                    String::from_utf8(symbol.name().to_vec()).unwrap(),
-                    SymbolExportKind::Text,
+
+            let object = object::File::parse(&*data)
+                .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
+
+            // gcc / clang ELF / Mach-O LTO
+            if object.sections().any(|s| {
+                s.name().map(|n| n.starts_with(".gnu.lto_") || n == ".llvm.lto").unwrap_or(false)
+            }) {
+                return Err(io::Error::new(
+                    io::ErrorKind::InvalidData,
+                    "LTO object in C static library is not supported",
                 ));
             }
+
+            for symbol in object.symbols() {
+                if symbol.scope() != object::SymbolScope::Dynamic {
+                    continue;
+                }
+
+                let mut name = match symbol.name() {
+                    Ok(n) => n,
+                    Err(_) => continue,
+                };
+
+                if sess.target.is_like_darwin {
+                    if let Some(stripped) = name.strip_prefix('_') {
+                        name = stripped;
+                    }
+                }
+
+                let export_kind = match symbol.kind() {
+                    object::SymbolKind::Text => SymbolExportKind::Text,
+                    object::SymbolKind::Data => SymbolExportKind::Data,
+                    _ => continue,
+                };
+
+                out.push((name.to_string(), export_kind));
+            }
         }
+
+        return Ok(());
     }
+
+    Ok(())
 }
 
 /// Produce the linker command line containing linker path and arguments.
@@ -2241,9 +2279,13 @@ fn linker_with_args(
     let link_output_kind = link_output_kind(sess, crate_type);
 
     let mut export_symbols = codegen_results.crate_info.exported_symbols[&crate_type].clone();
-    if !sess.opts.unstable_opts.include_libs.is_empty() {
-        for name in &sess.opts.unstable_opts.include_libs {
-            add_c_staticlib_symbols(&sess, name, &mut export_symbols);
+    if crate_type == CrateType::Cdylib
+        && !sess.opts.unstable_opts.export_c_static_library_symbols.is_empty()
+    {
+        for name in &sess.opts.unstable_opts.export_c_static_library_symbols {
+            if let Err(err) = add_c_staticlib_symbols(&sess, name, &mut export_symbols) {
+                sess.dcx().fatal(format!("failed to process C static library `{}`: {}", name, err));
+            }
         }
     }
 

compiler/rustc_interface/src/tests.rs

@@ -794,7 +794,8 @@ fn test_unstable_options_tracking_hash() {
     tracked!(embed_metadata, false);
     tracked!(embed_source, true);
     tracked!(emit_thin_lto, false);
-    tracked!(emscripten_wasm_eh, true);
+    tracked!(emscripten_wasm_eh, false);
+    tracked!(export_c_static_library_symbols, vec![String::from("libfoo.a")]);
     tracked!(export_executable_symbols, true);
     tracked!(fewer_names, Some(true));
     tracked!(fixed_x18, true);
@@ -805,7 +806,6 @@ fn test_unstable_options_tracking_hash() {
     tracked!(function_sections, Some(false));
     tracked!(hint_mostly_unused, true);
     tracked!(human_readable_cgu_names, true);
-    tracked!(include_libs, vec![String::from("libfoo.a")]);
     tracked!(incremental_ignore_spans, true);
     tracked!(inline_mir, Some(true));
     tracked!(inline_mir_hint_threshold, Some(123));

compiler/rustc_session/src/options.rs

@@ -2243,6 +2243,9 @@ options! {
         "enforce the type length limit when monomorphizing instances in codegen"),
     experimental_default_bounds: bool = (false, parse_bool, [TRACKED],
         "enable default bounds for experimental group of auto traits"),
+    export_c_static_library_symbols: Vec<String> = (Vec::new(), parse_comma_list, [TRACKED],
+       "export all global symbols from selected upstream c staticlibs when building cdylib \
+        (comma separated crate names)"),
     export_executable_symbols: bool = (false, parse_bool, [TRACKED],
         "export symbols from executables, as if they were dynamic libraries"),
     external_clangrt: bool = (false, parse_bool, [UNTRACKED],
@@ -2286,9 +2289,6 @@ options! {
         "display unnamed regions as `'<id>`, using a non-ident unique id (default: no)"),
     ignore_directory_in_diagnostics_source_blocks: Vec<String> = (Vec::new(), parse_string_push, [UNTRACKED],
         "do not display the source code block in diagnostics for files in the directory"),
-    include_libs: Vec<String> = (Vec::new(), parse_comma_list, [TRACKED],
-       "export all global symbols from selected upstream c staticlibs when building cdylib \
-        (comma separated crate names)"),
     incremental_ignore_spans: bool = (false, parse_bool, [TRACKED],
         "ignore spans during ICH computation -- used for testing (default: no)"),
     incremental_info: bool = (false, parse_bool, [UNTRACKED],

src/doc/unstable-book/src/compiler-flags/export-c-static-library-symbols.md

@@ -0,0 +1,9 @@
+# `export-c-static-library-symbols`
+
+This flag is provided to export all global symbols from selected upstream c staticlibs only when building `cdylib`.
+
+ - This flag will select and import the `Global` symbols of the first matching library it finds.
+
+ - Developers should ensure that there are no libraries with the same name.
+
+ - By default, upstream C static libraries will not export their `Global` symbols regardless of whether `LTO` optimization is enabled. However, after enabling this flag, if the upstream C static library has `LTO` optimization enabled, the compiler will issue an error to inform the developer that the linked C library is invalid.

src/doc/unstable-book/src/compiler-flags/include-libs.md

@@ -0,0 +1 @@
+void my_function() {}

tests/run-make/cdylib-export-c-library-symbols/foo.c

@@ -0,0 +1,8 @@
+extern "C" {
+    pub fn my_function();
+}
+
+#[no_mangle]
+pub extern "C" fn rust_entry() {
+    unsafe { my_function(); }
+}

tests/run-make/cdylib-export-c-library-symbols/foo.rs

@@ -0,0 +1,39 @@
+//@ ignore-nvptx64
+//@ ignore-wasm32-bare
+//@ ignore-i686-pc-windows-msvc
+// FIXME:The symbol mangle rules are slightly different in 32-bit Windows. Need to be resolved.
+//@ ignore-cross-compile
+// Reason: the compiled binary is executed
+
+use run_make_support::{build_native_static_lib, cc, dynamic_lib_name, is_darwin, llvm_nm, rustc};
+
+fn main() {
+    cc().input("foo.c").arg("-c").out_exe("foo.o").run();
+    build_native_static_lib("foo");
+
+    rustc().input("foo.rs").arg("-lstatic=foo").crate_type("cdylib").run();
+
+    let out = llvm_nm()
+        .input(dynamic_lib_name("foo"))
+        .run()
+        .assert_stdout_not_contains_regex("T *my_function");
+
+    rustc()
+        .input("foo.rs")
+        .arg("-lstatic=foo")
+        .crate_type("cdylib")
+        .arg("-Zexport-c-static-library-symbols=libfoo.a")
+        .run();
+
+    if is_darwin() {
+        let out = llvm_nm()
+            .input(dynamic_lib_name("foo"))
+            .run()
+            .assert_stdout_contains_regex("T _my_function");
+    } else {
+        let out = llvm_nm()
+            .input(dynamic_lib_name("foo"))
+            .run()
+            .assert_stdout_contains_regex("T my_function");
+    }
+}