Revert some changes

Author: bjorn3

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -2074,7 +2074,7 @@ fn add_linked_symbol_object(
         }
     }
 
-    if sess.target.is_like_windows {
+    if sess.target.is_like_msvc {
         // Currently the compiler doesn't use `dllexport` (an LLVM attribute) to
         // export symbols from a dynamic library. When building a dynamic library,
         // however, we're going to want some symbols exported, so this adds a
@@ -2089,11 +2089,12 @@ fn add_linked_symbol_object(
         // transitively be used and hence need their symbols exported.
         let drectve = exported_symbols
             .into_iter()
-            .map(|(sym, kind)| match (sess.target.is_like_msvc, *kind == SymbolExportKind::Text) {
-                (true, true) => format!(" /EXPORT:\"{sym}\""),
-                (true, false) => format!(" /EXPORT:\"{sym}\",DATA"),
-                (false, true) => format!(" -export:\"{sym}\""),
-                (false, false) => format!(" -export:\"{sym}\",data"),
+            .map(|(sym, kind)| {
+                if *kind == SymbolExportKind::Text {
+                    format!(" /EXPORT:\"{sym}\"")
+                } else {
+                    format!(" /EXPORT:\"{sym}\",DATA")
+                }
             })
             .collect::<Vec<_>>()
             .join("");

compiler/rustc_codegen_ssa/src/back/linker.rs

@@ -800,12 +800,8 @@ impl<'a> Linker for GccLinker<'a> {
             return;
         }
 
-        if self.sess.target.is_like_windows {
-            // We already add -export arguments to the .drectve section of symbols.o
-            return;
-        }
-
-        let path = tmpdir.join("list");
+        let is_windows = self.sess.target.is_like_windows;
+        let path = tmpdir.join(if is_windows { "list.def" } else { "list" });
 
         debug!("EXPORTED SYMBOLS:");
 
@@ -821,6 +817,23 @@ impl<'a> Linker for GccLinker<'a> {
             if let Err(error) = res {
                 self.sess.dcx().emit_fatal(errors::LibDefWriteFailure { error });
             }
+        } else if is_windows {
+            let res: io::Result<()> = try {
+                let mut f = File::create_buffered(&path)?;
+
+                // .def file similar to MSVC one but without LIBRARY section
+                // because LD doesn't like when it's empty
+                writeln!(f, "EXPORTS")?;
+                for (symbol, _) in symbols {
+                    debug!("  _{symbol}");
+                    // Quote the name in case it's reserved by linker in some way
+                    // (this accounts for names with dots in particular).
+                    writeln!(f, "  \"{symbol}\"")?;
+                }
+            };
+            if let Err(error) = res {
+                self.sess.dcx().emit_fatal(errors::LibDefWriteFailure { error });
+            }
         } else {
             // Write an LD version script
             let res: io::Result<()> = try {
@@ -844,6 +857,8 @@ impl<'a> Linker for GccLinker<'a> {
             self.link_arg("-exported_symbols_list").link_arg(path);
         } else if self.sess.target.is_like_solaris {
             self.link_arg("-M").link_arg(path);
+        } else if is_windows {
+            self.link_arg(path);
         } else {
             let mut arg = OsString::from("--version-script=");
             arg.push(path);
@@ -1083,11 +1098,37 @@ impl<'a> Linker for MsvcLinker<'a> {
 
     fn export_symbols(
         &mut self,
-        _tmpdir: &Path,
-        _crate_type: CrateType,
+        tmpdir: &Path,
+        crate_type: CrateType,
         _symbols: &[(String, SymbolExportKind)],
     ) {
-        // We already add /EXPORT arguments to the .drectve section of symbols.o
+        // We already add /EXPORT arguments to the .drectve section of symbols.o. We generate
+        // a .DEF file here anyway as it might prevent auto-export of some symbols.
+
+        // Symbol visibility takes care of this typically
+        if crate_type == CrateType::Executable {
+            let should_export_executable_symbols =
+                self.sess.opts.unstable_opts.export_executable_symbols;
+            if !should_export_executable_symbols {
+                return;
+            }
+        }
+
+        let path = tmpdir.join("lib.def");
+        let res: io::Result<()> = try {
+            let mut f = File::create_buffered(&path)?;
+
+            // Start off with the standard module name header and then go
+            // straight to exports.
+            writeln!(f, "LIBRARY")?;
+            writeln!(f, "EXPORTS")?;
+        };
+        if let Err(error) = res {
+            self.sess.dcx().emit_fatal(errors::LibDefWriteFailure { error });
+        }
+        let mut arg = OsString::from("/DEF:");
+        arg.push(path);
+        self.link_arg(&arg);
     }
 
     fn subsystem(&mut self, subsystem: &str) {