add export executable symbols make run

Author: csmoe

compiler/rustc_codegen_ssa/src/back/linker.rs

@@ -643,7 +643,7 @@ impl<'a> Linker for GccLinker<'a> {
         // Symbol visibility in object files typically takes care of this.
         if crate_type == CrateType::Executable {
             if self.sess.target.override_export_symbols.is_none()
-                && !self.sess.opts.cg.export_executable_symbols
+                && !self.sess.opts.debugging_opts.export_executable_symbols
             {
                 return;
             }
@@ -966,7 +966,7 @@ impl<'a> Linker for MsvcLinker<'a> {
     fn export_symbols(&mut self, tmpdir: &Path, crate_type: CrateType, symbols: &[String]) {
         // Symbol visibility takes care of this typically
         if crate_type == CrateType::Executable {
-            if !self.sess.opts.cg.export_executable_symbols {
+            if !self.sess.opts.debugging_opts.export_executable_symbols {
                 return;
             }
         }

compiler/rustc_interface/src/tests.rs

@@ -572,7 +572,6 @@ fn test_codegen_options_tracking_hash() {
     tracked!(debug_assertions, Some(true));
     tracked!(debuginfo, 0xdeadbeef);
     tracked!(embed_bitcode, false);
-    tracked!(export_executable_symbols, true);
     tracked!(force_frame_pointers, Some(false));
     tracked!(force_unwind_tables, Some(true));
     tracked!(inline_threshold, Some(0xf007ba11));
@@ -734,6 +733,7 @@ fn test_debugging_options_tracking_hash() {
     tracked!(debug_macros, true);
     tracked!(dep_info_omit_d_target, true);
     tracked!(drop_tracking, true);
+    tracked!(export_executable_symbols, true);
     tracked!(dual_proc_macros, true);
     tracked!(fewer_names, Some(true));
     tracked!(force_unstable_if_unmarked, true);

compiler/rustc_session/src/options.rs

@@ -1042,8 +1042,6 @@ options! {
         "allow the linker to link its default libraries (default: no)"),
     embed_bitcode: bool = (true, parse_bool, [TRACKED],
         "emit bitcode in rlibs (default: yes)"),
-    export_executable_symbols: bool = (false, parse_bool, [TRACKED],
-        "export symbols from executables, as if they were dynamic libraries"),
     extra_filename: String = (String::new(), parse_string, [UNTRACKED],
         "extra data to put in each output filename"),
     force_frame_pointers: Option<bool> = (None, parse_opt_bool, [TRACKED],
@@ -1232,6 +1230,8 @@ options! {
         an additional `.html` file showing the computed coverage spans."),
     emit_stack_sizes: bool = (false, parse_bool, [UNTRACKED],
         "emit a section containing stack size metadata (default: no)"),
+    export_executable_symbols: bool = (false, parse_bool, [TRACKED],
+        "export symbols from executables, as if they were dynamic libraries"),
     fewer_names: Option<bool> = (None, parse_opt_bool, [TRACKED],
         "reduce memory use by retaining fewer names within compilation artifacts (LLVM-IR) \
         (default: no)"),

src/test/run-make/export-executable-symbols/Makefile

@@ -0,0 +1,7 @@
+-include ../../run-make-fulldeps/tools.mk
+
+all:
+	$(RUSTC) --edition=2018 --crate-type=cdylib foo.rs -o $(TMPDIR)/libfoo.so
+	$(RUSTC) --edition=2018 -Zexport-executable-symbols -lfoo -L $(TMPDIR) main.rs -o $(TMPDIR)/main
+	$(call $(TMPDIR)/main)
+

src/test/run-make/export-executable-symbols/foo.rs

@@ -0,0 +1,8 @@
+extern "C" {
+    fn exported_symbol() -> i8;
+}
+
+#[no_mangle]
+pub extern "C" fn call_exported_symbol() -> i8 {
+    unsafe { exported_symbol() }
+}

src/test/run-make/export-executable-symbols/main.rs

@@ -1,10 +1,37 @@
 // edition:2018
 
+#![feature(rustc_private)]
+
+extern crate libc;
+use std::ffi::*;
+use std::os::unix::ffi::*;
+
 fn main() {
-    foo();
+    let path = std::env::var("TMPDIR").unwrap();
+    let path = std::path::PathBuf::from(path).join("libfoo.so");
+
+    let s = CString::new(path.as_os_str().as_bytes()).unwrap();
+    let handle = unsafe { libc::dlopen(s.as_ptr(), libc::RTLD_LAZY | libc::RTLD_GLOBAL) };
+    if handle.is_null() {
+        let msg = unsafe { CStr::from_ptr(libc::dlerror() as *const _) };
+        panic!("failed to dlopen lib {:?}", msg);
+    }
+
+    unsafe {
+        libc::dlerror();
+    }
+
+    let raw_string = CString::new("call_exported_symbol").unwrap();
+    let symbol = unsafe { libc::dlsym(handle as *mut libc::c_void, raw_string.as_ptr()) };
+    if symbol.is_null() {
+        let msg = unsafe { CStr::from_ptr(libc::dlerror() as *const _) };
+        panic!("failed to load symbol {:?}", msg);
+    }
+    let func: extern "C" fn() -> i8 = unsafe { std::mem::transmute(symbol) };
+    assert_eq!(func(), 42);
 }
 
 #[no_mangle]
-pub extern "C" fn foo() -> i32 {
-    1 + 1
+pub fn exported_symbol() -> i8 {
+    42
 }